public async Task <bool> CreateMovie(MovieDetailsRequestModel movieDetailsRequestModel)
{
var dbMovie = await _movieRepository.GetMovieByTitle(movieDetailsRequestModel.Title);
if (dbMovie != null)
{
throw new MovieConflictException("Movie already exists");
}
var movie = new Movie
{
Title = movieDetailsRequestModel.Title,
Overview = movieDetailsRequestModel.Overview,
Tagline = movieDetailsRequestModel.Tagline,
Budget = movieDetailsRequestModel.Budget,
Revenue = movieDetailsRequestModel.Revenue,
ImdbUrl = movieDetailsRequestModel.ImdbUrl,
TmdbUrl = movieDetailsRequestModel.TmdbUrl,
PosterUrl = movieDetailsRequestModel.PosterUrl,
BackdropUrl = movieDetailsRequestModel.BackdropUrl,
OriginalLanguage = movieDetailsRequestModel.OriginalLanguage,
ReleaseDate = movieDetailsRequestModel.ReleaseDate,
RunTime = movieDetailsRequestModel.RunTime,
Price = movieDetailsRequestModel.Price
};
var createdMovie = await _movieRepository.AddAsync(movie);
if (createdMovie != null && createdMovie.Id > 0)
{
return(true);
}
return(false);
}
public async Task <MovieVm> Handle(CreateMovie request, CancellationToken cancellationToken)
{
var artists = _artistRepository.List(x => request.Actors.Contains(x.Id)).ToList();
var movie = new Movie(Guid.NewGuid(), request.Name, request.ReleaseYear, request.Duration, request.Summary, request.Country, request.MovieGenres);
movie.Actors = artists;
string imageUrl;
if (request.Poster?.HasValue() == true)
{
if (!string.IsNullOrEmpty(movie.Poster))
{
await _fileUtils.RemoveByUrlAsync(movie.Poster);
}
var fileName = $"movies/{Guid.NewGuid()}{request.Poster.Name.GetExtension()}";
imageUrl = await _fileUtils.UploadAsync(request.Poster, fileName);
if (imageUrl.IsNull())
{
throw new Exception("Erro ao Importar o poster");
}
}
else
{
imageUrl = movie.Poster;
}
movie.Poster = imageUrl;
movie = await _movieRepository.AddAsync(movie);
return(movie.ToVm());
}
public async Task <MovieResponse> SaveAsync(Movie movie)
{
try
{
_session.Insert(movie);
_session.Fire();
movie.First = true;
_session.Update(movie);
_session.Fire();
await _movieRepository.AddAsync(movie);
await _unitOfWork.CompleteAsync();
return(new MovieResponse(movie));
}
catch (Exception ex)
{
return(new MovieResponse($"An error occurred when saving the movie: {ex.Message}"));
}
}
//public async Task<IEnumerable<MovieResponseModel>> GetMoviesByGenre(int genreId)
//{
// var movies = await _movieRepository.GetMoviesByGenre(genreId);
// if (!movies.Any()) throw new NotFoundException("Movies for genre", genreId);
// var response = _mapper.Map<IEnumerable<MovieResponseModel>>(movies);
// return response;
//}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
//if (_currentUserService.UserId != favoriteRequest.UserId)
// throw new HttpException(HttpStatusCode.Unauthorized, "You are not Authorized to purchase");
// check whether the user is Admin and can create the movie claim
var movie = _mapper.Map <Movie>(movieCreateRequest);
var createdMovie = await _movieRepository.AddAsync(movie);
// var movieGenres = new List<MovieGenre>();
foreach (var genre in movieCreateRequest.Genres)
{
var movieGenre = new MovieGenre {
MovieId = createdMovie.Id, GenreId = genre.Id
};
//await _genresRepository.AddAsync(movieGenre);
var genresddd = _genresRepository.GetByIdAsync(movieGenre.GenreId);
await _genresRepository.AddAsync(genresddd.Result);
}
return(_mapper.Map <MovieDetailsResponseModel>(createdMovie));
//throw new NotImplementedException();
}
public async Task <ServiceResult <IEnumerable <Genre> > > SendData(ICollection <MovieChoice> data, UserDto user)
{
Movie tmpMovie = new Movie();
Choice tmpChoice = new Choice();
User tmpUser = new User();
List <Genre> tmpGenres = new List <Genre>();
List <Movie> movieExist = (List <Movie>) await _movieService.FillterAll();
foreach (var item in data)
{
tmpMovie.Id = item.Id;
tmpMovie.Name = item.Title;
var isExist = movieExist.Exists(x => x.Id == tmpMovie.Id);
foreach (var item2 in item.genre_ids)
{
var result = await _genreService.GetById(item2);
tmpGenres.Add(result);
tmpMovie.Genres.Add(result);
}
if (!isExist)
{
var deleteDuplicate = tmpMovie.Genres.GroupBy(x => x.Id).Select(x => x.First()).ToList();
tmpMovie.Genres = deleteDuplicate;
await _moviepository.AddAsync(tmpMovie);
tmpMovie = new Movie();
}
}
List <Genre> uniqueGenra = tmpGenres.Distinct().ToList();
List <User> userExist = (List <User>)_userService.GetAll();
var isExistUser = userExist.Exists(x => x.Name == user.Name);
if (!isExistUser)
{
tmpUser.Name = user.Name;
tmpUser.User_Name = user.Nickname;
tmpUser.Email = user.Email;
_userService.Add(tmpUser);
tmpChoice.UserId = tmpUser.Id;
tmpChoice.Genres = uniqueGenra;
await _choiceService.AddAsync(tmpChoice);
_userService.SaveChanges();
}
else
{
User userId = _userService.GetByName(user.Name);
tmpChoice.UserId = userId.Id;
tmpChoice.Genres = uniqueGenra;
await _choiceService.AddAsync(tmpChoice);
}
return(ServiceResult <IEnumerable <Genre> > .SuccessResult(uniqueGenra));
}
public async Task <MovieDetailResponseModel> CreateMovie(MovieCreateRequestModel request)
{
var createdMovie = await _movieRepository.AddAsync(new Movie { Title = request.Title, Budget = request.Budget, Revenue = request.Revenue });
return(new MovieDetailResponseModel {
Id = createdMovie.Id, Title = createdMovie.Title, Budget = createdMovie.Budget, Revenue = request.Revenue
});
}
public async Task <IActionResult> Create([Bind("Id,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (ModelState.IsValid)
{
await _movieRepository.AddAsync(movie);
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task AddMovieAsync(NewMovieDto dto)
{
var newMovie = dto.DtoToEntity();
await _repository.AddAsync(newMovie);
foreach (var item in dto.CastIds)
{
await _castOfMovieRepository.AddAsync(new CastOfMovie { CastId = item, MovieId = newMovie.Id });
}
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var roles = _currentUserService.Roles;
List <string> rolesList = new List <string>();
foreach (var role in roles)
{
rolesList.Add(role);
}
string admin = "Admin";
if (!rolesList.Exists(e => e == admin))
{
throw new Exception("Not Authorized");
}
var movie = new Movie
{
Title = movieCreateRequest.Title,
Overview = movieCreateRequest.Overview,
BackdropUrl = movieCreateRequest.BackdropUrl,
Budget = movieCreateRequest.Budget,
CreatedDate = movieCreateRequest.CreatedDate,
ImdbUrl = movieCreateRequest.ImdbUrl,
OriginalLanguage = movieCreateRequest.OriginalLanguage,
PosterUrl = movieCreateRequest.PosterUrl,
Price = movieCreateRequest.Price,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Tagline = movieCreateRequest.TagLine,
TmdbUrl = movieCreateRequest.TmdbUrl
};
var createdMovie = await _movieRepository.AddAsync(movie);
var response = new MovieDetailsResponseModel()
{
Id = createdMovie.Id,
Title = createdMovie.Title,
Overview = createdMovie.Overview,
BackdropUrl = createdMovie.BackdropUrl,
Budget = createdMovie.Budget,
CreatedDate = createdMovie.CreatedDate,
ImdbUrl = createdMovie.ImdbUrl,
OriginalLanguage = createdMovie.OriginalLanguage,
PosterUrl = createdMovie.PosterUrl,
Price = createdMovie.Price,
ReleaseDate = createdMovie.ReleaseDate,
RunTime = createdMovie.RunTime,
Tagline = createdMovie.Tagline,
TmdbUrl = createdMovie.TmdbUrl
};
return(response);
}
// public async Task AddTicketsAsync(Guid movieId, int amount, decimal price)
// {
// var movie = await _movieRepository.GetOrFailAsync(movieId);
// movie.AddTickets(amount, price);
// await _movieRepository.UpdateAsync(movie);
// }
public async Task CreateAsync(Guid id, string title, string description, string type, string director, string producer, DateTime dateTime)
{
var movie = await _movieRepository.GetAsync(id);
if (movie != null)
{
throw new Exception($"Movie titled: '{title}' already exists.");
}
movie = new Movie(id, title, description, type, director, producer, dateTime);
await _movieRepository.AddAsync(movie);
}
public async Task AddAsync(MovieDTO newMovie)
{
var movie = _mapper.Map <Movie>(newMovie);
if (!IsExistMovie(movie))
{
throw new EntityAlreadyExistsException("Movie already exists");
}
await _movieRepository.AddAsync(movie);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var movie = new Movie
{
Title = movieCreateRequest.Title,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
PosterUrl = movieCreateRequest.PosterUrl,
Budget = movieCreateRequest.Budget,
RunTime = movieCreateRequest.RunTime,
ReleaseDate = movieCreateRequest.ReleaseDate,
Revenue = movieCreateRequest.Revenue,
Price = movieCreateRequest.Price,
OriginalLanguage = movieCreateRequest.OriginalLanguage
};
var createdMovieDetail = await _movieRepository.AddAsync(movie);
if (movieCreateRequest.Genres != null)
{
foreach (var genre in movieCreateRequest.Genres)
{
var movieGenre = new MovieGenre {
MovieId = createdMovieDetail.Id, GenreId = genre.Id
};
await _genresRepository.AddAsync(movieGenre);
}
}
var respose = new MovieDetailsResponseModel
{
Id = createdMovieDetail.Id,
Title = createdMovieDetail.Title,
Overview = createdMovieDetail.Overview,
Tagline = createdMovieDetail.Tagline,
ImdbUrl = createdMovieDetail.ImdbUrl,
TmdbUrl = createdMovieDetail.TmdbUrl,
BackdropUrl = createdMovieDetail.BackdropUrl,
PosterUrl = createdMovieDetail.PosterUrl,
Budget = createdMovieDetail.Budget,
RunTime = createdMovieDetail.RunTime,
ReleaseDate = createdMovieDetail.ReleaseDate,
Revenue = createdMovieDetail.Revenue,
Price = createdMovieDetail.Price,
OriginalLanguage = createdMovieDetail.OriginalLanguage
};
return(respose);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var configMovie = new MapperConfiguration(cfg => cfg.CreateMap <MovieCreateRequest, Movie>());
var mapperMovie = configMovie.CreateMapper();
var movie = mapperMovie.Map <Movie>(movieCreateRequest);
var entity = await _movieRepository.AddAsync(movie);
var config = new MapperConfiguration(cfg => cfg.CreateMap <Movie, MovieDetailsResponseModel>());
var mapper = config.CreateMapper();
return(mapper.Map <MovieDetailsResponseModel>(entity));
}
public async Task <MovieResource> Handle(CreateMovieCommand request, CancellationToken cancellationToken)
{
var movie = mapper.Map <Movie>(request);
await movieRepository.AddAsync(movie, cancellationToken);
await unitOfWork.SaveAsync(cancellationToken);
movie = await movieRepository.GetMovieWithGenre(movie.Id, cancellationToken);
return(mapper.Map <MovieResource>(movie));
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequestModel movieCreateRequestModel)
{
//check whether the user is Admin and can create the movie claim
var movie = new Movie()
{
Title = movieCreateRequestModel.Title,
Overview = movieCreateRequestModel.Overview,
Tagline = movieCreateRequestModel.Tagline,
Revenue = movieCreateRequestModel.Revenue,
Budget = movieCreateRequestModel.Budget,
ImdbUrl = movieCreateRequestModel.ImdbUrl,
TmdbUrl = movieCreateRequestModel.TmdbUrl,
PosterUrl = movieCreateRequestModel.PosterUrl,
BackdropUrl = movieCreateRequestModel.BackdropUrl,
OriginalLanguage = movieCreateRequestModel.OriginalLanguage,
ReleaseDate = movieCreateRequestModel.ReleaseDate,
RunTime = movieCreateRequestModel.RunTime,
Price = movieCreateRequestModel.Price,
Genres = new List <Genre>()
};
foreach (var genre in movieCreateRequestModel.Genres)
{
movie.Genres.Add(new Genre()
{
Id = genre.Id,
Name = genre.Name,
});
}
var newMovie = await _movieRepository.AddAsync(movie);
var moiveResponse = new MovieDetailsResponseModel()
{
Id = newMovie.Id,
Title = newMovie.Title,
Budget = newMovie.Budget,
PosterUrl = newMovie.PosterUrl,
Rating = newMovie.Rating,
ReleaseDate = newMovie.ReleaseDate,
BackdropUrl = newMovie.BackdropUrl,
ImdbUrl = newMovie.ImdbUrl,
Tagline = newMovie.Tagline,
Price = newMovie.Price,
Revenue = newMovie.Revenue,
RunTime = newMovie.RunTime,
Overview = newMovie.Overview,
TmdbUrl = newMovie.TmdbUrl,
};
return(moiveResponse);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var movie = MovieRequestToMovie(movieCreateRequest);
foreach (var genre in movieCreateRequest.Genres)
{
var movieGenre = new MovieGenre {
MovieId = movieCreateRequest.Id, GenreId = genre.Id
};
//await _movieGenreRepo.AddAsync(movieGenre);
}
return(movieToDetialResponse(await _repository.AddAsync(movie)));
}
public async Task <MovieResponse> Handle(CreateMovieCommand request, CancellationToken cancellationToken)
{
var movieEntity = MovieMapper.Mapper.Map <Movie>(request);
if (movieEntity is null)
{
throw new ApplicationException("There is an issue with mapping");
}
var newMovie = await _movieRepository.AddAsync(movieEntity);
var movieResponse = MovieMapper.Mapper.Map <MovieResponse>(newMovie);
return(movieResponse);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var dbMovie = await _movieRepository.GetMovieByTitle(movieCreateRequest.Title);
if (dbMovie != null && string.Equals(dbMovie.Title, movieCreateRequest.Title, StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("Movie Already Exits");
}
var movie = new Movie
{
Id = movieCreateRequest.Id,
Title = movieCreateRequest.Title,
PosterUrl = movieCreateRequest.PosterUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
//Rating = movie.Rating,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
Budget = movieCreateRequest.Budget,
Revenue = movieCreateRequest.Revenue,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Price = movieCreateRequest.Price
};
var createMovie = await _movieRepository.AddAsync(movie);
var response = new MovieDetailsResponseModel
{
Id = createMovie.Id,
Title = createMovie.Title,
PosterUrl = createMovie.PosterUrl,
BackdropUrl = createMovie.BackdropUrl,
//Rating = movie.Rating,
Overview = createMovie.Overview,
Tagline = createMovie.Tagline,
Budget = createMovie.Budget,
Revenue = createMovie.Revenue,
ImdbUrl = createMovie.ImdbUrl,
TmdbUrl = createMovie.TmdbUrl,
ReleaseDate = createMovie.ReleaseDate,
RunTime = createMovie.RunTime,
Price = createMovie.Price
};
return(response);
}
public async Task <MovieResponse> SaveAsync(Movie movie)
{
try
{
await _movieRepository.AddAsync(movie);
await _unitOfWork.CompleteAsync();
return(new MovieResponse(movie));
}
catch (Exception ex)
{
// Do some logging stuff
return(new MovieResponse($"An error occurred when saving the movie: {ex.Message}"));
}
}
public async Task <IActionResult> PostMovie([FromBody] MovieViewModel movie)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newMovie = Mapper.Map <MovieViewModel, Movie>(movie);
await _movieRepository.AddAsync(newMovie);
await _movieRepository.CommitAsync();
movie = Mapper.Map <Movie, MovieViewModel>(newMovie);
return(CreatedAtAction("GetMovie", new { id = movie.ID }, movie));
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var movie = new Movie {
Id = movieCreateRequest.Id,
Title = movieCreateRequest.Title,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
Revenue = movieCreateRequest.Revenue,
Budget = movieCreateRequest.Budget,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
PosterUrl = movieCreateRequest.PosterUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
OriginalLanguage = movieCreateRequest.OriginalLanguage,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Price = movieCreateRequest.Price,
};
var CreatedMovie = await _movieRepository.AddAsync(movie);
foreach (var genre in movieCreateRequest.Genres)
{
var MovieGenre = new MovieGenre {
MovieId = CreatedMovie.Id, GenreId = genre.Id
};
await _movieGenresRepository.AddAsync(MovieGenre);
}
var ReturnedModel = new MovieDetailsResponseModel {
Id = movie.Id,
Title = movie.Title,
Overview = movie.Overview,
Tagline = movie.Tagline,
Revenue = movie.Revenue,
Budget = movie.Budget,
ImdbUrl = movie.ImdbUrl,
TmdbUrl = movie.TmdbUrl,
PosterUrl = movie.PosterUrl,
BackdropUrl = movie.BackdropUrl,
ReleaseDate = movie.ReleaseDate,
RunTime = movie.RunTime,
Price = movie.Price,
};
return(ReturnedModel);
}
public Task <Movie> CreateMovie(MovieRequestModel requestModel)
{
var movie = new Movie()
{
Title = requestModel.Title,
Overview = requestModel.Overview,
Tagline = requestModel.Tagline,
Budget = requestModel.Budget,
Revenue = requestModel.Revenue,
TmdbUrl = requestModel.TmdbUrl,
PosterUrl = requestModel.PosterUrl,
BackdropUrl = requestModel.BackdropUrl,
OriginalLanguage = requestModel.OriginalLanguage,
ReleaseDate = requestModel.ReleaseDate
};
return(_movieRepository.AddAsync(movie));
}
public async Task CreateAsync(MovieCreate movieUi)
{
var actorIds = new List <Guid>();
if (movieUi.GenreId == Guid.Empty)
{
throw new ArgumentException($"Genre can't be null");
}
if (movieUi.FirstActor == Guid.Empty)
{
throw new ArgumentException($"Movie should has at least one actor");
}
var existedActor = await _actorRepository.FindByAsync(e => e.Id == movieUi.FirstActor);
if (existedActor == null)
{
throw new ArgumentException($"Can't create movie with not existed actor id : {movieUi.FirstActor}");
}
var movie = new Movie()
{
Genre = movieUi.Genre,
GenreId = movieUi.GenreId,
Id = Guid.NewGuid(),
Title = movieUi.Title,
Year = movieUi.Year,
};
await _movieRepository.AddAsync(movie);
//Link movie to actors
var actorMovie = new ActorMovie()
{
ActorId = movieUi.FirstActor,
MovieId = movie.Id,
ActorMovieId = Guid.NewGuid()
};
await _actorMovieRepository.AddAsync(actorMovie);
}
public async Task <AddMovieResponseModel> AddMovieAsync(AddMovieRequestModel model, CancellationToken token = default)
{
try
{
await _validatorService.ValidationCheck <AddMovieRequestModelValidator, AddMovieRequestModel>(model);
MovieEntity entity = await model.BuildAdapter().AdaptToTypeAsync <MovieEntity>();
await _movieRepository.AddAsync(entity, token);
AddMovieResponseModel responseModel = await entity.BuildAdapter().AdaptToTypeAsync <AddMovieResponseModel>();
return(responseModel);
}
catch (Exception)
{
return(null);
}
}
public async Task <IActionResult> Create([FromForm] MovieRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.InvalidPayload));
}
var movie = _mapper.Map <MovieEntity>(model);
movie.GenreMovies = new List <GenreMovieEntity>();
model.SelectedGenres.ForEach(item => {
movie.GenreMovies.Add(new GenreMovieEntity()
{
GenreId = item
});
});
movie.DateCreated = DateTime.Now;
if (model.File != null)
{
var filePath = $"/{DateTime.Now.ToFileTime()}_{model.File.FileName}";
using (var stream = new FileStream($"wwwroot/{filePath}", FileMode.Create))
{
var oldPath = $"wwwroot{movie.PosterUrl}";
if (System.IO.File.Exists(oldPath))
{
System.IO.File.Delete(oldPath);
}
await model.File.CopyToAsync(stream);
movie.PosterUrl = filePath;
}
}
await _movieRepository.AddAsync(movie);
await _unitOfWork.SaveChangesAsync();
return(Ok());
}
public async Task <MovieCardResponseModel> CreateMovie(MovieCreateRequestModel movieCreateRequestModel)
{
var movie = new Movie
{
Title = movieCreateRequestModel.Title,
Budget = movieCreateRequestModel.Budget,
Revenue = movieCreateRequestModel.Revenue,
};
var response = await _movieRepository.AddAsync(movie);
var createdMovie = new MovieCardResponseModel
{
Id = response.Id,
Title = response.Title,
Budget = response.Budget,
Revenue = response.Revenue,
};
return(createdMovie);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var movie = new Movie
{
Id = movieCreateRequest.Id,
Title = movieCreateRequest.Title,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
Revenue = movieCreateRequest.Revenue,
Budget = movieCreateRequest.Budget,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
PosterUrl = movieCreateRequest.PosterUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
OriginalLanguage = movieCreateRequest.OriginalLanguage,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Price = movieCreateRequest.Price,
};
await _movieRepository.AddAsync(movie);
var response = new MovieDetailsResponseModel
{
Id = movieCreateRequest.Id,
Title = movieCreateRequest.Title,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
Revenue = movieCreateRequest.Revenue,
Budget = movieCreateRequest.Budget,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
PosterUrl = movieCreateRequest.PosterUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Price = movieCreateRequest.Price,
Genres = movieCreateRequest.Genres
};
return(response);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var movie = new Movie();
{
movieCreateRequest.Id = movie.Id;
movieCreateRequest.Title = movie.Title;
movieCreateRequest.PosterUrl = movie.PosterUrl;
movieCreateRequest.BackdropUrl = movie.BackdropUrl;
movieCreateRequest.Overview = movie.Overview;
movieCreateRequest.Tagline = movie.Tagline;
movieCreateRequest.Budget = movie.Budget;
movieCreateRequest.Revenue = movie.Revenue;
movieCreateRequest.ImdbUrl = movie.ImdbUrl;
movieCreateRequest.TmdbUrl = movie.TmdbUrl;
movieCreateRequest.ReleaseDate = movie.ReleaseDate;
movieCreateRequest.RunTime = movie.RunTime;
movieCreateRequest.Price = movie.Price;
}
var movies = await _movieRepository.AddAsync(movie);
var responseMovies = new MovieDetailsResponseModel
{
Id = movieCreateRequest.Id,
Title = movieCreateRequest.Title,
PosterUrl = movieCreateRequest.PosterUrl,
BackdropUrl = movieCreateRequest.BackdropUrl,
Rating = movie.Rating,
Overview = movieCreateRequest.Overview,
Tagline = movieCreateRequest.Tagline,
Budget = movieCreateRequest.Budget,
Revenue = movieCreateRequest.Revenue,
ImdbUrl = movieCreateRequest.ImdbUrl,
TmdbUrl = movieCreateRequest.TmdbUrl,
ReleaseDate = movieCreateRequest.ReleaseDate,
RunTime = movieCreateRequest.RunTime,
Price = movieCreateRequest.Price,
//FavoritesCount = movieCreateRequest,
};
return(responseMovies);
}
public async Task <Result <Exception, Guid> > Handle(MovieRegisterCommand request, CancellationToken cancellationToken)
{
var movie = _mapper.Map <MovieRegisterCommand, Movie>(request);
var findGenreCallback = await _genreRepository.GetById(movie.GenreId);
if (findGenreCallback.IsFailure)
{
return(findGenreCallback.Failure);
}
movie.SetGenre(findGenreCallback.Success);
var addMovieCallback = await _movieRepository.AddAsync(movie);
if (addMovieCallback.IsFailure)
{
return(addMovieCallback.Failure);
}
return(addMovieCallback.Success.Id);
}
public async Task <MovieDetailsResponseModel> CreateMovie(MovieCreateRequest movieCreateRequest)
{
var temp = new Movie
{
BackdropUrl = movieCreateRequest.BackdropUrl,
Budget = movieCreateRequest.Budget,
Id = movieCreateRequest.Id,
ImdbUrl = movieCreateRequest.ImdbUrl,
PosterUrl = movieCreateRequest.PosterUrl,
Overview = movieCreateRequest.Overview,
Price = movieCreateRequest.Price,
ReleaseDate = movieCreateRequest.ReleaseDate,
TmdbUrl = movieCreateRequest.TmdbUrl,
Title = movieCreateRequest.Title,
Tagline = movieCreateRequest.Tagline,
RunTime = movieCreateRequest.RunTime,
Revenue = movieCreateRequest.Revenue,
CreatedDate = DateTime.Today
};
await _movieRepository.AddAsync(temp);
return(new MovieDetailsResponseModel
{
BackdropUrl = movieCreateRequest.BackdropUrl,
Budget = movieCreateRequest.Budget,
Id = movieCreateRequest.Id,
ImdbUrl = movieCreateRequest.ImdbUrl,
PosterUrl = movieCreateRequest.PosterUrl,
Overview = movieCreateRequest.Overview,
Price = movieCreateRequest.Price,
ReleaseDate = movieCreateRequest.ReleaseDate,
TmdbUrl = movieCreateRequest.TmdbUrl,
Title = movieCreateRequest.Title,
Tagline = movieCreateRequest.Tagline,
RunTime = movieCreateRequest.RunTime,
Revenue = movieCreateRequest.Revenue
});
}
