public static async Task <GetHenchmenReply> GetHenchmenAsync(GetHenchmenRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new GetHenchmenReply {
Status = new Status {
Code = 200
}
};
if (request.Fields.Count() == 0)
{
request.Fields.AddRange(DatabaseDefinition.BasicFields);
}
// Need to remove abilityIds field because it's handled separately from the main db request
var includeAbilityIds = request.Fields.Remove(HenchmanField.HenchmanAbilityIds);
var select = DatabaseDefinition.BuildSelectStatement(request.Fields);
var joins = DatabaseDefinition.BuildRequiredJoins(request.Fields);
var where = !string.IsNullOrWhiteSpace(request.Name) ?
$"where { DatabaseDefinition.BuildWhereStatement(HenchmanField.HenchmanName, DatabaseUtility.GetWhereComparisonType(request.NameMatchStyle))}" :
request.HenchmanIds.Count() != 0 ?
$"where { DatabaseDefinition.BuildWhereStatement(HenchmanField.HenchmanId, WhereStatementType.Includes)}" :
"";
var whereMatch = !string.IsNullOrWhiteSpace(request.Name) ?
new (string, object)[] { (DatabaseDefinition.GetSelectResult(HenchmanField.HenchmanName), request.NameMatchStyle == NameMatchStyle.Similar ? $"%{request.Name}%" : request.Name) } :
public static async Task <GetAbilitiesReply> GetAbilitiesAsync(GetAbilitiesRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new GetAbilitiesReply {
Status = new Status {
Code = 200
}
};
var select = DatabaseDefinition.BuildSelectStatement(request.AbilityFields);
var joins = DatabaseDefinition.BuildRequiredJoins(request.AbilityFields);
var where = request.GamePackageId != 0 ?
$"where { DatabaseDefinition.BuildWhereStatement(AbilityField.GamePackageId, WhereStatementType.Equals)}" :
request.AbilityIds.Count() != 0 ?
$"where { DatabaseDefinition.BuildWhereStatement(AbilityField.Id, WhereStatementType.Includes)}" :
!string.IsNullOrWhiteSpace(request.Name) ?
$"where { DatabaseDefinition.BuildWhereStatement(AbilityField.Name, WhereStatementType.Like)}" :
"";
var whereMatch = request.GamePackageId != 0 ?
new (string, object)[] { (DatabaseDefinition.GetSelectResult(AbilityField.GamePackageId), request.GamePackageId) } :
internal static async ValueTask <int> AddSchemeTwistRequirementAsync(SchemeTwistRequirement requirement)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
return((int)(await connector.Command(
$@"
insert into {TableNames.TwistRequirements} (TwistCount, IsAllowed)
values ({requirement.SchemeTwistCount}, {requirement.Allowed});
select last_insert_id();" )
.QuerySingleAsync <ulong>()));
}
public static async Task <CreateTeamsReply> CreateTeamsAsync(CreateTeamsRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateTeamsReply {
Status = new Status {
Code = 200
}
};
var teams = await GetTeamsAsync(new GetTeamsRequest(), context);
var teamsToAdd = request.Teams.Where(x => !teams.Teams.Any(y => y.Name.Equals(x.Name, StringComparison.OrdinalIgnoreCase))).ToList();
if (teamsToAdd.Count != request.Teams.Count() && request.CreateOptions.Contains(CreateOptions.ErrorOnDuplicates))
{
reply.Status.Code = 400;
reply.Status.Message = $"Cannot add duplicate teams ({request.Teams.Except(teamsToAdd).Select(x => x.Name).Join(", ")}).";
return(reply);
}
List <int> insertIds = request.Teams.Except(teamsToAdd).Select(x => x.Id).ToList();
foreach (var team in teamsToAdd)
{
insertIds.Add((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[TeamField.TeamName]}, {DatabaseDefinition.ColumnName[TeamField.TeamImagePath]})
values (@TeamName, @ImagePath);
select last_insert_id();" ,
("TeamName", team.Name),
("ImagePath", team.ImagePath))
.QuerySingleAsync <ulong>()));
}
var finalTeamsList = new GetTeamsRequest();
finalTeamsList.TeamIds.AddRange(insertIds);
var createdTeams = await GetTeamsAsync(finalTeamsList, context);
reply.Teams.AddRange(createdTeams.Teams);
return(reply);
}
internal static async ValueTask <int> AddCardRequirement(CardRequirement requirement)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
// Create new card requirement
var insertColumnInfo = GetInsertColumnValue(requirement);
var insertCardTypeInfo = await GetInsertCardTypeValue(requirement, connector);
var query = $@"insert into {TableNames.CardRequirements} ({insertColumnInfo.Name}, {insertCardTypeInfo.Name}) values (@{insertColumnInfo.Name}, @{insertCardTypeInfo.Name}); select last_insert_id();";
return((int)await connector.Command(query,
insertColumnInfo,
insertCardTypeInfo)
.QuerySingleAsync <ulong>());
}
public static async Task <GetNeutralsReply> GetNeutralsAsync(GetNeutralsRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new GetNeutralsReply {
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(NeutralField.NeutralName, DatabaseUtility.GetWhereComparisonType(request.NameMatchStyle))}" :
request.NeutralIds.Count() != 0 ?
$"where { DatabaseDefinition.BuildWhereStatement(NeutralField.NeutralId, WhereStatementType.Includes)}" :
"";
var whereMatch = !string.IsNullOrWhiteSpace(request.Name) ?
new (string, object)[] { (DatabaseDefinition.GetSelectResult(NeutralField.NeutralName), request.NameMatchStyle == NameMatchStyle.Similar ? $"%{request.Name}%" : request.Name) } :
internal static async ValueTask <IReadOnlyList <CardRequirement> > GetCardRequirementsAsync(int ownerId)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var fields = DatabaseDefinition.BasicFields;
var numberOfPlayersResult = $"{TableNames.MatchedCardRequirements}_NumberOfPlayers";
var selectStatement = DatabaseDefinition.BuildSelectStatement(fields);
var joinStatement = DatabaseDefinition.BuildRequiredJoins(fields);
var whereStatement = $"where {DatabaseDefinition.BuildWhereStatement(CardRequirement.OwnerIdFieldNumber, WhereStatementType.Equals)}";
// Create new card requirement
return(await connector.Command($@"
select {selectStatement}
from {DatabaseDefinition.DefaultTableName}
{joinStatement}
{whereStatement};" ,
(DatabaseDefinition.GetSelectResult(CardRequirement.OwnerIdFieldNumber), ownerId))
.QueryAsync(x => MapCardRequirement(x, DatabaseDefinition.BasicFields)));
}
public static async Task <CreateNeutralsReply> CreateNeutralsAsync(CreateNeutralsRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateNeutralsReply {
Status = new Status {
Code = 200
}
};
List <int> newNeutralIds = new List <int>();
foreach (var neutral in request.Neutrals)
{
// Validate the GamePackageId
var packageRequest = new GetGamePackagesRequest();
packageRequest.GamePackageIds.Add(neutral.GamePackageId);
packageRequest.Fields.Add(GamePackageField.Id);
var packageReply = await GamePackageUtility.GetGamePackagesAsync(packageRequest, context);
if (packageReply.Status.Code != 200)
{
reply.Status = packageReply.Status;
return(reply);
}
// Verify that this neutral doesn't already exist
var neutralRequest = new GetNeutralsRequest();
neutralRequest.Name = neutral.Name;
neutralRequest.Fields.AddRange(new[] { NeutralField.NeutralId, NeutralField.NeutralName, NeutralField.NeutralGamePackageId });
neutralRequest.NameMatchStyle = NameMatchStyle.MixedCase;
var neutralReply = await GetNeutralsAsync(neutralRequest, context);
if (neutralReply.Status.Code == 200 && neutralReply.Neutrals.Any(x => x.GamePackageId == neutral.GamePackageId))
{
var matchingNeutral = neutralReply.Neutrals.First();
reply.Status = new Status {
Code = 400, Message = $"Neutral {matchingNeutral.Id} with name '{matchingNeutral.Name}' was found in game package '{matchingNeutral.GamePackageId}'"
};
return(reply);
}
// Create the neutral
var newNeutralId = ((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[NeutralField.NeutralName]})
values (@NeutralName);
select last_insert_id();" ,
("NeutralName", neutral.Name))
.QuerySingleAsync <ulong>()));
// Add to game package
await connector.Command(
$@"
insert
into {TableNames.GamePackageNeutrals}
({DatabaseDefinition.ColumnName[NeutralField.NeutralId]}, {GamePackageUtility.DatabaseDefinition.ColumnName[GamePackageField.Id]})
values (@NeutralId, @GamePackageId);" ,
("NeutralId", newNeutralId),
("GamePackageId", neutral.GamePackageId))
.ExecuteAsync();
newNeutralIds.Add(newNeutralId);
}
// Get all of the created neutrals
var finalRequest = new GetNeutralsRequest();
finalRequest.NeutralIds.AddRange(newNeutralIds);
var finalReply = await GetNeutralsAsync(finalRequest, context);
reply.Status = finalReply.Status;
reply.Neutrals.AddRange(finalReply.Neutrals);
return(reply);
}
public static async Task <CreateHenchmenReply> CreateHenchmenAsync(CreateHenchmenRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateHenchmenReply {
Status = new Status {
Code = 200
}
};
List <int> newHenchmenIds = new List <int>();
foreach (var henchman in request.Henchmen)
{
// Validate the GamePackageId
var packageRequest = new GetGamePackagesRequest();
packageRequest.GamePackageIds.Add(henchman.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(henchman.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 henchman doesn't already exist
var henchmanRequest = new GetHenchmenRequest();
henchmanRequest.Name = henchman.Name;
henchmanRequest.Fields.AddRange(new[] { HenchmanField.HenchmanId, HenchmanField.HenchmanName, HenchmanField.HenchmanGamePackageId });
henchmanRequest.NameMatchStyle = NameMatchStyle.MixedCase;
var henchmanReply = await GetHenchmenAsync(henchmanRequest, context);
if (henchmanReply.Status.Code == 200 && henchmanReply.Henchmen.Any())
{
var matchingHenchman = henchmanReply.Henchmen.First();
reply.Status = new Status {
Code = 400, Message = $"Henchman {matchingHenchman.Id} with name '{matchingHenchman.Name}' was found in game package '{matchingHenchman.GamePackageId}'"
};
return(reply);
}
// Create the henchman
var newHenchmanId = ((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[HenchmanField.HenchmanName]})
values (@HenchmanName);
select last_insert_id();" ,
("HenchmanName", henchman.Name))
.QuerySingleAsync <ulong>()));
// Add to game package
await connector.Command(
$@"
insert
into {TableNames.GamePackageHenchmen}
({DatabaseDefinition.ColumnName[HenchmanField.HenchmanId]}, {GamePackageUtility.DatabaseDefinition.ColumnName[GamePackageField.Id]})
values (@HenchmanId, @GamePackageId);" ,
("HenchmanId", newHenchmanId),
("GamePackageId", henchman.GamePackageId))
.ExecuteAsync();
// Link abilities
foreach (var abilityId in henchman.AbilityIds)
{
await connector.Command(
$@"
insert
into {TableNames.HenchmanAbilities}
({DatabaseDefinition.ColumnName[HenchmanField.HenchmanId]}, {AbilityUtility.DatabaseDefinition.ColumnName[AbilityField.Id]})
values (@HenchmanId, @AbilityId);" ,
("HenchmanId", newHenchmanId),
("AbilityId", abilityId))
.ExecuteAsync();
}
newHenchmenIds.Add(newHenchmanId);
}
// Get all of the created henchmen
var finalRequest = new GetHenchmenRequest();
finalRequest.HenchmanIds.AddRange(newHenchmenIds);
var finalReply = await GetHenchmenAsync(finalRequest, context);
reply.Status = finalReply.Status;
reply.Henchmen.AddRange(finalReply.Henchmen);
return(reply);
}
public static async Task <CreateSchemesReply> CreateSchemesAsync(CreateSchemesRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateSchemesReply {
Status = new Status {
Code = 200
}
};
List <int> newSchemeIds = new List <int>();
var cardSetTypeInfo = await CardRequirementUtility.GetInsertCardTypeValue(CardSetType.CardSetScheme, connector);
foreach (var scheme in request.Schemes)
{
// Validate the GamePackageId
var packageRequest = new GetGamePackagesRequest();
packageRequest.GamePackageIds.Add(scheme.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(scheme.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 scheme doesn't already exist
var schemeRequest = new GetSchemesRequest();
schemeRequest.Name = scheme.Name;
schemeRequest.Fields.AddRange(new[] { SchemeField.SchemeId, SchemeField.SchemeName, SchemeField.SchemeGamePackageId });
schemeRequest.NameMatchStyle = NameMatchStyle.MixedCase;
var schemeReply = await GetSchemesAsync(schemeRequest, context);
if (schemeReply.Status.Code == 200 && schemeReply.Schemes.Any())
{
var matchingScheme = schemeReply.Schemes.First();
reply.Status = new Status {
Code = 400, Message = $"Scheme {matchingScheme.Id} with name '{matchingScheme.Name}' was found in game package '{matchingScheme.GamePackageId}'"
};
return(reply);
}
// Create the scheme
var newSchemeId = ((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[SchemeField.SchemeName]}, {DatabaseDefinition.ColumnName[SchemeField.SchemeEpicInformation]})
values (@SchemeName, @HasEpicSide);
select last_insert_id();" ,
("SchemeName", scheme.Name),
("HasEpicSide", scheme.HasEpicSide))
.QuerySingleAsync <ulong>()));
// Add to game package
await connector.Command(
$@"
insert
into {TableNames.GamePackageSchemes}
({DatabaseDefinition.ColumnName[SchemeField.SchemeId]}, {GamePackageUtility.DatabaseDefinition.ColumnName[GamePackageField.Id]})
values (@SchemeId, @GamePackageId);" ,
("SchemeId", newSchemeId),
("GamePackageId", scheme.GamePackageId))
.ExecuteAsync();
// Link abilities
foreach (var abilityId in scheme.AbilityIds)
{
await connector.Command(
$@"
insert
into {TableNames.SchemeAbilities}
({DatabaseDefinition.ColumnName[SchemeField.SchemeId]}, {AbilityUtility.DatabaseDefinition.ColumnName[AbilityField.Id]})
values (@SchemeId, @AbilityId);" ,
("SchemeId", newSchemeId),
("AbilityId", abilityId))
.ExecuteAsync();
}
// Add card requirements
foreach (var requirement in scheme.CardRequirements)
{
var cardRequirementId = await CardRequirementUtility.AddCardRequirement(requirement);
await connector.Command(
$@"
insert
into {TableNames.MatchedCardRequirements}
({CardRequirementUtility.DatabaseDefinition.ColumnName[CardRequirement.OwnerIdFieldNumber]}, {CardRequirementUtility.DatabaseDefinition.ColumnName[CardRequirement.CardRequirementIdFieldNumber]}, NumberOfPlayers, {cardSetTypeInfo.Name})
values (@OwnerId, @CardRequirementId, @NumberOfPlayers, @{cardSetTypeInfo.Name});" ,
("OwnerId", newSchemeId),
("CardRequirementId", cardRequirementId),
("NumberOfPlayers", requirement.PlayerCount),
(cardSetTypeInfo.Name, cardSetTypeInfo.Value))
.ExecuteAsync();
}
// Add twist requirements
foreach (var twistRequirement in scheme.TwistRequirements)
{
var twistRequirementId = await SchemeTwistRequirementUtility.AddSchemeTwistRequirementAsync(twistRequirement);
await connector.Command(
$@"
insert
into {TableNames.SchemeTwistRequirements}
(SchemeId, TwistRequirementId, NumberOfPlayers)
values (@SchemeId, @TwistRequirementId, @NumberOfPlayers);" ,
("SchemeId", newSchemeId),
("TwistRequirementId", twistRequirementId),
("NumberOfPlayers", twistRequirement.PlayerCount))
.ExecuteAsync();
}
newSchemeIds.Add(newSchemeId);
}
// Get all of the created schemes
var finalRequest = new GetSchemesRequest();
finalRequest.SchemeIds.AddRange(newSchemeIds);
var finalReply = await GetSchemesAsync(finalRequest, context);
reply.Status = finalReply.Status;
reply.Schemes.AddRange(finalReply.Schemes);
return(reply);
}
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);
}
