public async Task <IActionResult> AddOneAsync(MatchRequestModel matchRequestModel)
{
try
{
if (matchRequestModel.HouseTeam.Count.Equals(2) && matchRequestModel.AwayTeam.Count.Equals(2))
{
if (ModelState.IsValid)
{
return(StatusCode(201, await _services.AddOne(matchRequestModel)));
}
}
else
{
throw new FXSException("The players array is not equal to 11", "400");
}
throw new FXSException("Model is invalid", "401");
}
catch (FXSException fxse)
{
return(StatusCode(Int32.Parse(fxse.Code), new ExceptionModel {
Message = fxse.Message, Code = fxse.Code
}));
}
catch (Exception ex)
{
return(NotFound(ex.Message));
}
}
private static MatchRequestModel GetRequest()
{
var format = _gameFormats[_random.Next(_gameFormats.Length)];
var isSolo = _random.Next(4) > 0;
var partySize = isSolo ? 1 : _random.Next(GameSetup.GameFormatsToPlayersRequired[format]) + 1;
var players = new List <PlayerModel>();
for (var i = 0; i < partySize; i++)
{
var playerId = Guid.NewGuid();
var player = new PlayerModel
{
Id = playerId,
Name = $"player{playerId:N}"
};
players.Add(player);
}
var titles = new List <GameTitle>();
var titleChance = _random.Next(_gameTitles.Length);
foreach (var title in _gameTitles)
{
if (_random.Next(titleChance) == 0)
{
titles.Add(title);
}
}
if (!titles.Any())
{
titles.Add(_gameTitles.First());
}
var modes = new List <GameMode>();
var gameModes = GameSetup.GameFormatsToModes[format];
var modeChance = _random.Next(gameModes.Count());
foreach (var mode in gameModes)
{
if (_random.Next(modeChance) == 0)
{
modes.Add(mode);
}
}
if (!modes.Any())
{
modes.Add(gameModes.First());
}
var request = new MatchRequestModel
{
Players = players,
GameFormat = format,
GameTitles = titles,
GameModes = modes
};
return(request);
}
private void ValidateRequest(MatchRequestModel request)
{
if (!request.Players.Any())
{
throw new ArgumentException("At least one player required");
}
if (request.Players.Count() > GameSetup.GameFormatsToPlayersRequired[request.GameFormat])
{
throw new ArgumentException("Too many players for the selected GameFormat");
}
if (request.Players.Any(x => x.Id == Guid.Empty))
{
throw new ArgumentException("Player Id required");
}
if (request.Players.Any(x => string.IsNullOrWhiteSpace(x.Name)))
{
throw new ArgumentException("Player Name required");
}
if (request.GameTitles == null || !request.GameTitles.Any())
{
throw new ArgumentException("At least one GameTitle required");
}
if (request.GameModes == null || !request.GameModes.Any())
{
throw new ArgumentException("At least one GameMode required");
}
if (request.GameModes.Except(GameSetup.GameFormatsToModes[request.GameFormat]).Count() != 0)
{
throw new ArgumentException("All GameModes must be valid for the selected GameFormat");
}
}
public async Task <object> UpdateOne(int id, MatchRequestModel MatchRequestModel)
{
try
{
var update = Builders <MatchRequestMongoModel> .Update.Set("created", DateTime.UtcNow);
foreach (BsonElement item in MatchRequestModel.ToBsonDocument())
{
if (item.Name != "modified" && item.Name != "created" && item.Name != "_id" && item.Value.GetType() != typeof(BsonNull))
{
update = update.Set(item.Name, item.Value);
}
if (item.Name == "referee" || item.Name == "awayManger" || item.Name == "houseManager")
{
update = update.Set(item.Name, item.Value.ToString());
}
if (item.Name == "houseTeam" || item.Name == "awayTeam")
{
List <int> values = BsonSerializer.Deserialize <List <int> >(item.Value.ToJson());
update = update.Set(item.Name, values.ConvertAll <string>(delegate(int i)
{
return(i.ToString());
}));
}
}
update = update.Set("modified", DateTime.UtcNow);
await _mongoCollection.UpdateOneAsync(Builders <MatchRequestMongoModel> .Filter.Eq("uid", id.ToString()), update);
return(string.Format("{0} update success", id));
}
catch (Exception)
{
throw;
}
}
public async Task <string> AddOne(MatchRequestModel matchRequestModel)
{
try
{
MatchRequestMongoModel matchRequestMongoModel = new MatchRequestMongoModel
{
_id = ObjectId.GenerateNewId(),
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
Uid = GenerateIdUtils.GenerateId(),
Name = matchRequestModel.Name,
Referee = matchRequestModel.Referee.ToString(),
AwayManger = matchRequestModel.AwayManger.ToString(),
Date = matchRequestModel.Date,
HouseManager = matchRequestModel.HouseManager.ToString(),
HouseTeam = matchRequestModel.HouseTeam.ConvertAll <string>(delegate(int i)
{
return(i.ToString());
}),
AwayTeam = matchRequestModel.AwayTeam.ConvertAll <string>(delegate(int i)
{
return(i.ToString());
}),
};
await _mongoCollection.InsertOneAsync(matchRequestMongoModel);
return(matchRequestMongoModel.Uid);
}
catch (Exception)
{
throw;
}
}
public Task CreateAsync(MatchRequestModel model)
{
var match = new Match {
Name = model.Name, Status = model.Status, TeamMatches = model.TeamMatches.ToList()
};
return(matchRepository.CreateAsync(match));
}
public async Task Should_Require_At_Least_One_Player()
{
var request = new MatchRequestModel
{
Players = new PlayerModel[0],
GameFormat = GameFormat.OneVersusOne,
GameTitles = new[] { GameTitle.HaloReach },
GameModes = new[] { GameMode.Slayer }
};
await Assert.ThrowsAsync <ArgumentException>(() => _sut.GetMatch(request, CancellationToken.None));
}
private async Task SendRequest(MatchRequestModel request, ClientWebSocket webSocket, CancellationToken cancellationToken)
{
var json = JsonSerializer.Serialize(request);
var bytes = Encoding.UTF8.GetBytes(json);
var segments = ArraySegmentHelper.Segment(bytes, BUFFER_SIZE);
await webSocket.ConnectAsync(new Uri(_matchmakingServer, "/ws"), cancellationToken);
foreach (var segment in segments)
{
var eom = segment == segments.Last();
await webSocket.SendAsync(segment, WebSocketMessageType.Text, eom, CancellationToken.None);
}
}
public async Task <MatchResponseModel> GetMatch(MatchRequestModel request, CancellationToken cancellationToken)
{
ValidateRequest(request);
using (var webSocket = new ClientWebSocket())
{
await SendRequest(request, webSocket, cancellationToken);
var response = await ReceiveResponse(webSocket, cancellationToken);
await CloseHandshake(webSocket, cancellationToken);
return(response);
}
}
public async Task <IActionResult> UpdateAsync(int id, MatchRequestModel matchRequestModel)
{
try
{
return(Ok(await _services.UpdateOne(id, matchRequestModel)));
}
catch (FXSException fxse)
{
return(StatusCode(Int32.Parse(fxse.Code), new ExceptionModel {
Message = fxse.Message, Code = fxse.Code
}));
}
catch (Exception ex)
{
return(NotFound(ex.Message));
}
}
public async Task Should_Require_At_Least_One_GameTitle()
{
var player1 = new PlayerModel {
Id = Guid.NewGuid(), Name = "bob"
};
var player2 = new PlayerModel {
Id = Guid.NewGuid(), Name = "sue"
};
var request = new MatchRequestModel
{
Players = new[] { player1, player2 },
GameFormat = GameFormat.OneVersusOne,
GameTitles = new GameTitle[0],
GameModes = new[] { GameMode.Slayer }
};
await Assert.ThrowsAsync <ArgumentException>(() => _sut.GetMatch(request, CancellationToken.None));
}
public async Task Should_Restrict_GameModes_To_The_Selected_GameFormat()
{
var player1 = new PlayerModel {
Id = Guid.NewGuid(), Name = "bob"
};
var player2 = new PlayerModel {
Id = Guid.NewGuid(), Name = "sue"
};
var request = new MatchRequestModel
{
Players = new[] { player1, player2 },
GameFormat = GameFormat.OneVersusOne,
GameTitles = new[] { GameTitle.HaloReach },
GameModes = new[] { GameMode.FirefightArcade }
};
await Assert.ThrowsAsync <ArgumentException>(() => _sut.GetMatch(request, CancellationToken.None));
}
public async Task <IActionResult> SubmitMatch(int id, MatchRequestModel matchRqModel)
{
var user = await userManager.GetUser(User);
// Admin can't sumbit test
if (await userManager.IsInRoleAsync(user, Roles.Administrator))
{
return(Ok());
}
if (matchRqModel.SucceededCardIds.Intersect(matchRqModel.FailedCardIds).Count() > 0)
{
ModelState.AddModelError("", "At least a card is both succeeded and failed.");
return(BadRequest(ModelState));
}
var deck = await repository.Deck
.QueryByIdCheckingSharedDeck(user.Id, id)
.FirstOrDefaultAsync();
if (deck == null)
{
return(NotFound());
}
var newMatch = new Match()
{
TotalTime = matchRqModel.TotalTime,
StartTime = matchRqModel.StartTime.Value,
EndTime = matchRqModel.EndTime.Value,
Deck = deck,
Taker = user,
MatchedCards = new List <MatchedCard>()
};
var cards = await repository.Card
.QueryByDeckId(id)
.ToListAsync();
var succeededCards = FilterCards(cards, matchRqModel.SucceededCardIds);
var failedCards = FilterCards(cards, matchRqModel.FailedCardIds);
foreach (var card in succeededCards)
{
newMatch.MatchedCards.Add(new MatchedCard()
{
Card = card,
Failed = false
});
}
foreach (var card in failedCards)
{
newMatch.MatchedCards.Add(new MatchedCard()
{
Card = card,
Failed = true
});
}
newMatch.Score = (float)succeededCards.Count / (succeededCards.Count + failedCards.Count);
repository.Match.Create(newMatch);
await repository.SaveChangesAsync();
return(Ok());
}
