public void LoadDatabaseTest()
{
UnitTestDatabase database = new UnitTestDatabase();
SplatTagController controller = new SplatTagController(database);
controller.Initialise();
Assert.IsTrue(database.loadCalled);
database.loadCalled = false;
Team exampleTeam = new Team("Example Team", Builtins.ManualSource);
exampleTeam.AddClanTag("e.g", Builtins.ManualSource, TagOption.Front);
exampleTeam.AddDivision(new Division(1, DivType.DSB), Builtins.ManualSource);
var TEAM_ID = exampleTeam.Id;
database.expectedTeams = new List <Team> {
exampleTeam
};
var PLAYER_NAME = "Example Name";
database.expectedPlayers = new List <Player>
{
new Player(PLAYER_NAME, new Guid[] { TEAM_ID }, Builtins.ManualSource)
};
var PLAYER_ID = database.expectedPlayers[0].Id;
controller.LoadDatabase();
Assert.IsTrue(database.loadCalled);
// Also check the player and team is now in the controller
var players = controller.MatchPlayer(PLAYER_ID.ToString(), new MatchOptions {
FilterOptions = FilterOptions.SlappId
});
Assert.IsNotNull(players.FirstOrDefault());
var player = players[0];
Assert.IsTrue(player.Name.Value == PLAYER_NAME);
var teams = controller.MatchTeam(TEAM_ID.ToString(), new MatchOptions {
FilterOptions = FilterOptions.SlappId
});
Assert.IsNotNull(teams.FirstOrDefault());
var team = teams[0];
Assert.IsTrue(team.CurrentDiv.Value == 1);
Assert.IsTrue(team.CurrentDiv.DivType == DivType.DSB);
// Verify getting the players for that team returns our player
var playersForExampleTeam = controller.GetPlayersForTeam(exampleTeam);
Assert.IsNotNull(playersForExampleTeam);
Assert.IsTrue(playersForExampleTeam.Count == 1);
Assert.IsTrue(playersForExampleTeam[0].player.Equals(player));
}
private static void HandleCommandLineQuery(
string?b64,
string?query,
string?slappId,
bool exactCase,
bool exactCharacterRecognition,
string?rebuild,
string?patch,
bool keepOpen,
int limit,
bool verbose,
bool queryIsRegex,
bool queryIsClanTag,
bool queryIsTeam,
bool queryIsPlayer)
{
try
{
var options = new MatchOptions
{
IgnoreCase = !exactCase,
NearCharacterRecognition = !exactCharacterRecognition,
QueryIsRegex = queryIsRegex,
Limit = limit
};
if (queryIsPlayer)
{
options.FilterOptions = FilterOptions.Player;
}
else if (queryIsTeam)
{
options.FilterOptions = FilterOptions.Team;
}
else if (queryIsClanTag)
{
options.FilterOptions = FilterOptions.ClanTag;
}
else
{
options.FilterOptions = FilterOptions.Default;
}
CommandLineResult result = new CommandLineResult
{
Message = "OK",
Options = options
};
string?[] inputs = new string?[] { b64, query, slappId };
SplatTagController.Verbose = verbose;
if (rebuild != null)
{
if (rebuild.Equals(string.Empty))
{
SplatTagControllerFactory.GenerateNewDatabase();
result.Message = "Database rebuilt from default sources!";
}
else if (File.Exists(rebuild))
{
string?saveFolder = Directory.GetParent(rebuild)?.FullName;
string sourcesFile = Path.GetFileName(rebuild);
SplatTagControllerFactory.GenerateNewDatabase(saveFolder: saveFolder, sourcesFile: sourcesFile);
result.Message = $"Database rebuilt from {rebuild}!";
}
else
{
result.Message = $"Rebuild specified but the sources file specified `{rebuild}` from `{Directory.GetCurrentDirectory()}` does not exist. Aborting.";
}
}
else if (patch != null)
{
if (patch.Equals(string.Empty))
{
result.Message = "Patch specified but no patch sources file specified. Aborting.";
}
else if (File.Exists(patch))
{
SplatTagControllerFactory.GenerateDatabasePatch(patchFile: patch);
result.Message = $"Database patched from {patch}!";
}
else
{
result.Message = $"Patch specified but the sources file specified `{patch}` from `{Directory.GetCurrentDirectory()}` does not exist. Aborting.";
}
}
else if (inputs.All(s => string.IsNullOrEmpty(s)))
{
if (keepOpen)
{
// First run to open
result.Message = $"Connection established. {splatTagController.MatchPlayer(null).Length} players and {splatTagController.MatchTeam(null).Length} teams loaded.";
}
else
{
result.Message = "Nothing to search!";
}
}
else
{
try
{
if (new[] { b64, query, slappId }.Count(s => !string.IsNullOrEmpty(s)) > 1)
{
result.Message = "Warning: Multiple inputs defined. YMMV.";
}
if (!string.IsNullOrEmpty(b64))
{
result.Query = query = Encoding.UTF8.GetString(Convert.FromBase64String(b64));
}
if (!string.IsNullOrEmpty(slappId))
{
result.Query = slappId;
options.FilterOptions = FilterOptions.SlappId;
result.Players = splatTagController.MatchPlayer(slappId, options);
result.Teams = splatTagController.MatchTeam(slappId, options);
}
else
{
Console.WriteLine($"Building result for query={query}");
result.Query = query ?? string.Empty;
result.Players = splatTagController.MatchPlayer(query, options);
result.Teams = splatTagController.MatchTeam(query, options);
}
if (result.Players.Length > 0 || result.Teams.Length > 0)
{
result.AdditionalTeams =
result.Players
.SelectMany(p => p.TeamInformation.GetAllTeamsUnordered().Select(id => splatTagController.GetTeamById(id)))
.Distinct()
.ToDictionary(t => t.Id, t => t);
result.AdditionalTeams[Team.NoTeam.Id] = Team.NoTeam;
result.AdditionalTeams[Team.UnlinkedTeam.Id] = Team.UnlinkedTeam;
result.PlayersForTeams =
result.Teams
.ToDictionary(t => t.Id, t => splatTagController.GetPlayersForTeam(t).ToArray());
foreach (var pair in result.PlayersForTeams)
{
foreach ((Player, bool)tuple in pair.Value)
{
foreach (Guid t in tuple.Item1.TeamInformation.GetAllTeamsUnordered())
{
result.AdditionalTeams.TryAdd(t, splatTagController.GetTeamById(t));
}
}
}
var sources = new HashSet <string>();
foreach (var s in result.Players.SelectMany(p => p.Sources))
{
sources.Add(s.Name);
}
foreach (var s in result.Teams.SelectMany(t => t.Sources))
{
sources.Add(s.Name);
}
foreach (var s in result.AdditionalTeams.Values.SelectMany(t => t.Sources))
{
sources.Add(s.Name);
}
foreach (var s in result.PlayersForTeams.Values.SelectMany(tupleArray => tupleArray.SelectMany(p => p.Item1.Sources)))
{
sources.Add(s.Name);
}
sources.Add(Builtins.BuiltinSource.Name);
sources.Add(Builtins.ManualSource.Name);
result.Sources = sources.ToArray();
try
{
result.PlacementsForPlayers = new Dictionary <Guid, Dictionary <string, Bracket[]> >();
foreach (var player in result.Players)
{
result.PlacementsForPlayers[player.Id] = new Dictionary <string, Bracket[]>();
foreach (var source in player.Sources)
{
result.PlacementsForPlayers[player.Id][source.Name] = source.Brackets;
}
}
}
catch (OutOfMemoryException oom)
{
const string message = "ERROR: OutOfMemoryException on PlacementsForPlayers. Will continue anyway.";
Console.WriteLine(message);
Console.WriteLine(oom.ToString());
result.PlacementsForPlayers = new Dictionary <Guid, Dictionary <string, Bracket[]> >();
}
}
}
catch (Exception ex)
{
string message = $"ERROR: {ex.GetType().Name} while compiling data for serialization...";
Console.WriteLine(message);
Console.WriteLine(ex.ToString());
string q = result.Query;
result = new CommandLineResult
{
Query = q,
Options = options,
Message = message,
};
}
}
string messageToSend;
try
{
StringWriter sw = new StringWriter();
serializer.Serialize(sw, result);
messageToSend = sw.ToString();
}
catch (Exception ex)
{
string message = $"ERROR: {ex.GetType().Name} while serializing result...";
Console.WriteLine(message);
Console.WriteLine(ex.ToString());
string q = result.Query;
result = new CommandLineResult
{
Query = q,
Options = options,
Message = message
};
// Attempt to send the message as a different serialized error
StringWriter sw = new StringWriter();
serializer.Serialize(sw, result);
messageToSend = sw.ToString();
}
// Send back as a b64 string
Console.WriteLine(Convert.ToBase64String(Encoding.UTF8.GetBytes(messageToSend)));
}
catch (Exception ex)
{
Console.WriteLine($"ERROR: Outer Exception handler, caught a {ex.GetType().Name}...");
Console.WriteLine(ex.ToString());
}
finally
{
errorMessagesReported.Clear();
}
}