private static bool AreEqualRequestAndResponseDto(PlayerRequestDto request, PlayerResponseDto response)
{
return(request.AvatarUrl == response.AvatarUrl &&
request.PlatformName == response.PlatformName &&
request.RocketStatsID == response.RocketStatsID &&
request.UserName == response.UserName);
}
public async Task <string> ProcessEventAsync(PlayerResponseDto player)
{
var session = await statProvider.GetRecentRocketLeagueSessionsAsync(player.RocketStatsID, player.PlatformName);
foreach (var item in session.Data.Items)
{
foreach (var rtMatch in item.Matches)
{
if (rtMatch.Metadata.Result.ToLower() == "victory" || rtMatch.Metadata.Result.ToLower() == "defeat") // Indicates individual game
{
var existingPlayerMatch = await rocketClient.GetPlayerMatchByRocketIdAsync(rtMatch.ID);
if (existingPlayerMatch == default)
{
var playermatch = await rocketClient.AddPlayerMatchAsync(new PlayerMatchRequestDto()
{
PlayerID = player.Id,
MatchID = null,
Victory = rtMatch.Metadata.Result.ToLower(),
RocketStatsID = rtMatch.ID,
RocketStatsGameMode = rtMatch.Metadata.Playlist,
RocketStatsMatchDate = rtMatch.Metadata.DateCollected
});
await ProcessMatchStatsAsync(playermatch, rtMatch.Stats);
}
}
}
}
return("Success");
}
public async Task GetAllPlayersAsync_HappyPath()
{
// Arrange
var player1 = new PlayerResponseDto()
{
Id = Guid.NewGuid(),
UserName = "******",
PlatformName = "Steam",
AvatarUrl = "https://www.pictures.com",
RocketStatsID = "Starlord",
DateCreatedUTC = DateTime.UtcNow,
DateModifiedUTC = DateTime.UtcNow
};
var playerList = new List <PlayerResponseDto>();
playerList.Add(player1);
mockHttpClient.Setup(client => client.ExecuteRequestAsync <List <PlayerResponseDto> >($"{fakeUrl}/api/player/list", It.IsAny <RestRequest>())).ReturnsAsync(playerList);
// Act
var response = await rocketClient.GetAllPlayersAsync();
// Assert
mockHttpClient.Verify(Clients => Clients.ExecuteRequestAsync <List <PlayerResponseDto> >($"{fakeUrl}/api/player/list", It.IsAny <RestRequest>()), Times.Once);
Assert.NotNull(response);
Assert.Equal(playerList.Count, response.Count);
}
public async Task <bool> UpdatePlayerResponse(PlayerResponseDto playerResponseDto)
{
bool result = true;
//Map the DTO object into the data entity
var questionnaireResponses = playerResponseDto.Answers.Select(response => new QuestionnaireResponse()
{
QuestionnaireId = playerResponseDto.QuestionnaireId,
UserId = playerResponseDto.PlayerId,
QuestionId = response.QuestionId,
AnswerDateTime = response.AnswerDateTime,
Value = response.Answer.Value
}).ToList();
foreach (var response in questionnaireResponses)
{
//Find all records belonging to this questionnaire
var recs = await _db.FindAsync <QuestionnaireResponse>(query => query
.Where($"{nameof(QuestionnaireResponse.QuestionId):C} = @questionId And {nameof(QuestionnaireResponse.QuestionnaireId):C} = @questionnaireId")
.WithParameters(new
{
questionId = response.QuestionId,
questionnaireId = response.QuestionnaireId
}));
result &= await _db.UpdateAsync(recs);
}
return(result);
}
public async Task <string> SayHello([ActivityTrigger] PlayerResponseDto player)
{
//logger.LogInformation($"Saying hello to {player.UserName}.");
var result = await handler.ProcessEventAsync(player);
return($"Hello {result}!");
}
public static bool AreEqualModelAndResponseDto(PlayerModel model, PlayerResponseDto dto)
{
return(model.ID == dto.ID &&
model.PlatformName == dto.PlatformName &&
model.RocketStatsID == dto.RocketStatsID &&
model.UserName == dto.UserName &&
model.DateModifiedUTC == dto.DateModifiedUTC &&
model.DateCreatedUTC == dto.DateCreatedUTC);
}
public static PlayerResponseDto ToDto(this PlayerModel player)
{
var response = new PlayerResponseDto
{
Id = player.Id,
FirstName = player.FirstName,
LastName = player.LastName,
Email = player.Email,
Rating = player.Rating,
RegistrationDate = player.RegistrationDate
};
return(response);
}
public async Task <IActionResult> Get([FromBody, Required] PlayerResponseDto playerResponseDto)
{
try
{
var result = await _service.GetPlayerResponse(playerResponseDto);
return(new ObjectResult(result));
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> SaveResponse([FromBody, Required] PlayerResponseDto playerResponseDto)
{
try
{
if (playerResponseDto == null)
{
return(BadRequest());
}
await _service.CreatePlayerResponse(playerResponseDto);
return(CreatedAtRoute("default", playerResponseDto));
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
return(BadRequest(ex.Message));
}
}
protected async Task <IEnumerable <PlayerResponseDto> > GetPlayersMockedAsync()
{
List <PlayerResponseDto> playerList = new List <PlayerResponseDto>();
for (int i = 1; i < 4; i++)
{
var player = new PlayerResponseDto()
{
Age = i,
FirstName = "John" + i,
LastName = "Doe" + i,
Alias = "Dooezer" + i
};
playerList.Add(player);
}
return(await Task.FromResult(playerList));
}
//
//CREATE APIs
//
public async Task <bool> CreatePlayerResponse(PlayerResponseDto playerResponseDto)
{
var questionnaireResponses = playerResponseDto.Answers.Select(response => new QuestionnaireResponse()
{
QuestionnaireId = playerResponseDto.QuestionnaireId,
UserId = playerResponseDto.PlayerId,
QuestionId = response.QuestionId,
AnswerDateTime = response.AnswerDateTime,
Value = response.Answer.Value
}).ToList();
foreach (var response in questionnaireResponses)
{
//Insert into Message table
await _db.InsertAsync(response);
}
return(true);
}
public async Task <PlayerResponseDto> GetPlayerResponse(PlayerResponseDto playerQuestionnaire)
{
//Find all records belonging to this questionnaire
var recs = await _db.FindAsync <QuestionnaireResponse>(query => query
.Where($"{nameof(QuestionnaireResponse.UserId):C} = @playerId And {nameof(QuestionnaireResponse.QuestionnaireId):C} = @questionnaireId")
.WithParameters(new
{
playerId = playerQuestionnaire.PlayerId,
questionnaireId = playerQuestionnaire.QuestionnaireId
}));
playerQuestionnaire.Answers = new List <QuestionResponseDto>();
foreach (var response in recs)
{
//Map to the DTO table
var responses = Mapper.Map <QuestionResponseDto>(recs);
playerQuestionnaire.Answers.Add(responses);
}
return(playerQuestionnaire);
}
public async Task <IActionResult> CreatePlayerResponse([FromBody, Required] PlayerResponseDto playerResponseDto)
{
try
{
if (playerResponseDto == null)
{
return(BadRequest());
}
if (await _service.CreatePlayerResponse(playerResponseDto))
{
return(CreatedAtRoute("default", true));
}
return(BadRequest("Failed to update the database"));
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
return(BadRequest(ex.Message));
}
}
