public async Task Async()
{
var createCount = 0;
await using var pool = new DbConnectorPool(new DbConnectorPoolSettings { Create = CreateConnection });
await using (var connector1 = pool.Get())
await using (var connector2 = pool.Get())
{
(await connector1.Command("select null;").QuerySingleAsync <object>()).Should().Be(null);
(await connector2.Command("select null;").QuerySingleAsync <object>()).Should().Be(null);
}
await using (var connector3 = pool.Get())
(await connector3.Command("select null;").QuerySingleAsync <object>()).Should().Be(null);
createCount.Should().Be(2);
DbConnector CreateConnection()
{
createCount++;
return(DbConnector.Create(
new SqliteConnection("Data Source=:memory:"),
new DbConnectorSettings {
AutoOpen = true
}));
}
}
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) } :
public async Task OpenConnectionAsync()
{
await using var connector = DbConnector.Create(
new SQLiteConnection("Data Source=:memory:"),
new DbConnectorSettings { ProviderMethods = new SqliteProviderMethods() });
await using (await connector.OpenConnectionAsync())
(await connector.Command("create table Items1 (ItemId integer primary key, Name text not null);").ExecuteAsync()).Should().Be(0);
}
public IActionResult Index(User user)
{
if (ModelState.IsValid)
{
_dbConnector.Create(user.FirstName, user.LastName, user.EmailAddress, user.Password);
return(View("success"));
}
return(View(user));
}
public IActionResult Index(User user)
{
Console.WriteLine(user.FirstName);
if (ModelState.IsValid)
{
_dbConnector.Create(user.FirstName, user.LastName, user.EmailAddress, user.Password);
return(RedirectToAction("RegSuccess"));
}
ViewBag.IsValid = false;
return(View("_Registration", user));
}
protected BulkInsertBenchmark(IDbConnection connection, string columnsSql, int recordCount, Func <int, object>?createParameter = null)
{
m_connector = DbConnector.Create(connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
m_connector.Command("drop table if exists BulkInsertBenchmark; ").Execute();
m_connector.CommandFormat($"create table BulkInsertBenchmark ({Sql.Raw(columnsSql)});").Execute();
m_recordCount = recordCount;
m_createParameter = createParameter;
m_sql = "insert into BulkInsertBenchmark (Value) values (@Value)...;";
}
protected PreparedCachedBenchmark(IDbConnection connection, string columnsSql, int recordCount, Func <int, object>?createParameter = null)
{
m_connector = DbConnector.Create(connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
m_connector.Command("drop table if exists PreparedCachedBenchmark; ").Execute();
m_connector.CommandFormat($"create table PreparedCachedBenchmark ({Sql.Raw(columnsSql)});").Execute();
m_recordCount = recordCount;
m_createParameter = createParameter;
m_paramCount = 100;
m_sql = $"insert into PreparedCachedBenchmark (Value) values ({string.Join(" + ", Enumerable.Range(0, m_paramCount).Select(x => $"@Value{x}"))});";
}
public void TimeoutTest()
{
var connectionString = new SqliteConnectionStringBuilder {
DataSource = nameof(TimeoutTest), Mode = SqliteOpenMode.Memory, Cache = SqliteCacheMode.Shared
}.ConnectionString;
using var connector1 = DbConnector.Create(new SqliteConnection(connectionString), new DbConnectorSettings { AutoOpen = true });
using var connector2 = DbConnector.Create(new SqliteConnection(connectionString), new DbConnectorSettings { AutoOpen = true });
connector1.Command("create table Items (ItemId integer primary key, Name text not null);").Execute();
connector2.Command("insert into Items (Name) values ('xyzzy');").Execute();
using var transaction1 = connector1.BeginTransaction();
Invoking(() => connector2.Command("insert into Items (Name) values ('querty');").WithTimeout(TimeSpan.FromSeconds(1)).Execute()).Should().Throw <SqliteException>();
}
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);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
List <Dictionary <string, object> > allUsers = DbConnector.Read();
string output = JsonConvert.SerializeObject(allUsers);
// Console.WriteLine(output);
DbConnector.Create();
// List<Dictionary<string, object>> myQuery = DbConnector.Query("SELECT first_name, favorite_number FROM users");
// foreach (Dictionary<string,object> dict in myQuery) {
// foreach (KeyValuePair<string,object> entry in dict) {
// Console.WriteLine(entry.Key + " " + entry.Value);
// }
// }
}
public IActionResult SearchMovie(string movie)
// public void SearchMovie(string movie)
{
var MovieObject = new Movie();
WebRequest.GetMovieDataAsync(movie, ApiResponse =>
{
MovieObject = ApiResponse;
}
).Wait();
List <Dictionary <string, object> > AllMovies = _dbConnector.Create(MovieObject.Title, MovieObject.VoteAverage, MovieObject.ReleaseDate);
// List<Dictionary<string,object>> ThisMovie = _dbConnector.Query($"SELECT title, vote_average, release_date FROM movies WHERE title = '{MovieObject.Title}'");
return(RedirectToAction("Index"));
}
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 void DeferredTransaction()
{
var connectionString = new SqliteConnectionStringBuilder {
DataSource = nameof(DeferredTransaction), Mode = SqliteOpenMode.Memory, Cache = SqliteCacheMode.Shared
}.ConnectionString;
using var connector1 = DbConnector.Create(new SqliteConnection(connectionString), new DbConnectorSettings { AutoOpen = true });
using var connector2 = DbConnector.Create(new SqliteConnection(connectionString), new DbConnectorSettings { AutoOpen = true });
((SqliteConnection)connector1.Connection).DefaultTimeout = 5;
((SqliteConnection)connector2.Connection).DefaultTimeout = 5;
connector1.Command("create table Items (ItemId integer primary key, Name text not null);").Execute();
connector1.Command("insert into Items (Name) values ('xyzzy');").Execute();
using var transaction1 = connector1.AttachTransaction(((SqliteConnection)connector1.Connection).BeginTransaction(deferred: true));
using var transaction2 = connector2.AttachTransaction(((SqliteConnection)connector2.Connection).BeginTransaction(deferred: true));
connector1.Command("select count(*) from Items;").QuerySingle <long>().Should().Be(1);
connector2.Command("select count(*) from Items;").QuerySingle <long>().Should().Be(1);
connector1.CommitTransaction();
}
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)));
}
private static DbConnector CreateConnector() => DbConnector.Create(
new SqlConnection("data source=localhost;user id=sa;password=P@ssw0rd;initial catalog=test"),
new DbConnectorSettings {
AutoOpen = true, LazyOpen = true, SqlSyntax = SqlSyntax.SqlServer
});
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 void OpenConnection()
{
using var connector = DbConnector.Create(new SqliteConnection("Data Source=:memory:"));
using (connector.OpenConnection())
connector.Command("create table Items1 (ItemId integer primary key, Name text not null);").Execute().Should().Be(0);
}
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);
}
private DbConnector CreateConnector() => DbConnector.Create(
new SQLiteConnection("Data Source=:memory:"),
new DbConnectorSettings {
ProviderMethods = new SqliteProviderMethods(), AutoOpen = true, LazyOpen = true
});
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);
}
private static DbConnector CreateConnector() => DbConnector.Create(
new NpgsqlConnection("host=localhost;user id=root;password=test;database=test"),
new DbConnectorSettings {
AutoOpen = true, LazyOpen = true, SqlSyntax = SqlSyntax.Postgres
});
private static DbConnector CreateConnector() => DbConnector.Create(
new MySqlConnection("Server=localhost;User Id=root;Password=test;SSL Mode=none;Database=test;Ignore Prepare=false;AllowPublicKeyRetrieval=true"),
new DbConnectorSettings {
AutoOpen = true, LazyOpen = true, SqlSyntax = SqlSyntax.MySql
});
private static DbConnector CreateConnector() => DbConnector.Create(
new SqliteConnection("Data Source=:memory:"),
new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
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);
}
