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);
}
