public async Task CreateQuickMatchWithAlliance()
{
var session = await Login();
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(session.Id);
var quickMatch = new QuickMatch {
AlliancesOnly = true
};
var matchResponse = await client.PostAsJsonAsync("/api/matches", quickMatch);
Assert.Equal(HttpStatusCode.Created, matchResponse.StatusCode);
var matchGet = await matchResponse.Content.ReadAsStringAsync();
var match = JsonConvert.DeserializeObject <Match>(matchGet, Actor.JsonSerializerSettings());
Assert.Equal(session.Player.Id, match.Tournament.OwnerId);
Assert.False(match.IsFinished);
Assert.False(match.IsDeleted);
}
}
/// <summary>
/// A consolidated version of ConvertInput.
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
static public string Parse(Generator.Export.Intrinsic.IDataConfig config)
{
// TableElement tableElementbackup = config.Table;
string tableOut = Parse(config.Databases, config.Table, config.Template);
List <QuickMatch> list;
while (0 != (list = TemplateReferenceUtil.GetReferences(tableOut)).Count)
{
// we could restore the table if it was changed
QuickMatch match0 = list[0];
if (!list[0].HasParams) /* error no parameters */ continue {
;
}
string newOut = string.Empty;
// TableTemplate tbltmpl = null;
if (!match0.HasMultipleParams) // single parameter-match
{
bool checker = config.HasTemplate(list[0].Params[0]);
Debug.Assert(checker, string.Format("Template {0} not found! if you continue, the generated content will have errors.", match0.Params[0]));
if (checker)
{
config.Template = config.Templates[list[0].Params[0]];
newOut = Parse(config);
tableOut = tableOut.Replace(list[0].FullString, newOut);
}
}
else // Multiple param-matches
{
for (int i = 1; i < match0.Params.Length; i++)
{
bool checker = config.HasTemplate(match0.Params[0]);
Debug.Assert(checker, string.Format("Template {0} not found! if you continue, the generated content will have errors.", match0.Params[0]));
if (checker)
{
config.Template = config.Templates[match0.Params[0]];
config.Table = config.Database[match0.Params[i]];
newOut += Parse(config);
}
}
tableOut = tableOut.Replace(list[0].FullString, newOut);
}
}
static string WritePart(TemplateModel view, QuickMatch match, string generatedIn)
{
string generatedOut = generatedIn; // QuickMatch match0 = list[0]; // Logger.LogY("TemplateFactory.WritePart","{0}", match.Value);// this is "TemplateName,TableName"
if (!match.HasParams)
{
Logger.Warn("TemplateFactory.WritePart", "ERROR: No Params"); return(generatedIn);
}
if (!match.HasMultipleParams)
{
view.SetTemplate(match.Params[0]);
if (view.TT == null)
{
Logger.Warn("TemplateFactory.WritePart ERROR", "Tag: ‘{0}’ value.", match.Name); return(generatedIn);
}
generatedOut = generatedIn.Replace(match.FullString, Gen_Pass2(view)); // replace the template tag with the parsed content.
}
// the Directory Element is not parsed.
else if (match.Name == "Directory")
{
if (System.IO.Directory.Exists(match.Value))
{
var listf = new List <string>();
foreach (string dir in System.IO.Directory.GetDirectories(match.Value))
{
listf.Add(dir);
}
generatedOut = generatedIn.Replace(match.FullString, string.Join(",", listf.ToArray()));
}
}
// ¡MAIN PARSER LOOP!
else
{
string newOut = string.Empty;
for (int i = 1; i < match.Params.Length; i++) // match.Params[i] = table-name; notice I starts at one
{
view.SetTemplate(match.Params[0]);
view.SetView(match.Params[i]);
newOut += Gen_Pass2(view);
}
generatedOut = generatedIn.Replace(match.FullString, newOut);
}
return(generatedOut);
}
public async Task CreateQuickMatchWithAllianceForNonAlliedPlayer()
{
var ben = await Login("ben", "ben");
using (var client = new HttpClient {
BaseAddress = new Uri(ServerUrl)
})
{
client.AcceptJson().AddSessionHeader(ben.Id);
var quickMatch = new QuickMatch {
AlliancesOnly = true
};
var matchResponse = await client.PostAsJsonAsync("/api/matches", quickMatch);
Assert.Equal(HttpStatusCode.NotFound, matchResponse.StatusCode);
var response = await matchResponse.Content.ReadAsJsonAsync <ApiError>();
Assert.Equal("No Players available for match at this moment.", response.Error);
}
}
private async Task <QuickMatchResult> QuickMatch(QuickMatch quickMatch, IEnumerable <Group> groups)
{
Tournament tournament;
ContentResult error;
if (quickMatch.Tournament.HasValue && quickMatch.Tournament != Guid.Empty)
{
tournament = await _context.Tournaments.FindAsync(quickMatch.Tournament);
if (tournament == null)
{
return(new QuickMatchResult
{
match = null,
error = HttpResponseHelper.BadRequest("Invalid Tournament.")
});
}
}
else
{
tournament = new Tournament {
OwnerId = session.Player.Id
};
_context.Tournaments.Add(tournament);
error = await SaveChangesAsync();
if (error != null)
{
return(new QuickMatchResult {
match = null, error = error
});
}
}
// Create Match
var match = new Match {
TournamentId = tournament.Id, TotalRounds = quickMatch.Rounds
};
_context.Matches.Add(match);
error = await SaveChangesAsync();
if (error != null)
{
return(new QuickMatchResult {
match = match, error = error
});
}
foreach (var actor in groups)
{
error = await MatchActor.Add(_context, match, actor);
if (error != null)
{
return(new QuickMatchResult {
match = match, error = error
});
}
}
return(new QuickMatchResult {
match = match, error = null
});
}
public async Task <IActionResult> CreateQuickMatch([FromBody] QuickMatch quickMatch)
{
if (session?.Player == null)
{
return(HttpResponseHelper.NotFound("No Session/Player found."));
}
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var result = new QuickMatchResult();
// Build the filter by CustomData
var customData = CustomDataBase.Parse(quickMatch.CustomData);
if (quickMatch.Type == MatchType.Player)
{
var players =
await
Player.LoadRandom(
_context,
session.Player,
customData,
quickMatch.AlliancesOnly,
quickMatch.Actors - 1);
players.Add(session.Player);
if (players.Count < quickMatch.Actors)
{
return(HttpResponseHelper.NotFound("No Players available for match at this moment."));
}
result = await QuickMatch(quickMatch, players);
}
else if (quickMatch.Type == MatchType.Group)
{
if (!quickMatch.ActorId.HasValue || quickMatch.ActorId == Guid.Empty)
{
return(HttpResponseHelper.BadRequest("GroupId is required for Group Matches."));
}
var group = session.Player.Groups.FirstOrDefault(g => g.Id.Equals(quickMatch.ActorId));
if (group == null)
{
return(HttpResponseHelper.NotFound("No such Group found for Player."));
}
var groups =
await Group.LoadRandom(_context, group, customData, quickMatch.AlliancesOnly, quickMatch.Actors - 1);
groups.Add(group);
if (groups.Count < quickMatch.Actors)
{
return(HttpResponseHelper.NotFound("No Groups available for match at this moment."));
}
result = await QuickMatch(quickMatch, groups);
}
if (result.error != null)
{
return(result.error);
}
return(CreatedAtRoute("GetMatchDetailed", new { id = result.match.Id }, result.match));
}
