public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
var movieDB = await context.Movies.FirstOrDefaultAsync(x => x.Id == id);
if (movieDB == null)
{
return(NotFound());
}
movieDB = mapper.Map(movieCreationDTO, movieDB);
if (movieCreationDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.Poster.FileName);
movieDB.Poster =
await fileStorageService.EditFile(content, extension, containerName,
movieDB.Poster,
movieCreationDTO.Poster.ContentType);
}
}
await context.Database.ExecuteSqlInterpolatedAsync($"delete from MoviesActors where MovieId = {movieDB.Id}; delete from MoviesGenres where MovieId = {movieDB.Id}");
AnnotateActorsOrder(movieDB);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var entity = _mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.Poster.FileName);
entity.Poster = await _filesStorage.SaveFile(content, extension, container, movieCreationDTO.Poster.ContentType);
}
}
AsignActrorsOrder(entity);
_context.Add(entity);
await _context.SaveChangesAsync();
var dto = _mapper.Map <MovieDTO>(entity);
return(new CreatedAtRouteResult("getMovie", new { id = entity.Id }, dto));
}
public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
var movie = await context.Movies.Include(x => x.MoviesActors)
.Include(x => x.MoviesGenres)
.Include(x => x.MovieTheatersMovies)
.FirstOrDefaultAsync(x => x.Id == id);
if (movie == null)
{
return(NotFound());
}
movie = mapper.Map(movieCreationDTO, movie);
if (movieCreationDTO.Poster != null)
{
movie.Poster = await fileStorageService.EditFile(container, movieCreationDTO.Poster,
movie.Poster);
}
AnnotateActorsOrder(movie);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <MovieDTO> > Post([FromForm] MovieCreationDTO movieCreationDto)
{
TryValidateModel(movieCreationDto);
var movieDb = this.mapper.Map <Movie>(movieCreationDto);
if (movieCreationDto.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDto.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDto.Poster.FileName);
movieDb.Poster = await this.fileManager.SaveFile(content, extension, this.container, movieCreationDto.Poster.ContentType);
}
}
this.orderActors(movieDb);
this.context.Movies.Add(movieDb);
await this.context.SaveChangesAsync();
var movieDto = this.mapper.Map <MovieDTO>(movieDb);
return(new CreatedAtRouteResult("GetMovie", new { Id = movieDto.Id }, movieDto));
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
Movie movie = mapper.Map <Movie>(movieCreationDTO);
return(Ok());
string dbpath = "";
if (movieCreationDTO.Poster != null)
{
if (FileHelper.CheckIfImageFile(movieCreationDTO.Poster))
{
dbpath = await FileHelper.WriteFile(movieCreationDTO.Poster);
}
else
{
return(BadRequest(new { message = "Invalid file extension" }));
}
}
movie.Title = movieCreationDTO.Title;
movie.Summary = movieCreationDTO.Summary;
movie.InTheaters = movieCreationDTO.InTheaters;
movie.ReleaseDate = movieCreationDTO.ReleaseDate;
movie.Poster = dbpath;
dbcontext.Movies.Add(movie);
await dbcontext.SaveChangesAsync();
MovieDTO movieDTO = mapper.Map <MovieDTO>(movie);
return(new CreatedAtRouteResult("GetMovie", new Movie {
Id = movie.Id
}, movieDTO));
}
public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreation)
{
var movieDb = await dbContext.Movies.FirstOrDefaultAsync(m => m.Id == id);
if (movieDb == null)
{
return(NotFound());
}
movieDb = mapper.Map(movieCreation, movieDb);
if (movieCreation.Picture == null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreation.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreation.Picture.FileName);
movieDb.Picture =
await fileStorageService.EditFile(content, extension, containerName,
movieDb.Picture,
movieCreation.Picture.ContentType);
}
}
await dbContext.Database.ExecuteSqlInterpolatedAsync($"DELETE FROM MoviesActors WHERE MovieId = {movieDb.Id}; DELETE FROM MoviesGenres WHERE MovieId = {movieDb.Id};");
AnnotateActorsOrder(movieDb);
await dbContext.SaveChangesAsync();
return(NoContent());
}
public virtual async Task <Movie> AddDTO(MovieCreationDTO movieCreationDTO)
{
var movie = _mapper.Map <Movie>(movieCreationDTO);
// another way without automapper (ignored in AutomapperProfile)
if (movieCreationDTO.GenresIds.Count > 0)
{
var genres = applicationDb.Genres.ToList();
foreach (var id in movieCreationDTO.GenresIds)
{
movie.Genres.Add(genres.First(g => g.Id == id));
}
}
if (movieCreationDTO.MovieTheatersIds.Count > 0)
{
var movieTheaters = applicationDb.MovieTheaters.ToList();
foreach (var id in movieCreationDTO.MovieTheatersIds)
{
movie.MovieTheaters.Add(movieTheaters.First(mt => mt.Id == id));
}
}
if (movieCreationDTO.Poster != null)
{
movie.Poster = await fileStorageService.SaveFile(containerName, movieCreationDTO.Poster);
}
AnnotateActorsOrder(movie);
return(await Attach(movie));
}
public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
var movieDB = await _context.Movies
.Include(x => x.MoviesActors)
.Include(x => x.MoviesGenres)
.FirstOrDefaultAsync(x => x.Id == id);
if (movieDB == null)
{
return(NotFound());
}
movieDB = _mapper.Map(movieCreationDTO, movieDB);
if (movieCreationDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.Poster.FileName);
movieDB.Poster = await _filesStorage.EditFile(content, extension, container, movieDB.Poster, movieCreationDTO.Poster.ContentType);
}
}
AsignActrorsOrder(movieDB);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var movie = mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.Poster.FileName);
movie.Poster =
await fileStorageService.SaveFile(content, extension, containerName,
movieCreationDTO.Poster.ContentType);
}
}
AnnotateActorsOrder(movie);
context.Add(movie);
await context.SaveChangesAsync();
var movieDTO = mapper.Map <MovieDTO>(movie);
return(new CreatedAtRouteResult("getMovie", new { id = movie.Id }, movieDTO));
}
public async Task <ActionResult> UpdateMovie(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
Movie movieDb = await dbcontext.Movies.AsNoTracking().FirstOrDefaultAsync(m => m.Id == id);
if (movieDb == null)
{
return(NotFound());
}
if (movieCreationDTO.Poster != null)
{
FileHelper.DeleteFile(movieDb.Poster);
movieDb.Poster = await FileHelper.WriteFile(movieCreationDTO.Poster);
}
movieDb = mapper.Map(movieCreationDTO, movieDb);
movieDb.Id = id;
movieDb.Poster = movieDb.Poster;
dbcontext.Entry(movieDb).State = EntityState.Modified;
await dbcontext.SaveChangesAsync();
MovieDTO movieDTO = mapper.Map <MovieDTO>(movieDb);
return(new CreatedAtRouteResult("", new Movie {
Id = movieDb.Id
}, movieDTO));
}
public async Task SetMovieDirectorsGenresCastsListAsync(Movie movie, MovieCreationDTO movieCreationDTO)
{
movie.Genres = await ListGenres(movieCreationDTO);
movie.Directors = await ListDirectors(movieCreationDTO);
movie.Countries = await ListCountries(movieCreationDTO);
}
public async Task <ActionResult <int> > PostMovie([FromForm] MovieCreationDTO movieCreationDTO)
{
var newMovie = await repository.AddDTO(movieCreationDTO);
if (newMovie == null)
{
return(BadRequest());
}
return(newMovie.Id);
}
// Update
public async Task <bool> Update(MovieCreationDTO movieCreationDTO)
{
var movieEntity = await _context.Movies.SingleOrDefaultAsync(m => m.Id == movieCreationDTO.Id);
if (movieEntity == null)
{
return(false);
}
_mapper.Map <MovieCreationDTO, Movie>(movieCreationDTO, movieEntity);
return((await _context.SaveChangesAsync()) > 0);
}
public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
var editedMovie = await repository.Update(id, movieCreationDTO);
if (editedMovie == null)
{
return(NotFound());
}
return(NoContent());
}
private List <MoviesGenres> MapMoviesGenres(MovieCreationDTO movieCreationDTO, Movie movie)
{
var result = new List <MoviesGenres>();
foreach (var id in movieCreationDTO.GenresIds)
{
result.Add(new MoviesGenres()
{
GenreId = id
});
}
return(result);
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var exists = await _moviesService.CheckImdbIdAsync(movieCreationDTO.ImdbId);
if (exists == 1)
{
return(BadRequest($"ImdbId {movieCreationDTO.ImdbId} already exists."));
}
var movieDTO = await _moviesService.AddMovieAsync(movieCreationDTO);
return(new CreatedAtRouteResult("getMovie", new { Id = movieDTO.Id }, movieDTO));
}
private List <MoviesActors> MapMovieActors(MovieCreationDTO movieCreationDTO, Movie movie)
{
var result = new List <MoviesActors>();
foreach (var actor in movieCreationDTO.Actors)
{
result.Add(new MoviesActors()
{
ActorId = actor.PersonId, Character = actor.Character
});
}
return(result);
}
private List <MoviesGenres> MapMoviesGenres(MovieCreationDTO movieCreationDTO, Movie movie)
{
var result = new List <MoviesGenres>();
for (int i = 0; i <= movieCreationDTO.Genresids.Count(); i++)
{
result.Add(new MoviesGenres()
{
GenreId = i
});
}
return(result);
}
public async Task <Movie> Update(int id, MovieCreationDTO movieCreationDTO)
{
var movie = await applicationDb.Movies.Include(x => x.MoviesActors)
.Include(x => x.Genres)
.Include(x => x.MovieTheaters)
.FirstOrDefaultAsync(x => x.Id == id);
if (movie == null)
{
return(null);
}
movie = _mapper.Map(movieCreationDTO, movie);
if (movieCreationDTO.GenresIds.Count > 0)
{
var genres = applicationDb.Genres.ToList();
foreach (var genreId in movieCreationDTO.GenresIds)
{
movie.Genres.Add(genres.First(g => g.Id == genreId));
}
}
if (movieCreationDTO.MovieTheatersIds.Count > 0)
{
var movieTheaters = applicationDb.MovieTheaters.ToList();
foreach (var movieTheaterId in movieCreationDTO.MovieTheatersIds)
{
movie.MovieTheaters.Add(movieTheaters.First(mt => mt.Id == movieTheaterId));
}
}
if (movieCreationDTO.Poster != null)
{
movie.Poster = await fileStorageService.EditFile(containerName, movieCreationDTO.Poster, movie.Poster);
}
AnnotateActorsOrder(movie);
try
{
await applicationDb.SaveChangesAsync();
}
catch (Exception ex)
{
Debug.WriteLine("{0} Exception caught.", ex);
}
return(movie);
}
public async Task <MovieDTO> AddMovieAsync(MovieCreationDTO movieCreationDTO)
{
var movie = _mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Picture != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.Picture.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.Picture.FileName);
movie.Picture =
await _fileStorageService.SaveFile(content, extension, _containerName,
movieCreationDTO.Picture.ContentType);
}
}
if (movieCreationDTO.BannerImage != null)
{
using (var memoryStream = new MemoryStream())
{
await movieCreationDTO.BannerImage.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(movieCreationDTO.BannerImage.FileName);
movie.BannerImage =
await _fileStorageService.SaveFile(content, extension, _containerName,
movieCreationDTO.BannerImage.ContentType);
}
}
this.AnnotateCastsOrder(movie);
await SetMovieDirectorsGenresCastsListAsync(movie, movieCreationDTO);
await AddCategoryToPerson(movie);
_dbContext.Add(movie);
try
{
await this.SaveChangesAsync();
_logger.LogInfo($"Movie with ID {movie.Id} was added successfully.");
await SetMovieRatingsAsync(movie);
}
catch (Exception ex)
{
_logger.LogWarn($"Failed to add movie {movie.Id}. Exception: {ex}");
}
return(_mapper.Map <MovieDTO>(movie));
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var movie = _mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Poster != null)
{
movie.Poster = await _fileStorage.SaveFile(container, movieCreationDTO.Poster);
}
AnnotateActorsOrder(movie);
_ctx.Add(movie);
await _ctx.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> Put(int id, [FromForm] MovieCreationDTO movieCreationDTO)
{
var result = await _moviesService.UpdateMovieAsync(id, movieCreationDTO);
if (result == -1)
{
return(NotFound());
}
else if (result == 0)
{
return(BadRequest("Failed to save changes."));
}
return(NoContent());
}
private async Task <List <Person> > ListDirectors(MovieCreationDTO movieCreationDTO)
{
if (movieCreationDTO.DirectorsId == null)
{
return(null);
}
var result = new List <Person>();
foreach (var id in movieCreationDTO.DirectorsId)
{
result.Add(await _dbContext.People.FirstOrDefaultAsync(x => x.Id == id));
}
return(result);
}
public async Task <ActionResult <int> > Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var movie = mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Poster != null)
{
movie.Poster = await fileStorageService.SaveFile(container, movieCreationDTO.Poster);
}
AnnotateActorsOrder(movie);
context.Add(movie);
await context.SaveChangesAsync();
return(movie.Id);
}
private async Task <List <Country> > ListCountries(MovieCreationDTO movieCreationDTO)
{
if (movieCreationDTO.CountriesId == null)
{
return(null);
}
var result = new List <Country>();
foreach (var id in movieCreationDTO.CountriesId)
{
result.Add(await _dbContext.Countries.FirstOrDefaultAsync(x => x.Id == id));
}
return(result);
}
private async Task <List <Genre> > ListGenres(MovieCreationDTO movieCreationDTO)
{
if (movieCreationDTO.GenresId == null)
{
return(null);
}
var result = new List <Genre>();
var genres = await _dbContext.Genres.ToListAsync();
foreach (var id in movieCreationDTO.GenresId)
{
result.Add(genres.FirstOrDefault(x => x.Id == id));
}
return(result);
}
public async Task <ActionResult> Post([FromForm] MovieCreationDTO movieCreationDTO)
{
var entity = this.mapper.Map <Movie>(movieCreationDTO);
if (movieCreationDTO.Poster != null)
{
entity.Poster = await this.fileStorageService.SaveFile(STORAGE_CONTAINER_NAME, movieCreationDTO.Poster);
}
this.AnnotateActorsOrder(entity);
this.dbContext.Add(entity);
await this.dbContext.SaveChangesAsync();
return(this.NoContent());
}
// Add
public async Task <bool> Add(MovieCreationDTO movieCreationDTO)
{
try
{
var movie = _mapper.Map <Movie>(movieCreationDTO);
_context.Movies.Add(movie);
await _context.SaveChangesAsync();
_logger.LogInformation($"Movie with ID {movie.Id} was added.");
return(true);
}
catch (DbUpdateConcurrencyException e)
{
_logger.LogWarning($"There was an exception while adding movie with ID {movieCreationDTO.Id}. Exception:{e}");
return(false);
}
}
private List <MovieTheatersMovies> MapMovieTheaters(MovieCreationDTO movieCreationDTO, Movie movie)
{
var result = new List <MovieTheatersMovies>();
if (movieCreationDTO.MoviesTheatersIds == null)
{
return(result);
}
foreach (var id in movieCreationDTO.MoviesTheatersIds)
{
result.Add(new MovieTheatersMovies()
{
MovieTheaterId = id
});
}
return(result);
}
private List <MoviesActors> MapMoviesActors(MovieCreationDTO movieCreationDto, Movie movie)
{
var result = new List <MoviesActors>();
if (movieCreationDto.Actors == null)
{
return(result);
}
foreach (var actor in movieCreationDto.Actors)
{
result.Add(new MoviesActors()
{
ActorId = actor.ActorId, Character = actor.Character
});
}
return(result);
}
