public async Task TestParseHeader(
int bitsMatchId,
int homeTeamId,
DateTime date,
string team,
string opponent,
int turn,
string oilPatternName,
string oilPatternUrl,
string location)
{
// Arrange
Web.Infrastructure.Bits.Contracts.HeadInfo content = await BitsGateway.GetHeadInfo(bitsMatchId);
// Act
ParseHeaderResult header = BitsParser.ParseHeader(content, homeTeamId);
// Assert
Assert.That(header.Date, Is.EqualTo(date));
Assert.That(header.Team, Is.EqualTo(team));
Assert.That(header.Opponent, Is.EqualTo(opponent));
Assert.That(header.Turn, Is.EqualTo(turn));
Assert.That(header.OilPattern.Name, Is.EqualTo(oilPatternName));
Assert.That(header.OilPattern.Url, Is.EqualTo(oilPatternUrl));
Assert.That(header.Location, Is.EqualTo(location));
}
public async Task CanParseAlternateAwayTeamNameWithIf()
{
// Arrange
const int ClubId = 1660;
// Act
ParseResult?result = new BitsParser(playersTeamF).Parse(await BitsGateway.GetBitsMatchResult(3048477), ClubId);
// Assert
Assert.That(result !.TeamScore, Is.EqualTo(14));
}
public async Task CanFindName()
{
// Arrange
const int ClubId = 1660;
// Act
ParseResult?result = new BitsParser(playersTeamA).Parse(await BitsGateway.GetBitsMatchResult(3050651), ClubId);
// Assert
Assert.That(result !.TeamScore, Is.EqualTo(7));
}
private async Task <IHttpActionResult> Handle(RegisterMatchMessage message)
{
WebsiteConfig websiteConfig = DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
Player[] players =
DocumentSession.Query <Player, PlayerSearch>()
.ToArray()
.Where(x => x.PlayerItem?.LicNbr != null)
.ToArray();
Roster pendingMatch = DocumentSession.Load <Roster>(message.RosterId);
try
{
var parser = new BitsParser(players);
BitsMatchResult bitsMatchResult = await bitsClient.GetBitsMatchResult(pendingMatch.BitsMatchId);
if (bitsMatchResult.HeadInfo.MatchFinished == false)
{
Log.Info($"Match {pendingMatch.BitsMatchId} not yet finished");
return(Ok());
}
if (pendingMatch.IsFourPlayer)
{
Parse4Result parse4Result = parser.Parse4(bitsMatchResult, websiteConfig.ClubId);
if (parse4Result != null)
{
List <string> allPlayerIds = GetPlayerIds(parse4Result);
pendingMatch.SetPlayers(allPlayerIds);
ExecuteCommand(new RegisterMatch4Command(pendingMatch, parse4Result));
}
}
else
{
ParseResult parseResult = parser.Parse(bitsMatchResult, websiteConfig.ClubId);
if (parseResult != null)
{
List <string> allPlayerIds = GetPlayerIds(parseResult);
pendingMatch.SetPlayers(allPlayerIds);
ExecuteCommand(new RegisterMatchCommand(pendingMatch, parseResult));
}
}
}
catch (Exception e)
{
ErrorSignal
.FromCurrentContext()
.Raise(new Exception($"Unable to auto register match {pendingMatch.Id} ({pendingMatch.BitsMatchId})", e));
Log.Warn(e);
return(Ok(e.ToString()));
}
return(Ok());
}
public async Task CanParseHomeTeam()
{
// Arrange
const int ClubId = 1660;
// Act
Parse4Result?result = new BitsParser(homePlayers).Parse4(await BitsGateway.GetBitsMatchResult(3060835), ClubId);
Assert.That(result !.TeamScore, Is.EqualTo(18));
Assert.That(result.OpponentScore, Is.EqualTo(1));
Assert.That(result.Turn, Is.EqualTo(11));
ResultSeries4ReadModel.Serie[] series = result.Series;
// Assert
Assert.That(series.Length, Is.EqualTo(4));
ResultSeries4ReadModel.Serie serie1 = series[0];
Assert.That(serie1.Games, Has.Count.EqualTo(4));
VerifyGame(serie1.Games[0], Tuple.Create(0, "player-1", 138));
VerifyGame(serie1.Games[1], Tuple.Create(1, "player-2", 178));
VerifyGame(serie1.Games[2], Tuple.Create(1, "player-3", 183));
VerifyGame(serie1.Games[3], Tuple.Create(1, "player-4", 131));
ResultSeries4ReadModel.Serie serie2 = series[1];
Assert.That(serie2.Games, Has.Count.EqualTo(4));
VerifyGame(serie2.Games[0], Tuple.Create(1, "player-3", 152));
VerifyGame(serie2.Games[1], Tuple.Create(1, "player-4", 189));
VerifyGame(serie2.Games[2], Tuple.Create(1, "player-1", 205));
VerifyGame(serie2.Games[3], Tuple.Create(1, "player-2", 136));
ResultSeries4ReadModel.Serie serie3 = series[2];
Assert.That(serie3.Games, Has.Count.EqualTo(4));
VerifyGame(serie3.Games[0], Tuple.Create(1, "player-4", 223));
VerifyGame(serie3.Games[1], Tuple.Create(1, "player-3", 251));
VerifyGame(serie3.Games[2], Tuple.Create(1, "player-2", 158));
VerifyGame(serie3.Games[3], Tuple.Create(1, "player-1", 149));
ResultSeries4ReadModel.Serie serie4 = series[3];
Assert.That(serie4.Games, Has.Count.EqualTo(4));
VerifyGame(serie4.Games[0], Tuple.Create(1, "player-2", 179));
VerifyGame(serie4.Games[1], Tuple.Create(1, "player-1", 181));
VerifyGame(serie4.Games[2], Tuple.Create(1, "player-4", 183));
VerifyGame(serie4.Games[3], Tuple.Create(0, "player-3", 167));
}
public async Task CanParseAwayTeam()
{
// Arrange
const int ClubId = 34534;
// Act
Parse4Result?result = new BitsParser(awayPlayers).Parse4(await BitsGateway.GetBitsMatchResult(3060835), ClubId);
Assert.That(result !.TeamScore, Is.EqualTo(1));
Assert.That(result.OpponentScore, Is.EqualTo(18));
Assert.That(result.Turn, Is.EqualTo(11));
ResultSeries4ReadModel.Serie[] series = result.Series;
// Assert
Assert.That(series.Length, Is.EqualTo(4));
ResultSeries4ReadModel.Serie serie1 = series[0];
Assert.That(serie1.Games.Count, Is.EqualTo(4));
VerifyGame(serie1.Games[0], Tuple.Create(1, "player-5", 160));
VerifyGame(serie1.Games[1], Tuple.Create(0, "player-6", 117));
VerifyGame(serie1.Games[2], Tuple.Create(0, "player-7", 139));
VerifyGame(serie1.Games[3], Tuple.Create(0, "player-8", 83));
ResultSeries4ReadModel.Serie serie2 = series[1];
Assert.That(serie2.Games.Count, Is.EqualTo(4));
VerifyGame(serie2.Games[0], Tuple.Create(0, "player-8", 122));
VerifyGame(serie2.Games[1], Tuple.Create(0, "player-7", 156));
VerifyGame(serie2.Games[2], Tuple.Create(0, "player-6", 101));
VerifyGame(serie2.Games[3], Tuple.Create(0, "player-5", 133));
ResultSeries4ReadModel.Serie serie3 = series[2];
Assert.That(serie3.Games.Count, Is.EqualTo(4));
VerifyGame(serie3.Games[0], Tuple.Create(0, "player-6", 148));
VerifyGame(serie3.Games[1], Tuple.Create(0, "player-5", 142));
VerifyGame(serie3.Games[2], Tuple.Create(0, "player-9", 118));
VerifyGame(serie3.Games[3], Tuple.Create(0, "player-7", 136));
ResultSeries4ReadModel.Serie serie4 = series[3];
Assert.That(serie4.Games.Count, Is.EqualTo(4));
VerifyGame(serie4.Games[0], Tuple.Create(0, "player-7", 134));
VerifyGame(serie4.Games[1], Tuple.Create(0, "player-9", 119));
VerifyGame(serie4.Games[2], Tuple.Create(0, "player-5", 122));
VerifyGame(serie4.Games[3], Tuple.Create(0, "player-6", 167));
}
public async Task CanParseAwayTeam()
{
// Arrange
const int ClubId = 1660;
// Act
ParseResult?result = new BitsParser(playersTeamA).Parse(await BitsGateway.GetBitsMatchResult(3048747), ClubId);
Assert.That(result !.TeamScore, Is.EqualTo(10));
Assert.That(result.OpponentScore, Is.EqualTo(9));
ResultSeriesReadModel.Serie[] series = result.Series;
// Assert
Assert.That(series.Length, Is.EqualTo(4));
ResultSeriesReadModel.Serie serie1 = series[0];
Assert.That(serie1.Tables.Count, Is.EqualTo(4));
VerifyTable(serie1.Tables[0], Tuple.Create(1, "player-3", 202, "player-10", 204));
VerifyTable(serie1.Tables[1], Tuple.Create(0, "player-1", 196, "player-2", 234));
VerifyTable(serie1.Tables[2], Tuple.Create(1, "player-7", 205, "player-8", 247));
VerifyTable(serie1.Tables[3], Tuple.Create(1, "player-5", 227, "player-6", 212));
ResultSeriesReadModel.Serie serie2 = series[1];
Assert.That(serie2.Tables.Count, Is.EqualTo(4));
VerifyTable(serie2.Tables[0], Tuple.Create(0, "player-5", 182, "player-6", 213));
VerifyTable(serie2.Tables[1], Tuple.Create(0, "player-7", 226, "player-8", 211));
VerifyTable(serie2.Tables[2], Tuple.Create(1, "player-1", 218, "player-2", 269));
VerifyTable(serie2.Tables[3], Tuple.Create(0, "player-3", 232, "player-10", 162));
ResultSeriesReadModel.Serie serie3 = series[2];
Assert.That(serie3.Tables.Count, Is.EqualTo(4));
VerifyTable(serie3.Tables[0], Tuple.Create(0, "player-1", 200, "player-2", 212));
VerifyTable(serie3.Tables[1], Tuple.Create(0, "player-3", 202, "player-10", 201));
VerifyTable(serie3.Tables[2], Tuple.Create(0, "player-5", 202, "player-6", 187));
VerifyTable(serie3.Tables[3], Tuple.Create(1, "player-7", 232, "player-8", 201));
ResultSeriesReadModel.Serie serie4 = series[3];
Assert.That(serie4.Tables.Count, Is.EqualTo(4));
VerifyTable(serie4.Tables[0], Tuple.Create(1, "player-7", 217, "player-8", 203));
VerifyTable(serie4.Tables[1], Tuple.Create(1, "player-5", 178, "player-6", 267));
VerifyTable(serie4.Tables[2], Tuple.Create(0, "player-3", 180, "player-10", 229));
VerifyTable(serie4.Tables[3], Tuple.Create(0, "player-1", 183, "player-2", 175));
}
public async Task CanParseHomeTeam()
{
// Arrange
const int ClubId = 1660;
// Act
ParseResult?result = new BitsParser(playersTeamA).Parse(await BitsGateway.GetBitsMatchResult(3048746), ClubId);
Assert.That(result !.TeamScore, Is.EqualTo(11));
Assert.That(result.OpponentScore, Is.EqualTo(9));
ResultSeriesReadModel.Serie[] series = result.Series;
// Assert
Assert.That(series.Length, Is.EqualTo(4));
ResultSeriesReadModel.Serie serie1 = series[0];
Assert.That(serie1.Tables.Count, Is.EqualTo(4));
VerifyTable(serie1.Tables[0], Tuple.Create(1, "player-1", 202, "player-2", 219));
VerifyTable(serie1.Tables[1], Tuple.Create(0, "player-3", 203, "player-4", 169));
VerifyTable(serie1.Tables[2], Tuple.Create(1, "player-5", 206, "player-6", 195));
VerifyTable(serie1.Tables[3], Tuple.Create(0, "player-7", 234, "player-8", 165));
ResultSeriesReadModel.Serie serie2 = series[1];
Assert.That(serie2.Tables.Count, Is.EqualTo(4));
VerifyTable(serie2.Tables[0], Tuple.Create(1, "player-5", 205, "player-6", 212));
VerifyTable(serie2.Tables[1], Tuple.Create(0, "player-7", 192, "player-8", 192));
VerifyTable(serie2.Tables[2], Tuple.Create(1, "player-1", 212, "player-2", 237));
VerifyTable(serie2.Tables[3], Tuple.Create(1, "player-3", 202, "player-4", 199));
ResultSeriesReadModel.Serie serie3 = series[2];
Assert.That(serie3.Tables.Count, Is.EqualTo(4));
VerifyTable(serie3.Tables[0], Tuple.Create(0, "player-7", 206, "player-8", 204));
VerifyTable(serie3.Tables[1], Tuple.Create(1, "player-5", 215, "player-6", 211));
VerifyTable(serie3.Tables[2], Tuple.Create(0, "player-3", 184, "player-4", 172));
VerifyTable(serie3.Tables[3], Tuple.Create(0, "player-1", 175, "player-2", 188));
ResultSeriesReadModel.Serie serie4 = series[3];
Assert.That(serie4.Tables.Count, Is.EqualTo(4));
VerifyTable(serie4.Tables[0], Tuple.Create(0, "player-3", 213, "player-9", 173));
VerifyTable(serie4.Tables[1], Tuple.Create(1, "player-1", 188, "player-2", 213));
VerifyTable(serie4.Tables[2], Tuple.Create(1, "player-7", 194, "player-8", 255));
VerifyTable(serie4.Tables[3], Tuple.Create(1, "player-5", 226, "player-6", 210));
}
public async Task <ActionResult> CreateBitsVerify(VerifyBitsViewModel vm)
{
if (DocumentSession.Query <Roster, RosterSearchTerms>()
.SingleOrDefault(x => x.BitsMatchId == vm.BitsMatchId) != null)
{
ModelState.AddModelError("BitsMatchId", "Matchen redan upplagd");
}
if (ModelState.IsValid == false)
{
return(View("CreateBits"));
}
int season = DocumentSession.LatestSeasonOrDefault(DateTime.Now.Year);
WebsiteConfig websiteConfig = DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
Infrastructure.Bits.Contracts.HeadInfo content = await bitsClient.GetHeadInfo(vm.BitsMatchId);
ParseHeaderResult header = BitsParser.ParseHeader(content, websiteConfig.ClubId);
ViewBag.TeamNamesAndLevels = websiteConfig.TeamNamesAndLevels;
return(View(
"Create", new CreateRosterViewModel
{
Season = season,
Turn = header.Turn,
BitsMatchId = vm.BitsMatchId,
Team = header.Team,
IsFourPlayer = false,
Opponent = header.Opponent,
Date = header.Date.ToString(DateTimeFormat),
Location = header.Location,
OilPatternName = header.OilPattern.Name,
OilPatternUrl = header.OilPattern.Url
}));
}
public async Task CanParseThreeSeries()
{
// Arrange
const int ClubId = 1660;
Player[] players = new[]
{
new Player("Daniel Solvander", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-1"
},
new Player("Daniel Lidström", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-2"
},
new Player("Thomas Gurell", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-3"
},
new Player("Lennart Axelsson", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-4"
},
new Player("Håkan Gustavsson", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-5"
},
new Player("Kjell Johansson", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-6"
},
new Player("Bengt Solvander", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-7"
},
new Player("Stefan Traav", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-8"
},
new Player("Matz Classon", "*****@*****.**", Player.Status.Active, 0, null, new string[0])
{
Id = "player-9"
}
};
// Act
ParseResult?result = new BitsParser(players).Parse(await BitsGateway.GetBitsMatchResult(3067035), ClubId);
Assert.That(result !.TeamScore, Is.EqualTo(10));
Assert.That(result.OpponentScore, Is.EqualTo(5));
Assert.That(result.Turn, Is.EqualTo(24));
ResultSeriesReadModel.Serie[] series = result.Series;
// Assert
Assert.That(series.Length, Is.EqualTo(3));
ResultSeriesReadModel.Serie serie1 = series[0];
Assert.That(serie1.Tables.Count, Is.EqualTo(4));
VerifyTable(serie1.Tables[0], Tuple.Create(1, "player-1", 200, "player-2", 199));
VerifyTable(serie1.Tables[1], Tuple.Create(1, "player-3", 160, "player-4", 257));
VerifyTable(serie1.Tables[2], Tuple.Create(1, "player-5", 214, "player-6", 195));
VerifyTable(serie1.Tables[3], Tuple.Create(1, "player-7", 175, "player-8", 241));
ResultSeriesReadModel.Serie serie2 = series[1];
Assert.That(serie1.Tables.Count, Is.EqualTo(4));
VerifyTable(serie2.Tables[0], Tuple.Create(1, "player-7", 165, "player-8", 217));
VerifyTable(serie2.Tables[1], Tuple.Create(0, "player-5", 180, "player-6", 158));
VerifyTable(serie2.Tables[2], Tuple.Create(0, "player-3", 176, "player-4", 197));
VerifyTable(serie2.Tables[3], Tuple.Create(1, "player-1", 145, "player-2", 161));
ResultSeriesReadModel.Serie serie3 = series[2];
Assert.That(serie1.Tables.Count, Is.EqualTo(4));
VerifyTable(serie3.Tables[0], Tuple.Create(0, "player-3", 180, "player-4", 222));
VerifyTable(serie3.Tables[1], Tuple.Create(1, "player-1", 159, "player-2", 277));
VerifyTable(serie3.Tables[2], Tuple.Create(1, "player-7", 166, "player-8", 234));
VerifyTable(serie3.Tables[3], Tuple.Create(0, "player-5", 143, "player-6", 171));
}
public override async Task Handle(HandlerContext <Command> context)
{
Roster roster = CompositionRoot.DocumentSession.Load <Roster>(context.Payload.RosterId);
if (roster.IsVerified && context.Payload.Force == false)
{
return;
}
WebsiteConfig websiteConfig = CompositionRoot.DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
HeadInfo result = await CompositionRoot.BitsClient.GetHeadInfo(roster.BitsMatchId);
ParseHeaderResult header = BitsParser.ParseHeader(result, websiteConfig.ClubId);
// chance to update roster values
Roster.Update update = new(
Roster.ChangeType.VerifyMatchMessage,
"system")
{
OilPattern = header.OilPattern,
Date = header.Date,
Opponent = header.Opponent,
Location = header.Location
};
if (roster.MatchResultId != null)
{
// update match result values
BitsMatchResult bitsMatchResult = await CompositionRoot.BitsClient.GetBitsMatchResult(roster.BitsMatchId);
Player[] players = CompositionRoot.DocumentSession.Query <Player, PlayerSearch>()
.ToArray()
.Where(x => x.PlayerItem?.LicNbr != null)
.ToArray();
BitsParser parser = new(players);
if (roster.IsFourPlayer)
{
MatchResult4?matchResult = CompositionRoot.EventStoreSession.Load <MatchResult4>(roster.MatchResultId);
Parse4Result?parseResult = parser.Parse4(bitsMatchResult, websiteConfig.ClubId);
update.Players = parseResult !.GetPlayerIds();
bool isVerified = matchResult !.Update(
t => context.PublishMessage(t),
roster,
parseResult.TeamScore,
parseResult.OpponentScore,
roster.BitsMatchId,
parseResult.CreateMatchSeries(),
players);
update.IsVerified = isVerified;
}
else
{
MatchResult?matchResult =
CompositionRoot.EventStoreSession.Load <MatchResult>(roster.MatchResultId);
ParseResult?parseResult = parser.Parse(bitsMatchResult, websiteConfig.ClubId);
update.Players = parseResult !.GetPlayerIds();
Dictionary <string, ResultForPlayerIndex.Result> resultsForPlayer =
CompositionRoot.DocumentSession.Query <ResultForPlayerIndex.Result, ResultForPlayerIndex>()
.Where(x => x.Season == roster.Season)
.ToArray()
.ToDictionary(x => x.PlayerId);
MatchSerie[] matchSeries = parseResult.CreateMatchSeries();
bool isVerified = matchResult !.Update(
t => context.PublishMessage(t),
roster,
parseResult.TeamScore,
parseResult.OpponentScore,
matchSeries,
parseResult.OpponentSeries,
players,
resultsForPlayer);
update.IsVerified = isVerified;
}
}
_ = roster.UpdateWith(context.CorrelationId, update);
}
private async Task <IHttpActionResult> Handle(VerifyMatchMessage message)
{
Roster roster = DocumentSession.Load <Roster>(message.RosterId);
if (roster.IsVerified && message.Force == false)
{
return(Ok());
}
WebsiteConfig websiteConfig = DocumentSession.Load <WebsiteConfig>(WebsiteConfig.GlobalId);
HeadInfo result = await bitsClient.GetHeadInfo(roster.BitsMatchId);
ParseHeaderResult header = BitsParser.ParseHeader(result, websiteConfig.ClubId);
// chance to update roster values
var update = new Roster.Update(
Roster.ChangeType.VerifyMatchMessage,
"system")
{
OilPattern = header.OilPattern,
Date = header.Date,
Opponent = header.Opponent,
Location = header.Location
};
if (roster.MatchResultId != null)
{
// update match result values
BitsMatchResult bitsMatchResult = await bitsClient.GetBitsMatchResult(roster.BitsMatchId);
Player[] players = DocumentSession.Query <Player, PlayerSearch>()
.ToArray()
.Where(x => x.PlayerItem?.LicNbr != null)
.ToArray();
var parser = new BitsParser(players);
if (roster.IsFourPlayer)
{
MatchResult4 matchResult = EventStoreSession.Load <MatchResult4>(roster.MatchResultId);
Parse4Result parseResult = parser.Parse4(bitsMatchResult, websiteConfig.ClubId);
update.Players = GetPlayerIds(parseResult);
bool isVerified = matchResult.Update(
PublishMessage,
roster,
parseResult.TeamScore,
parseResult.OpponentScore,
roster.BitsMatchId,
parseResult.CreateMatchSeries(),
players);
update.IsVerified = isVerified;
}
else
{
MatchResult matchResult = EventStoreSession.Load <MatchResult>(roster.MatchResultId);
ParseResult parseResult = parser.Parse(bitsMatchResult, websiteConfig.ClubId);
update.Players = GetPlayerIds(parseResult);
var resultsForPlayer = DocumentSession.Query <ResultForPlayerIndex.Result, ResultForPlayerIndex>()
.Where(x => x.Season == roster.Season)
.ToArray()
.ToDictionary(x => x.PlayerId);
MatchSerie[] matchSeries = parseResult.CreateMatchSeries();
bool isVerified = matchResult.Update(
PublishMessage,
roster,
parseResult.TeamScore,
parseResult.OpponentScore,
matchSeries,
parseResult.OpponentSeries,
players,
resultsForPlayer);
update.IsVerified = isVerified;
}
}
roster.UpdateWith(Trace.CorrelationManager.ActivityId, update);
return(Ok());
}
