public async Task <ActionResult <FilmModel> > UpdateFilm(string filmName, FilmModel model)
{
try
{
var directorModelValidationResult = ModelsValidator.ValidateDirectorModel(model);
if (!directorModelValidationResult.Item1)
{
return(BadRequest(directorModelValidationResult.Item2));
}
var actorsModelValidationResult = ModelsValidator.ValidateActorModels(model);
if (!actorsModelValidationResult.Item1)
{
return(BadRequest(actorsModelValidationResult.Item2));
}
var film = await _repository.GetFilmByTitleAsync(filmName);
if (film == null)
{
return(BadRequest("Film doesn't exist in db please add film with post method /api/films"));
}
_mapper.Map(model, film);
var updateDirectorResult = await UpdateDirectorAsync(film);
if (!updateDirectorResult.Item1)
{
return(BadRequest(updateDirectorResult.Item2));
}
var updateCastResult = await UpdateCastAsync(film);
if (!updateCastResult.Item1)
{
return(BadRequest(updateCastResult.Item2));
}
if (await _repository.SaveChangesAsync())
{
film = await _repository.GetFilmByTitleAsync(film.Title, true, true);
return(_mapper.Map <FilmModel>(film));
}
return(StatusCode(StatusCodes.Status500InternalServerError, "It looks like no changes were made"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task CreateAchievement(AchievementCreateDTO Achievement, CancellationToken Cancel)
{
if (ModelsValidator.AchievementIsValid((Mapper.Map <AchievementUpdateDTO>(Achievement))))
{
var _Achievement = Mapper.Map <Achievement>(Achievement);
_Achievement.Id = new Guid();
await UnitOfWork.AchievementRepository.Create(_Achievement, Cancel);
await UnitOfWork.SaveChangesAsync(Cancel);
}
else
{
throw new ArgumentException();
}
}
public async Task CreateUser(UserCreateDTO User, CancellationToken Cancel)
{
if (ModelsValidator.UserCreateIsValid(User) && IsCorrectRole(User))
{
var _User = Mapper.Map <User>(User);
_User.Id = new Guid();
using (SHA256 Sha256Hash = SHA256.Create())
{
var ByteArray = Sha256Hash.ComputeHash(Encoding.ASCII.GetBytes(_User.Password));
_User.Password = Encoding.UTF8.GetString(ByteArray, 0, ByteArray.Length);
}
await UnitOfWork.UserRepository.Create(_User, Cancel);
if (_User.UserRoles == null)
{
_User.UserRoles = new List <UserRole>();
}
if (_User.UserAchievements == null)
{
_User.UserAchievements = new List <UserAchievement>();
}
if (_User.Events == null)
{
_User.Events = new List <Event>();
}
foreach (var Role in User.Roles)
{
_User.UserRoles.Add(await GenerateUserRole(_User, Role, Cancel));
}
await UnitOfWork.SaveChangesAsync(Cancel);
}
else
{
throw new ArgumentException();
}
}
public async Task UpdateCurrentUser(string Token, UserUpdateDTO NewUser, CancellationToken Cancel)
{
if (!ModelsValidator.UserUpdateIsValid(NewUser))
{
throw new ArgumentException();
}
var Claims = HelperService.GetClaimsFromToken(Token, Key);
var UserId = HelperService.GetIdFromToken(Claims);
if (UserId == null)
{
throw new ArgumentNullException();
}
await UserService.UpdateUser(new Guid(UserId), NewUser, Cancel);
await UnitOfWork.SaveChangesAsync(Cancel);
}
public async Task <ActionResult <ActorModel> > Put(string firstName, string lastName, ActorModel model)
{
try
{
var filmsModelValidationResult = ModelsValidator.ValidateFilmModels(model);
if (!filmsModelValidationResult.Item1)
{
return(BadRequest(filmsModelValidationResult.Item2));
}
var actor = await _repository.GetActorByNameAsync(firstName, lastName);
if (actor == null)
{
return(BadRequest($"Actor {firstName} {lastName} doesn't exist"));
}
_mapper.Map(model, actor);
var updateFilmsResult = await UpdateActorsFilms(actor);
if (!updateFilmsResult.Item1)
{
return(BadRequest(updateFilmsResult.Item2));
}
if (await _repository.SaveChangesAsync())
{
actor = await _repository.GetActorByNameAsync(firstName, lastName, true);
return(_mapper.Map <ActorModel>(actor));
}
return(StatusCode(StatusCodes.Status500InternalServerError, "It looks like no changes were made"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task UpdateAchievement(Guid Id, AchievementUpdateDTO Achievement, CancellationToken Cancel)
{
if (ModelsValidator.AchievementIsValid(Achievement))
{
if ((await UnitOfWork.AchievementRepository
.DbSet.FirstOrDefaultAsync(item => item.Id == Id, Cancel)) == null)
{
throw new ArgumentNullException();
}
var _Achievement = await UnitOfWork.AchievementRepository.DbSet.FirstOrDefaultAsync(item => item.Id == Id, Cancel);
Mapper.Map(Achievement, _Achievement);
UnitOfWork.AchievementRepository.Update(_Achievement);
await UnitOfWork.SaveChangesAsync(Cancel);
}
else
{
throw new ArgumentException();
}
}
public async Task UpdateUser(Guid Id, UserUpdateDTO User, CancellationToken Cancel)
{
if (ModelsValidator.UserUpdateIsValid(User))
{
if ((await UnitOfWork.UserRepository
.DbSet.FirstOrDefaultAsync(item => item.Id == Id)) == null)
{
throw new ArgumentNullException();
}
var _User = await UnitOfWork.UserRepository.DbSet.FirstOrDefaultAsync(item => item.Id == Id, Cancel);
Mapper.Map(User, _User);
UnitOfWork.UserRepository.Update(_User);
await UnitOfWork.SaveChangesAsync(Cancel);
}
else
{
throw new ArgumentException();
}
}
public async Task <ActionResult <DirectorModel> > Put(string firstName, string lastName, DirectorModel model)
{
try
{
var filmsModelValidationResult = ModelsValidator.ValidateFilmModels(model);
if (!filmsModelValidationResult.Item1)
{
return(BadRequest(filmsModelValidationResult.Item2));
}
var director = await _repository.GetDirectorByNameAsync(firstName, lastName);
if (director == null)
{
return(BadRequest("There is director with the name in db"));
}
_mapper.Map(model, director);
var filmsUpdateResult = await UpdateFilmForDirector(director);
if (!filmsUpdateResult.Item1)
{
return(BadRequest(filmsUpdateResult.Item2));
}
if (await _repository.SaveChangesAsync())
{
return(Created($"api/Directors/{model.FirstName}/{model.LastName}", _mapper.Map <DirectorModel>(director)));
}
return(StatusCode(StatusCodes.Status500InternalServerError, "It looks like no changes were made"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public async Task <ActionResult <DirectorModel> > Post(DirectorModel model)
{
try
{
if (model.Films != null && model.Films.Count() > 0)
{
return(BadRequest("Please add director first. Than you can update list of films with PUT request"));
}
var filmsModelValidationResult = ModelsValidator.ValidateFilmModels(model);
if (!filmsModelValidationResult.Item1)
{
return(BadRequest(filmsModelValidationResult.Item2));
}
var existingDirector = await _repository.GetDirectorByNameAsync(model.FirstName, model.LastName);
if (existingDirector != null)
{
return(BadRequest("There is director with the name in db"));
}
var director = _mapper.Map <Director>(model);
_repository.Add(director);
if (await _repository.SaveChangesAsync())
{
return(Created($"api/Directors/{model.FirstName}/{model.LastName}", _mapper.Map <DirectorModel>(director)));
}
return(StatusCode(StatusCodes.Status500InternalServerError, "It looks like no changes were made"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
public JObject Validate()
{
return(ModelsValidator.Validate(this));
}
public async Task <ActionResult <FilmModel> > Post(FilmModel model)
{
try
{
if (model.Cast != null && model.Cast.Count() > 0)
{
return(BadRequest("Please add film first. Update films cast with updatefilm method"));
}
var directorModelValidationResult = ModelsValidator.ValidateDirectorModel(model);
if (!directorModelValidationResult.Item1)
{
return(BadRequest(directorModelValidationResult.Item2));
}
var actorsModelValidationResult = ModelsValidator.ValidateActorModels(model);
if (!actorsModelValidationResult.Item1)
{
return(BadRequest(actorsModelValidationResult.Item2));
}
var film = await _repository.GetFilmByTitleAsync(model.Title);
if (film != null)
{
return(BadRequest("There is a film with same name"));
}
film = _mapper.Map <Film>(model);
var updateDirectorResult = await UpdateDirectorAsync(film);
if (!updateDirectorResult.Item1)
{
return(BadRequest(updateDirectorResult.Item2));
}
var updateCastResult = await UpdateCastAsync(film);
if (!updateCastResult.Item1)
{
return(BadRequest(updateCastResult.Item2));
}
_repository.Add(film);
if (await _repository.SaveChangesAsync())
{
film = await _repository.GetFilmByTitleAsync(model.Title, true, true);
return(Created($"/api/films/{model.Title}", _mapper.Map <FilmModel>(film)));
}
return(StatusCode(StatusCodes.Status500InternalServerError, "It looks like no changes were made"));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database failure"));
}
}
