public ActionResult <UpdateTeamResponse> UpdateTeam(UpdateTeamRequest request)
{
var response = new UpdateTeamResponse()
{
ResponseMessage = Models.ResponseMessage.Failure
};
var team = _context.Teams.FirstOrDefault(t => t.Id == request.Team.Id);
if (team == null)
{
return(NotFound(response));
}
team.Name = request.Team.Name;
team.Nickname = request.Team.Nickname;
team.Location = request.Team.Location;
team.StadiumId = request.Team.StadiumId == 0 ? null : request.Team.StadiumId;
var success = _context.SaveChanges();
if (success > 0)
{
response.ResponseMessage = Models.ResponseMessage.Success;
}
return(Ok(response));
}
public object Patch(UpdateTeamRequest request)
{
var originalTeam = Db.SingleById<Team>(request.Id);
originalTeam.PopulateWithNonDefaultValues(request);
Db.Save(originalTeam);
return Db.SingleById<Team>(request.Id).ConvertTo<TeamDto>();
}
public async Task <ActionResult> UpdateTeam(UpdateTeamRequest request)
{
if (!await this.IsAPITokenValid(request.ApiToken))
{
return(new BadRequestObjectResult("UnAuthorized"));
}
string leagueId = await this.GetLeagueId(request.LeagueKey);
if (leagueId == null)
{
return(new BadRequestObjectResult("League Not Found"));
}
var team = await this.TeamRepositry.GetAsync(request.TeamId);
if (team == null)
{
return(new BadRequestObjectResult("Team Not Found"));
}
team.TeamName = request.TeamName;
team.CoachName = request.CoachName;
team.Logo = String.IsNullOrEmpty(request.Logo) ? Configuration.GetValue <string>("DefaultTeamLogo") : request.Logo;
var updatedTeam = await this.TeamRepositry.UpdateAsync(team);
return(new OkObjectResult(updatedTeam));
}
public async Task <IActionResult> Produce(UpdateTeamRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
public void MapUpdateTeamRequestShouldSucceed()
{
// Arrange
var ifMatch = "123456";
var version = 123456;
var apiVersion = "1.0";
var id = Guid.NewGuid();
var name = "Test";
var image = "update";
var description = "updatedeDescription";
var driverWait = "No";
var layout = Guid.NewGuid().ToString();
var filterContent = "{site:123456}";
var members = new List <Guid>();
// Act
var request = new UpdateTeamRequest(new UpdateTeamFromHeader()
{
IfMatch = ifMatch
},
new UpdateTeamFromQuery()
{
ApiVersion = apiVersion
},
new UpdateTeamFromRoute()
{
Id = id.ToString()
},
new UpdateTeamFromBody()
{
Name = name,
Image = image,
Description = description,
DriverWait = driverWait,
Layout = layout,
Members = members,
FilterContent = filterContent
});
var command = new UpdateTeamCommand(id,
name,
image,
description,
driverWait,
layout,
members,
filterContent,
version);
var mappedCommand = _cqsMapper.Map(request);
// Assert
command.Should().BeEquivalentTo(mappedCommand);
}
public async Task <IActionResult> UpdateTeam([FromRoute] string teamId, [FromBody] UpdateTeamRequest request,
CancellationToken cancellationToken)
{
var command = new UpdateTeamCommand
(
ObjectId.Parse(teamId),
request.Name
);
await _commandDispatcher.DispatchAsync(command, cancellationToken);
return(StatusCode(204));
}
public Team UpdateTeam([FromBody] Team team)
{
if (team != null)
{
var business = TeamBusiness.Instance;
var request = new UpdateTeamRequest(this.Context);
request.Team = team;
team = business.UpdateTeam(request);
}
return(team);
}
public Team UpdateTeam(UpdateTeamRequest request)
{
Team team = null;
if (request != null && request.Team != null)
{
var dataAccess = new TeamDataAccess(request.Context);
team = dataAccess.Update(request.Team);
}
return(team);
}
public async Task <IActionResult> Update([FromRoute] UpdateTeamFromRoute route,
[FromQuery] UpdateTeamFromQuery query,
[FromHeader] UpdateTeamFromHeader header)
{
var bodyString = await Request.GetRawBodyStringAsync();
var body = JsonConvert.DeserializeObject <UpdateTeamFromBody>(bodyString);
body.Put = bodyString;
var request = new UpdateTeamRequest(header, query, route, body);
var result = await _apiResult.Produce(request);
return(result);
}
public void ConstructorShouldSucceed()
{
// Arrange
var header = new UpdateTeamFromHeader();
var query = new UpdateTeamFromQuery();
var route = new UpdateTeamFromRoute();
var body = new UpdateTeamFromBody();
// Act
var request = new UpdateTeamRequest(header, query, route, body);
// Assert
request.Should().NotBeNull();
}
public object Post(UpdateTeamRequest request)
{
var originalTeam = Db.SingleById<Team>(request.Id);
var shouldUpdateStandings = originalTeam.IsForfaitOut != request.IsForfaitOut;
originalTeam.PopulateWith(request);
Db.Save(originalTeam);
if (shouldUpdateStandings && originalTeam.LeagueId.HasValue)
{
StandingsCalculator.Calculate(Db, originalTeam.LeagueId.Value);
}
return Db.SingleById<Team>(request.Id).ConvertTo<TeamDto>();
}
public UpdateTeamCommand Map(UpdateTeamRequest request)
{
var version = ToVersion(request.HeaderIfMatch);
var id = new Guid(request.RouteId);
var command = new UpdateTeamCommand(id,
request.Name,
request.Image,
request.Description,
request.DriverWait,
request.Layout,
request.Members,
request.FilterContent,
version);
return(command);
}
public async Task <IActionResult> Process(UpdateTeamRequest request, IValidatorActionResult validatorActionResult)
{
IActionResult actionResult;
if (validatorActionResult.Result == null)
{
var command = _cqsMapper.Map(request);
var result = await _mediator.Send(command);
actionResult = result.IsFailure ? _apiResponse.Fail(result)
: _apiResponse.Updated(result.Version.ToString());
}
else
{
actionResult = validatorActionResult.Result;
}
return(actionResult);
}
public async Task <IActionResult> Edit(Team team)
{
string errorMessage = "";
Parameter[] paramList = new Parameter[2];
paramList[0] = new Parameter("apiToken", Connector.CurrentApiToken, ParameterType.QueryString);
paramList[1] = new Parameter("leagueKey", Connector.League.LeagueKey, ParameterType.QueryString);
var teamList = this.ApiClient.Get <List <Team> >("Teams/ByLeague", paramList, ref errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
return(RedirectToAction("Index", "Teams", new { errorMsg = "Error updating team." }));
}
if (teamList != null && teamList.Where(x => x.TeamName.ToUpper() == team.TeamName.ToUpper() && x.TeamId != team.TeamId).FirstOrDefault() != null)
{
return(RedirectToAction("Index", "Teams", new { errorMsg = "A team with that name already exists" }));
}
UpdateTeamRequest apiRequest = new UpdateTeamRequest
{
ApiToken = Connector.CurrentApiToken,
LeagueKey = Connector.League.LeagueKey,
TeamName = team.TeamName,
CoachName = team.CoachName,
Logo = team.Logo,
TeamId = team.TeamId
};
errorMessage = "";
var updatedTeam = this.ApiClient.Post <Team>("Teams/Edit", JsonConvert.SerializeObject(apiRequest), ref errorMessage);
if (updatedTeam != null)
{
return(RedirectToAction("Index", "Teams", new { actionMsg = $"{updatedTeam.TeamName} updated." }));
}
return(RedirectToAction("Index", "Teams", new { errorMsg = "Error updating team." }));
}
public async Task UpdateTeamAsync(
UpdateTeamRequest request,
CancellationToken cancellationToken = default)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
Entities.Team entity = await _context.Teams
.FirstOrDefaultAsync(t => t.Id == request.TeamID);
if (entity == null)
{
throw new ObjectNotFoundException();
}
if (request.IsSet(x => x.Name))
{
entity.Name = request.Name;
}
await _context.SaveChangesAsync(cancellationToken);
}
catch (ServiceException)
{
throw;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error updating team.");
throw Conversion.ConvertException(ex);
}
}
public async Task <IActionResult> Create(UpdateTeamRequest request)
{
await _teamService.Update(request);
return(Ok());
}
public async Task Update(UpdateTeamRequest request)
{
Team team = _mapper.Map <Team>(request);
await _teamRepository.Update(team);
}
public async Task <ActionResult <CreateTeamResponse> > UpdateTeam([FromRoute] int teamId, [FromBody] UpdateTeamRequest createTeamRequest, CancellationToken cancellationToken)
{
var team = await _teamsRepository.GetByIdAsync(teamId, cancellationToken);
if (team != null)
{
team.Name = createTeamRequest.Name;
team.FoundedIn = createTeamRequest.FoundedIn;
await _teamsRepository.UpdateAsync(team, cancellationToken);
var response = new CreateTeamResponse()
{
Team = _mapper.Map <TeamDto>(team)
};
return(Ok(response));
}
else
{
return(BadRequest());
}
}
