public static async Task <IReadOnlyList <Class> > GetClassesAsync(GameServiceClient client, IReadOnlyList <Class> classes)
{
if (classes == null)
{
var request = new GetClassesRequest();
request.Fields.AddRange(new[] { ClassField.ClassId, ClassField.ClassName });
classes = (await client.GetClassesAsync(request)).Classes.ToList();
}
return(classes);
}
public static async Task DisplayClassesAsync(GameServiceClient client, IReadOnlyList <int> classIds = null, string name = null, NameMatchStyle nameMatchStyle = NameMatchStyle.MixedCase)
{
var request = new GetClassesRequest();
if (classIds != null && classIds.Count() != 0)
{
request.ClassIds.AddRange(classIds);
}
else if (!string.IsNullOrWhiteSpace(name))
{
request.Name = name;
}
request.NameMatchStyle = nameMatchStyle;
var classes = await client.GetClassesAsync(request);
foreach (var @class in classes.Classes)
{
ConsoleUtility.WriteLine($"{@class}");
}
}
public static async Task <GetClassesReply> GetClassesAsync(GetClassesRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new GetClassesReply {
Status = new Status {
Code = 200
}
};
var select = DatabaseDefinition.BuildSelectStatement(request.Fields);
var joins = DatabaseDefinition.BuildRequiredJoins(request.Fields);
var where = !string.IsNullOrWhiteSpace(request.Name) ?
$"where { DatabaseDefinition.BuildWhereStatement(ClassField.ClassName, WhereStatementType.Like)}" :
request.ClassIds.Count() != 0 ?
$"where { DatabaseDefinition.BuildWhereStatement(ClassField.ClassId, WhereStatementType.Includes)}" :
"";
var whereMatch = !string.IsNullOrWhiteSpace(request.Name) ?
new (string, object)[] { (DatabaseDefinition.GetSelectResult(ClassField.ClassName), $"%{request.Name}%") } :
public static async Task <CreateAlliesReply> CreateAlliesAsync(CreateAlliesRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateAlliesReply {
Status = new Status {
Code = 200
}
};
List <int> newAllyIds = new List <int>();
foreach (var ally in request.Allies)
{
// Validate the GamePackageId
var packageRequest = new GetGamePackagesRequest();
packageRequest.GamePackageIds.Add(ally.GamePackageId);
packageRequest.Fields.Add(GamePackageField.Id);
var packageReply = await GamePackageUtility.GetGamePackagesAsync(packageRequest, context);
if (packageReply.Status.Code != 200)
{
reply.Status = packageReply.Status;
return(reply);
}
// Validate the AbilityIds
var abilitiesRequest = new GetAbilitiesRequest();
abilitiesRequest.AbilityIds.AddRange(ally.AbilityIds);
abilitiesRequest.AbilityFields.Add(AbilityField.Id);
var abilitiesReply = await AbilityUtility.GetAbilitiesAsync(abilitiesRequest, context);
if (abilitiesReply.Status.Code != 200)
{
reply.Status = abilitiesReply.Status;
return(reply);
}
// Verify that this ally doesn't already exist
var allyRequest = new GetAlliesRequest();
allyRequest.Name = ally.Name;
allyRequest.Fields.AddRange(new[] { AllyField.AllyId, AllyField.AllyName, AllyField.AllyGamePackageId });
allyRequest.NameMatchStyle = NameMatchStyle.MixedCase;
var allyReply = await GetAlliesAsync(allyRequest, context);
if (allyReply.Status.Code == 200 && allyReply.Allies.Any())
{
var matchingAlly = allyReply.Allies.First();
reply.Status = new Status {
Code = 400, Message = $"Ally {matchingAlly.Id} with name '{matchingAlly.Name}' was found in game package '{matchingAlly.GamePackageId}'"
};
return(reply);
}
// Verify that the class counts add up to at least 14
if (ally.Classes.Select(x => x.Count).Sum() < 14)
{
reply.Status = new Status {
Code = 400, Message = $"Ally with name '{ally.Name}' must be supplied with at least 14 class cards."
};
return(reply);
}
// Verify that the classIds are valid
var classesRequest = new GetClassesRequest();
classesRequest.ClassIds.AddRange(ally.Classes.Select(x => x.ClassId));
classesRequest.Fields.Add(ClassField.ClassId);
var classesReply = await ClassUtility.GetClassesAsync(classesRequest, context);
if (classesReply.Status.Code != 200)
{
reply.Status = classesReply.Status;
return(reply);
}
// Create the ally
var newAllyId = ((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[AllyField.AllyName]}, {DatabaseDefinition.ColumnName[AllyField.AllyTeamId]})
values (@AllyName, @AllyTeamId);
select last_insert_id();" ,
("AllyName", ally.Name),
("AllyTeamId", ally.TeamId))
.QuerySingleAsync <ulong>()));
// Add to game package
await connector.Command(
$@"
insert
into {TableNames.GamePackageAllies}
({DatabaseDefinition.ColumnName[AllyField.AllyId]}, {GamePackageUtility.DatabaseDefinition.ColumnName[GamePackageField.Id]})
values (@AllyId, @GamePackageId);" ,
("AllyId", newAllyId),
("GamePackageId", ally.GamePackageId))
.ExecuteAsync();
// Link abilities
foreach (var abilityId in ally.AbilityIds)
{
await connector.Command(
$@"
insert
into {TableNames.AllyAbilities}
({DatabaseDefinition.ColumnName[AllyField.AllyId]}, {AbilityUtility.DatabaseDefinition.ColumnName[AbilityField.Id]})
values (@AllyId, @AbilityId);" ,
("AllyId", newAllyId),
("AbilityId", abilityId))
.ExecuteAsync();
}
// Add class info
foreach (var classInfo in ally.Classes)
{
await connector.Command(
$@"
insert
into {TableNames.AllyClasses}
({DatabaseDefinition.ColumnName[AllyField.AllyId]}, {ClassUtility.DatabaseDefinition.ColumnName[ClassField.ClassId]}, CardCount)
values (@AllyId, @ClassId, @CardCount);" ,
("AllyId", newAllyId),
("ClassId", classInfo.ClassId),
("CardCount", classInfo.Count))
.ExecuteAsync();
}
newAllyIds.Add(newAllyId);
}
// Get all of the created ally
var finalRequest = new GetAlliesRequest();
finalRequest.AllyIds.AddRange(newAllyIds);
var finalReply = await GetAlliesAsync(finalRequest, context);
reply.Status = finalReply.Status;
reply.Allies.AddRange(finalReply.Allies);
return(reply);
}
public override async Task <GetClassesReply> GetClasses(GetClassesRequest request, ServerCallContext context)
{
return(await ClassUtility.GetClassesAsync(request, context));
}
