public async Task <IActionResult> DeletePhoto(int userId, int id) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } // Get user from repo var user = await _repo.GetUser(userId); // Check for right user if (!user.Photos.Any(p => p.Id == id)) { return(Unauthorized()); } var photoFromRepo = await _repo.GetPhoto(id); if (photoFromRepo.IsMain) { return(BadRequest("You can not delete your main photo")); } // check if photo from repo exist if (photoFromRepo.PublicId != null) { var deleteParams = new DeletionParams(photoFromRepo.PublicId); var result = _cloudinary.Destroy(deleteParams); if (result.Result == "ok") { _repo.Delete(photoFromRepo); } } if (photoFromRepo.PublicId == null) { _repo.Delete(photoFromRepo); } //Save all if (await _repo.SaveAll()) { return(Ok()); } return(BadRequest("Failed to delete the photo")); }
public async Task DeletePlayerAsync(int id) { var playerToDelete = await playerRepository.GetByIdAsync(id) ?? throw new NotFoundInDatabaseException();; playerRepository.Delete(playerToDelete); await unitOfWork.CompleteAsync(); }
public ActionResult DeleteConfirmed(int id) { playerRepository.Delete(id); playerRepository.Save(); return(RedirectToAction("Index")); }
public ActionResult DeleteConfirmed(Guid id) { playerRepository.Delete(this.Session.CurrentTeam().Id, id); playerRepository.Save(); return(RedirectToAction("Index")); }
public void Delete(Player player) { if (player.UserId != null) { _repository.Delete(Mapping.Mapped.Map <Domain.Entities.Player>(player)); } }
public NHLStatsMutation(IPlayerRepository playerRepository, ISkaterStatisticRepository skaterRepository, ILogger <NHLStatsMutation> logging) { Name = "PlayerStatMutation"; Field <PlayerType>( "createPlayer", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <PlayerInputType> > { Name = "player" }, new QueryArgument <ListGraphType <SkaterStatisticInputType> > { Name = "skaterStats" } ), resolve: context => { var player = context.GetArgument <Player>("player"); var skaterStats = context.GetArgument <List <SkaterStatistic> >("skaterStats"); return(playerRepository.AddWithSkaterStats(player, skaterStats)); }); Field <StatusResultType>( "deletePlayer", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <IntGraphType> > { Name = "playerId" } ), resolve: context => { var playerId = context.GetArgument <int>("playerId"); return(playerRepository.Delete(playerId)); }); }
public IActionResult DeletePlayer(int playerId) { Player player = new Player(); player.Id = playerId; _repository.Delete(player); return(View("Index")); }
public ActionResult DeleteConfirmed(int id) { Player player = _playerRepository.FindById(id); _playerRepository.Delete(player); _playerRepository.Save(); return(RedirectToAction("Index")); }
public IActionResult DeletePost(Player model) { if (ModelState.IsValid) { _playerRepository.Delete(model); return(RedirectToAction("Teams")); } return(View("Delete")); }
public IActionResult Delete(Guid id) { var player = playerRepository.Find(id); playerRepository.Delete(player); playerRepository.SaveChanges(); context.Clients.All.SendAsync("refreshPlayers"); return(RedirectToAction("index", "Home")); }
public async Task <IActionResult> DeleteConfirmed(int id) { var player = await repository.GetAsync((int?)id); repository.Delete(player); await repository.SaveAsync(); return(RedirectToAction(nameof(Index))); }
public bool Delete(Player player) { //var playerToDelete = players.SingleOrDefault(p => p.Id == id); //if (playerToDelete == null) return false; //int index = players.IndexOf(playerToDelete); //players.RemoveAt(index); //return true; return(playerRepository.Delete(player)); }
public async Task Delete(Player player) { var found = await _repository.GetByEmail(player.email); if (found == null) { throw new EntityNotFoundException(); } await _repository.Delete(player); }
public void DeletePlayer(Player player, IPlayerRepository playerRepository) { foreach (Team t in _teamList) { if (t.LowerAge <= player.Age && t.UpperAge >= player.Age) { t.Players.Remove(player); } } playerRepository.Delete(player); }
public void DeleteOne() { Assert.AreEqual(0, _repo.GetAll().Count); Player player = new Player(1, "bob", "dasilva", "db@mail", "password", 15, true); _repo.Add(player); Assert.AreEqual(1, _repo.GetAll().Count); _repo.Delete(player); Assert.AreEqual(0, _repo.GetAll().Count); }
public ActionResult Delete(int id) { try { _repo.Delete(id); return(Ok("Player was successfully deleted.")); } catch { return(BadRequest("Player with id " + id + " not found!")); } }
public IActionResult Delete(int id) { try { _playerRepository.Delete(id); return(Ok()); } catch { return(BadRequest()); } }
public async Task <IActionResult> DeletePhoto(int playerId, int id) { var player = await _repo.GetPlayer(playerId); if (!player.Photos.Any(p => p.Id == id)) { return(BadRequest("La foto no pertenece al jugador")); } var photoFromRepo = await _repo.GetPhoto(id); if (photoFromRepo.Main) { return(BadRequest("No se puede borrar la principal del jugador")); } if (photoFromRepo.PublicId != null) { var deleteParams = new DeletionParams(photoFromRepo.PublicId); var result = _cloudinary.Destroy(deleteParams); if (result.Result == "ok") { _repo.Delete(photoFromRepo); } } else { _repo.Delete(photoFromRepo); } if (await _repo.SaveAll()) { return(Ok()); } return(BadRequest("Hubo un problema al eliminar la foto.")); }
public bool Delete(int id) { var entity = _repository.GetById(id); if (entity == null) { throw new ArgumentNullException("entity"); } _repository.Delete(entity); _unitOfWork.Commit(); return(true); }
public ActionResult Delete(int id, Player deletedPlayer) { try { _pRepo.Delete(deletedPlayer); return(RedirectToAction(nameof(Index))); } catch (Exception) { //TODO Log Exception } return(View(deletedPlayer)); }
public ActionResult DeletePlayer(String playerName) { if (ModelState.IsValid) { playerrepo.Delete(playerName); ModelState.Clear(); _context.SaveChanges(); return(RedirectToAction("Club", "Club")); } else { return(View("ClubDetails")); } }
public void VerifyPlayer(IVerifyUserView inForm, Player player, IPlayerRepository playerRepository, ITrainerRepository trainerRepository, ITeamRepository teamRepository) { inForm.SetPlayerValues(player); var result = inForm.ShowViewModal(); if (result == DialogResult.OK) { playerRepository.Verify(player); _form.DisplayPlayerList(playerRepository.GetAll(), teamRepository.GetAll()); } else if (result == DialogResult.No) { playerRepository.Delete(player); } _form.DisplayRegisterRequests(playerRepository.GetAll(), trainerRepository.GetAll()); }
public NHLStatsMutation(IPlayerRepository playerRepository) { Name = "NHLMutation"; Field <PlayerType>( "createPlayer", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <PlayerInputType> > { Name = "player" } ), resolve: context => { var player = context.GetArgument <Player>("player"); return(playerRepository.Add(player)); }); Field <PlayerType>( name: "editPlayer", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <PlayerInputType> > { Name = "player" } ), resolve: ctx => { var player = ctx.GetArgument <Player>("player"); return(playerRepository.Update(player)); } ); Field <BooleanGraphType>( name: "deletePlayer", arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> > { Name = "id" } ), resolve: ctx => { var id = ctx.GetArgument <int>("id"); playerRepository.Delete(id); return(true); } ); }
public async Task <IActionResult> DeleteConfirmed(int?id) { if (id == null) { return(NotFound()); } var model = await playerRepo.GetPlayer(id); if (model == null) { return(NotFound()); } await playerRepo.Delete(model); return(RedirectToAction("index")); }
public async Task <GenericResponse <Player> > DeleteAsync(int id) { var isExist = await playerRepository.FindByIdAsync(id); if (isExist == null) { return(new GenericResponse <Player>("Player doesn't exist!")); } try{ playerRepository.Delete(isExist); await unityOfWork.CompleteAsync(); return(new GenericResponse <Player>(isExist)); } catch (Exception ex) { return(new GenericResponse <Player>($"Error with deleting player: {ex.Message}")); } }
public bool DeletePlayer(Guid Id) { try { var ExistingPlayer = _playerRepository.FindById(Id); if (ExistingPlayer == null) { return(false); } _playerRepository.Delete(ExistingPlayer); _playerRepository.Save(); return(true); } catch (Exception ex) { _logger.LogWarning($"{ex.Message}\r\n{ex.StackTrace}"); return(false); } }
public async Task Delete(string id, string tenantId) { var player = (await _playerRepository.Find( p => p.Id == id && p.TenantId == tenantId, nameof(Player.MatchDayPlayers), $"{nameof(Player.MatchDayPlayers)}.{nameof(MatchDayPlayer.MatchDay)}")) .FirstOrDefault(); if (player == null) { throw new EntityNotFoundException($"Player with id {id} not found."); } if (player.MatchDayPlayers.Any(mdp => mdp.MatchDay.IsFinished == false)) { throw new EntityClosedForUpdateException($"Cannot delete player {player.Id}. He is part of an open Matchday"); } await _playerRepository.Delete(id); await _playerRepository.SaveChangesAsync(); }
public IActionResult DeletePlayer(int tournamentId, int playerId) { var tournament = tournamentRepository.Get(tournamentId); if (tournament == null) { return(BadRequest()); } var round = roundRepository.GetCurrentRound(tournamentId); if (round == null) { playerRepository.Delete(playerId); } else { playerRepository.Disable(playerId); } return(Ok()); }
public IActionResult Delete(int id) { if (playerRepository.Exists(id) == false) { return(NotFound()); } Models.Player playerToDelete = playerRepository.Get(id); if (playerToDelete == null) { return(NotFound()); } playerRepository.Delete(playerToDelete); if (!playerRepository.Save()) { return(StatusCode(500, "A problem happened while handling your request.")); } return(NoContent()); }
public Player Delete(int id) { var player = _playerRepository.FindById(id); //Check that no draw exists with matches, with this player //1) Player belongs to a tournament - find all draws that this tournament has //2) For each draw - get all matches and check if player is in one of the matches var draws = _drawRepository.FindByTournamentId(player.TournamentId); foreach (var draw in draws) { foreach (var match in draw.Matches) { if (id == match.P1Id || id == match.P2Id) { throw new TournamentSoftwareException("Cannot delete a player, that is in a match."); } } } _playerRepository.Delete(player); _dbContext.SaveChanges(); return(player); }