private IEnumerable <PokerBaaziPackage> ReadPackages(string testFolder)
{
var packages = new List <PokerBaaziPackage>();
var sourceJsonFile = Path.Combine(PokerBaaziTestsHelper.TestDataFolder, TestDataFolder, testFolder, SourceJsonFile);
FileAssert.Exists(sourceJsonFile);
var sourceJson = File.ReadAllText(sourceJsonFile);
var testObject = JsonConvert.DeserializeObject <PokerBaaziTestSourceObject>(sourceJson);
foreach (var packet in testObject.Packets)
{
var json = JsonConvert.SerializeObject(packet);
var package = new PokerBaaziPackage
{
PackageType = PokerBaaziPackage.ParsePackageType(json),
JsonData = json
};
packages.Add(package);
}
return(packages);
}
public void ParsePackageTypeTests(string file, PokerBaaziPackageType expectedPackageType)
{
file = Path.Combine(PokerBaaziTestsHelper.TestDataFolder, file);
FileAssert.Exists(file);
var data = File.ReadAllText(file);
Assert.IsNotEmpty(data);
var actualPackageType = PokerBaaziPackage.ParsePackageType(data);
Assert.That(actualPackageType, Is.EqualTo(expectedPackageType));
}
public void PokerBaaziPackageTryParseTest(string file, int lineNum, bool expectedResult, uint roomId, long tournamentId, PokerBaaziPackageType expectedType)
{
var lines = GetFileLines(file);
Assert.That(lines.Length, Is.GreaterThan(lineNum));
var data = lines[lineNum];
Assert.IsNotEmpty(data);
var result = PokerBaaziPackage.TryParse(data, out PokerBaaziPackage package);
Assert.Multiple(() =>
{
Assert.That(result, Is.EqualTo(expectedResult), $"TryParse must return expected result.");
Assert.That(package.RoomId, Is.EqualTo(roomId), $"RoomId must be equal expected.");
Assert.That(package.TournamentId, Is.EqualTo(tournamentId), $"TournamentId must be equal expected.");
Assert.That(package.PackageType, Is.EqualTo(expectedType), $"PackageType must be equal expected.");
});
}
/// <summary>
/// Tries to build hand history by using buffered packages or buffer the specified package for further using
/// </summary>
/// <param name="package">Package to buffer</param>
/// <param name="handHistory">Hand history</param>
/// <returns>True if hand can be built; otherwise - false</returns>
public bool TryBuild(PokerBaaziPackage package, out HandHistory handHistory, out PokerBaaziHandBuilderError builderError)
{
handHistory = null;
builderError = PokerBaaziHandBuilderError.None;
if (package == null)
{
return(false);
}
if (package.PackageType == PokerBaaziPackageType.InitResponse)
{
ParsePackage <PokerBaaziInitResponse>(package, x => ProcessInitResponse(x));
return(false);
}
else if (package.PackageType == PokerBaaziPackageType.TournamentDetailsResponse)
{
ParsePackage <PokerBaaziTournamentDetailsResponse>(package, x => ProcessTournamentDetailsResponse(x));
return(false);
}
if (!roomPackages.TryGetValue(package.RoomId, out List <PokerBaaziPackage> packages))
{
packages = new List <PokerBaaziPackage>();
roomPackages.Add(package.RoomId, packages);
}
packages.Add(package);
if (package.PackageType == PokerBaaziPackageType.WinnerResponse)
{
handHistory = BuildHand(packages, out builderError);
}
return(handHistory != null && handHistory.Players.Count > 0);
}
/// <summary>
/// Processes buffer data
/// </summary>
protected virtual void ProcessBuffer()
{
var handBuilder = ServiceLocator.Current.GetInstance <IPokerBaaziHandBuilder>();
var windows = new Dictionary <uint, IntPtr>();
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
if (!packetBuffer.TryTake(out string capturedData))
{
Task.Delay(NoDataDelay).Wait();
continue;
}
if (!PokerBaaziPackage.TryParse(capturedData, out PokerBaaziPackage package))
{
continue;
}
var windowHandle = IntPtr.Zero;
if (package.PackageType == PokerBaaziPackageType.InitResponse)
{
var windowsToRemove = windows.Where(x => !WinApi.IsWindow(x.Value)).ToArray();
windowsToRemove.ForEach(x => windows.Remove(x.Key));
}
// Get window related to the package
if (package.RoomId != 0 && !windows.TryGetValue(package.RoomId, out windowHandle))
{
var windowsToRemove = windows.Where(x => !WinApi.IsWindow(x.Value)).ToArray();
windowsToRemove.ForEach(x => windows.Remove(x.Key));
var initResponse = handBuilder.FindInitResponse(package.RoomId);
if (initResponse != null)
{
var existingWindows = new HashSet <IntPtr>(windows.Values);
windowHandle = FindWindow(initResponse, existingWindows);
if (windowHandle != IntPtr.Zero)
{
windows.Add(package.RoomId, windowHandle);
Task.Run(() =>
{
Task.Delay(ShowPreHUDDelay).Wait();
SendPreImporedData("Notifications_HudLayout_PreLoadingText_PB", windowHandle);
});
}
}
}
if (!handBuilder.TryBuild(package, out HandHistory handHistory, out PokerBaaziHandBuilderError builderError))
{
if (builderError == PokerBaaziHandBuilderError.TournamentDetailsNotFound &&
windowHandle != IntPtr.Zero)
{
Task.Run(() =>
{
Task.Delay(ShowPreHUDDelay).Wait();
SendPreImporedData("Notifications_HudLayout_PreLoadingText_NoTournamentDetails", windowHandle);
});
}
continue;
}
var handHistoryText = SerializationHelper.SerializeObject(handHistory);
#if DEBUG
if (!Directory.Exists("Hands"))
{
Directory.CreateDirectory("Hands");
}
File.WriteAllText($"Hands\\pokerbaazi_hand_exported_{handHistory.HandId}.xml", handHistoryText);
#endif
var gameInfo = new GameInfo
{
WindowHandle = windowHandle.ToInt32(),
PokerSite = EnumPokerSites.PokerBaazi,
GameNumber = handHistory.HandId,
Session = windowHandle.ToString()
};
ProcessHand(handHistoryText, gameInfo);
}
catch (Exception e)
{
LogProvider.Log.Error(this, $"Could not process captured data. [{SiteString}]", e);
}
}
}
