public async Task <IActionResult> PutTeam([FromRoute] int id, [FromBody] TeamUpdateDTO team)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != team.Id)
{
return(BadRequest());
}
var preUpdatedTeam = await teamService.GetTeamById(id);
var userId = int.Parse(User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
if (preUpdatedTeam.TeamLeader.Id != userId)
{
return(Forbid());
}
if (!preUpdatedTeam.Members.Any(m => m.Id == team.TeamLeader) && preUpdatedTeam.TeamLeader.Id != team.TeamLeader)
{
return(BadRequest(new { message = "New Team Leader must be a team member." }));
}
var updatedTeam = await teamService.UpdateTeam(team);
if (updatedTeam == null)
{
return(NotFound());
}
return(NoContent());
}
public async Task <Response <TeamDTO> > Update(Guid teamId, Guid userId, TeamUpdateDTO dto)
{
var teamEntity = await _repository.GetById(teamId);
if (teamEntity == null)
{
return(new BusinessConflictErrorResponse <TeamDTO>(new []
{
new Error
{
Code = ErrorCodes.Common.NotFound,
Message = ErrorMessages.Common.NotFound,
Field = "teamId"
}
}));
}
var teamUser = await _teamsUsersRepository.GetTeamUser(teamId, userId);
if (teamUser == null)
{
return(new BusinessConflictErrorResponse <TeamDTO>(new []
{
new Error
{
Code = ErrorCodes.Common.NotFound,
Message = ErrorMessages.Common.NotFound,
Field = "userId"
}
}));
}
if (teamUser.Status != MembershipStatus.SuperAdmin)
{
return(new ForbiddenErrorResponse <TeamDTO>(new []
{
new Error
{
Code = ErrorCodes.Security.Forbidden,
Message = ErrorMessages.Security.Forbidden
}
}));
}
teamEntity.Name = dto.Name;
teamEntity.ColorHex = dto.ColorHex;
teamEntity = await _repository.Update(teamEntity);
var result = _mapper.Map <TeamModel, TeamDTO>(teamEntity);
return(new Response <TeamDTO>
{
Data = result
});
}
public async Task <TeamDTO> UpdateTeam(TeamUpdateDTO team)
{
var response = await client.PutAsJsonAsync($"{baseUrl}/api/teams", team);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new Exception($"{response.StatusCode} : {await response.Content.ReadAsStringAsync()}");
}
return(await response.Content.ReadAsAsync <TeamDTO>());
}
public void Update(int id, TeamUpdateDTO teamDTO)
{
var teams = _teamRepository.GetById(id);
if (teams != null)
{
teams.ChangeName(teamDTO.Name);
teams.ChangeModality(teamDTO.Modality);
teams.ChangeQtdPlayers(teamDTO.QtdPlayers);
_teamRepository.Update(teams);
}
}
public async Task <TeamDTO> SaveTeam(TeamUpdateDTO team)
{
var teamToSave = new Team()
{
Name = team.Name,
LeaderId = team.TeamLeader,
CreatedAt = DateTime.Now
};
await teamRepository.SaveTeam(teamToSave);
return(await GetTeamById(teamToSave.Id));
}
public async Task <IActionResult> PostTeam([FromBody] TeamUpdateDTO team)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = int.Parse(User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
team.TeamLeader = userId;
var savedTeam = await teamService.SaveTeam(team);
return(CreatedAtAction("GetTeam", new { id = savedTeam.Id }, savedTeam));
}
public async Task <TeamDTO> UpdateTeam(TeamUpdateDTO team)
{
var preUpdateTeam = await teamRepository.GetTeamById(team.Id);
if (preUpdateTeam == null)
{
return(null);
}
preUpdateTeam.Name = team.Name;
preUpdateTeam.LeaderId = team.TeamLeader;
await teamRepository.UpdateTeam(preUpdateTeam);
return(await GetTeamById(team.Id));
}
public async Task <TeamDTO> UpdateTeam(TeamUpdateDTO teamDto)
{
var teamEntity = await repository.GetById(teamDto.Id);
if (teamEntity == null)
{
throw new NotFoundException(nameof(Team), teamDto.Id);
}
teamEntity.Name = teamDto.Name;
await repository.Update(teamEntity);
await unitOfWork.SaveChangesAsync();
return((await GetAllTeams()).FirstOrDefault(p => p.Id == teamEntity.Id));
}
public async Task <ActionResult <TeamUpdateDTO> > PutGet(int id)
{
var teamActionResult = await Get(id);
if (teamActionResult.Result is NotFoundResult)
{
return(NotFound());
}
var teamProfileDTO = teamActionResult.Value;
var selectedGamesIds = teamProfileDTO.Games.Select(x => x.GameId).ToList();
var notSelectedGames = await _dbContext.Games
.Where(x => !selectedGamesIds.Contains(x.GameId))
.ToListAsync();
var model = new TeamUpdateDTO();
model.Team = teamProfileDTO.Team;
model.SelectedGames = teamProfileDTO.Games;
model.NotSelectedGames = notSelectedGames;
model.TeamPlayers = teamProfileDTO.Players;
return(model);
}
public async Task <Response <TeamDTO> > UpdateTeam([Required, FromRoute] Guid id, [Required, FromBody] TeamUpdateDTO dto)
{
return(await _handler.Update(id, dto, User));
}
public IActionResult Put(int id, [FromBody] TeamUpdateDTO teamDTO)
{
_teamApplication.Update(id, teamDTO);
return(Ok("Time atualizado com sucesso!"));
}
public async Task <Response <TeamDTO> > Update(Guid teamId, TeamUpdateDTO dto, ClaimsPrincipal claims)
{
var result = await _service.Update(teamId, claims.GetUserId(), dto);
return(result);
}
public async Task <ActionResult <TeamDTO> > Put([FromBody] TeamUpdateDTO team)
{
return(Ok(await teamService.UpdateTeam(team)));
}
