public void Test_RemoveTypeMap()
{
SqlMapper.ResetTypeHandlers();
SqlMapper.RemoveTypeMap(typeof(DateTime));
var dateTimeHandler = new RecordingTypeHandler <DateTime>();
SqlMapper.AddTypeHandler(dateTimeHandler);
connection.Execute("CREATE TABLE #Test_RemoveTypeMap (x datetime NOT NULL);");
try
{
connection.Execute(@"INSERT INTO #Test_RemoveTypeMap VALUES (@Now)", new { DateTime.Now });
connection.Query <DateTime>("SELECT * FROM #Test_RemoveTypeMap");
dateTimeHandler.ParseWasCalled.IsTrue();
dateTimeHandler.SetValueWasCalled.IsTrue();
}
finally
{
connection.Execute("DROP TABLE #Test_RemoveTypeMap");
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime); // or an option to reset type map?
}
}
public void TestFixtureSetUp()
{
if (!SqlLocalDbApi.IsLocalDBInstalled())
{
throw new Exception("LocalDB is not installed!");
}
this.databaseName = "SqlServerUserManagerTests_" + Guid.NewGuid().ToString("N");
// Configure dapper to support datetime2
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
// Create test instance
this.instance = TemporarySqlLocalDbInstance.Create(deleteFiles: true);
// Seed test data
using (var connection = this.instance.CreateConnection())
{
connection.Open();
try
{
connection.Execute("CREATE DATABASE " + this.databaseName);
connection.Execute("USE " + this.databaseName);
connection.Execute("CREATE TABLE Users (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), UserId VARCHAR(255) NOT NULL, Password VARCHAR(MAX) NOT NULL, FirstName NVARCHAR(255) NOT NULL, LastName NVARCHAR(255) NOT NULL, LastLogin DATETIMEOFFSET)");
connection.Execute("INSERT INTO Users (UserId, Password, FirstName, LastName) VALUES ('azzlack', '10000:gW7zpVeugKl8IFu7TcpPskcgQjy4185eAwBk9fFlZK6JNd1I45tLyCYtJrzWzE+kVCUP7lMSY8o808EjUgfavBzYU/ZtWypcdCdCJ0BMfMcf8Mk+XIYQCQLiFpt9Rjrf5mAY86NuveUtd1yBdPjxX5neMXEtquNYhu9I6iyzcN4=:Lk2ZkpmTDkNtO/tsB/GskMppdAX2bXehP+ED4oLis0AAv3Q1VeI8KL0SxIIWdxjKH0NJKZ6qniRFkfZKZRS2hS4SB8oyB34u/jyUlmv+RZGZSt9nJ9FYJn1percd/yFA7sSQOpkGljJ6OTwdthe0Bw0A/8qlKHbO2y2M5BFgYHY=', 'Ove', 'Andersen')");
}
finally
{
connection.Close();
}
}
base.TestFixtureSetUp();
}
public async Task CreateAsync(ApplicationUser user)
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
using (var cn = new SqlConnection(_connectionString))
{
await cn.OpenAsync();
const string sql = @"
INSERT INTO [dbo].[Users] (
[UserId]
,[UserName]
,[Email]
,[EmailConfirmed]
,[PasswordHash]
,[LockoutEndDateUtc]
,[LockoutEnabled]
,[AccessFailedCount]
)
VALUES (
@Id
,@UserName
,@Email
,@EmailConfirmed
,@PasswordHash
,@LockoutEndDateUtc
,@LockoutEnabled
,@AccessFailedCount
)
";
await
cn.ExecuteAsync(sql, user);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("appsettings.json", false)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: false)
.Build();
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
}
public ApplicationUserRepository(string connectionString)
{
_connectionString = connectionString;
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
}
public override void TestFixtureSetUp()
{
if (!SqlLocalDbApi.IsLocalDBInstalled())
{
throw new Exception("LocalDB is not installed!");
}
this.databaseName = "SqlTokenRepositoryTests" + Guid.NewGuid().ToString("N");
// Configure dapper to support datetime2
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
// Create test instance
this.instance = TemporarySqlLocalDbInstance.Create(true);
// Seed test data
using (var connection = this.instance.CreateConnection())
{
connection.Open();
connection.Execute($"CREATE DATABASE [{this.databaseName}]");
connection.Execute($"USE [{this.databaseName}]");
connection.Execute("CREATE TABLE AccessTokens (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), ClientId VARCHAR(255) NOT NULL, Ticket VARCHAR(MAX) NOT NULL, Token VARCHAR(MAX) NOT NULL, Subject NVARCHAR(255) NOT NULL, RedirectUri VARCHAR(MAX), Scope NVARCHAR(MAX), ValidTo DATETIMEOFFSET, Created DATETIMEOFFSET)");
connection.Execute("CREATE TABLE RefreshTokens (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), ClientId VARCHAR(255) NOT NULL, Token VARCHAR(MAX) NOT NULL, Subject NVARCHAR(255) NOT NULL, RedirectUri VARCHAR(MAX), Scope NVARCHAR(MAX), ValidTo DATETIMEOFFSET, Created DATETIMEOFFSET)");
connection.Execute("CREATE TABLE AuthorizationCodes (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), ClientId VARCHAR(255) NOT NULL, Ticket VARCHAR(MAX) NOT NULL, Code VARCHAR(MAX) NOT NULL, Subject NVARCHAR(255) NOT NULL, Scope NVARCHAR(MAX), RedirectUri VARCHAR(MAX), ValidTo DATETIMEOFFSET, Created DATETIMEOFFSET)");
}
base.TestFixtureSetUp();
}
/// <summary></summary>
/// <param name="connectionString"></param>
/// <param name="migrationEnable"></param>
public static void Start(string connectionString, bool migrationEnable = true)
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
if (!migrationEnable)
{
return;
}
DatabaseHelper.CreateIfNotExists(connectionString);
MigrationRunnerHelper.MigrateToLatest(connectionString);
var storages = new StorageDbCommand(connectionString).GetAllAsync().Result;
foreach (var storage in storages)
{
try
{
BlobStorageConfig.Initialize(storage);
}
catch (Exception) {}
}
}
static DBConnectionExtensions()
{
SqlMapper.AddTypeHandler(new GuidHandler());
SqlMapper.AddTypeHandler(new DateTimeOffsetHandler());
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
}
/// <summary>
/// 構造函數
/// </summary>
/// <param name="connKeyName">數據庫連接字符串</param>
/// <param name="dbName">DB 類型</param>
public SqlDapperService(string connKeyName, Db_Type.DbName dbName)
{
_connectionString = connKeyName;
//var _connection = new ProfiledDbConnection(new SqlConnection(_connectionString), MiniProfiler.Current);
switch ((int)dbName)
{
case 0:
_connection = new ProfiledDbConnection(new OracleConnection(_connectionString), MiniProfiler.Current); // new OracleConnection(_connectionString);
break;
case 1:
_connection = new ProfiledDbConnection(new MySql.Data.MySqlClient.MySqlConnection(_connectionString), MiniProfiler.Current); //new MySql.Data.MySqlClient.MySqlConnection(_connectionString);
break;
case 2:
_connection = new ProfiledDbConnection(new SqlConnection(_connectionString), MiniProfiler.Current); //new SqlConnection(_connectionString);
break;
default:
break;
}
SqlMapper.RemoveTypeMap(typeof(Guid));
SqlMapper.RemoveTypeMap(typeof(Guid?));
SqlMapper.AddTypeHandler(typeof(Guid), new GuidTypeHandler());
SqlMapper.AddTypeMap(typeof(DateTime), System.Data.DbType.Date);
}
public static void DatabaseMapperSetup()
{
DbString.IsAnsiDefault = true; // default to varchar vs nvarchar for inserts
SqlMapper.AddTypeMap(typeof(string), DbType.AnsiString); // default to varchar vs nvarchar for query and parameterized variables
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2); // map new datatype datetime2 to datetime
SqlMapper.AddTypeHandler(new DateTimeHandler()); // add custom datetime handler to ensure UTC is being saved for any datetime
}
public Startup(IHostingEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
/* FIXME: I could not figure out how to instantiate a
* DatabaseOptions object in the clever way that
* Microsoft.Extensions.Options does it, so I gave up and passed
* the connection string. --Jonathan */
string connectionString =
(string)Configuration
.GetSection("Database")
.GetValue(typeof(string), "ConnectionString");
//force dapper to see a system datetime as an sql datetime 2
SqlMapper.AddTypeMap(typeof(System.DateTime), System.Data.DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(Guid), System.Data.DbType.Guid);
DatabaseTools.InitializeDatabase(connectionString);
//if (env.IsDevelopment()) {
// DatabaseTools.AddExampleData(connectionString);
//}
}
/// <inheritdoc cref="DefaultNancyBootstrapper.ConfigureRequestContainer" />
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime);
container.Register <IPersonRepository, PersonRepository>();
}
static void Main(string[] args)
{
SqlMapper.AddTypeMap(typeof(bool), DbType.Int32);
using (var program = new Program())
{
program.Run();
}
}
public static void RegisterMapping()
{
SqlMapper.AddTypeMap(typeof(Guid), DbType.Binary);
SqlMapper.AddTypeHandler(new GuidTypeHandler());
ScanType <AccountModel>();
ScanType <ManagedServerModel>();
ScanType <SubscriptionModel>();
}
#pragma warning disable xUnit1013 // Public method should be marked as test
/// <summary>
/// Resets Dapper type map and type handlers.
/// </summary>
public static void ResetDapperTypes()
{
// Because each database requires a slightly different type map, we have to reset it back to "normal" each time.
// As the only DbType we modify is DbType.Guid, we only need to re-add it to fix it.
SqlMapper.AddTypeMap(typeof(Guid), DbType.Guid);
SqlMapper.AddTypeMap(typeof(Guid?), DbType.Guid);
SqlMapper.ResetTypeHandlers();
}
public SqlDynamicStorage(string tableName, string connectionString, IConcurrencyControl concurrency, IKeyConverter <TKey> keyConverter)
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
_tableName = tableName;
_connectionString = connectionString;
_cc = concurrency;
_keyConverter = keyConverter;
_defaultSelection = new[] { new StorageSelection <TKey, TEntry, IDynamicStorage <TKey, TEntry> >(this) };
}
public override void Start()
{
if (_cf.AdoProvider == AdoProvider.Access)
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.Date);
}
_stopWatch.Start();
base.Start();
using (var cn = _cf.GetConnection()) {
cn.Open();
Context.Debug(() => "Loading BatchId.");
var sql = Context.SqlControlStartBatch(_cf);
try {
var cmd = cn.CreateCommand();
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
var batchId = cmd.CreateParameter();
batchId.ParameterName = "BatchId";
batchId.DbType = DbType.Int32;
batchId.Value = Context.Entity.BatchId;
var entity = cmd.CreateParameter();
entity.ParameterName = "Entity";
entity.DbType = DbType.String;
entity.Value = Context.Entity.Alias;
var mode = cmd.CreateParameter();
mode.ParameterName = "Mode";
mode.DbType = DbType.String;
mode.Value = Context.Process.Mode;
var start = cmd.CreateParameter();
start.ParameterName = "Start";
start.DbType = _cf.AdoProvider == AdoProvider.Access ? DbType.Date : DbType.DateTime;
start.Value = DateTime.Now;
cmd.Parameters.Add(batchId);
cmd.Parameters.Add(entity);
cmd.Parameters.Add(mode);
cmd.Parameters.Add(start);
cmd.ExecuteNonQuery();
} catch (Exception e) {
Context.Error(e.Message);
}
if (cn.State != ConnectionState.Closed)
{
cn.Close();
}
}
}
public RepositoryBase(IDatabase database)
{
ConnectionString = database.ConnectionString;
var type = typeof(TEntity);
_tableName = (type.GetCustomAttribute(typeof(TableAttribute), false) as TableAttribute)?.Name !;
if (string.IsNullOrWhiteSpace(_tableName))
{
throw new InvalidOperationException($"Table name not set on class '{type.Name}'");
}
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
}
public void TestInitialise()
{
CommonTestInitialise <IBaseStationDatabaseSqlServer>(() => {
ResetTestDatabase();
UpdateSchema();
},
() => new SqlConnection(DatabaseConnectionString),
(db) => {
db.ConnectionString = DatabaseConnectionString;
db.CommandTimeoutSeconds = 60;
// Make sure that Dapper is using DateTime2 when creating test records
SqlMapper.AddTypeMap(typeof(DateTime), System.Data.DbType.DateTime2);
},
"SELECT SCOPE_IDENTITY();");
}
public void Execute(string userId, string loginProvider, string name, string value, DateTime addedDate,
int type)
{
SqlMapper.AddTypeMap(typeof(DateTime), System.Data.DbType.DateTime2);
var parameters = new
{
userId,
loginProvider,
name,
value,
addedDate,
type
};
_unitOfWork.Connection.Execute(CreateSql, parameters, _unitOfWork.Transaction);
}
public static IServiceCollection AddMawDataServices(
this IServiceCollection services,
string connString)
{
DefaultTypeMap.MatchNamesWithUnderscores = true;
SqlMapper.AddTypeMap(typeof(string), System.Data.DbType.AnsiString);
services
.AddScoped <IBlogRepository>(x => new BlogRepository(connString))
.AddScoped <IUserRepository>(x => new UserRepository(connString))
.AddScoped <IPhotoRepository>(x => new PhotoRepository(connString))
.AddScoped <IVideoRepository>(x => new VideoRepository(connString))
.AddScoped <IUserStore <MawUser>, MawUserStore>()
.AddScoped <IRoleStore <MawRole>, MawRoleStore>();
return(services);
}
public void TestChangingDefaultStringTypeMappingToAnsiStringFirstOrDefault()
{
const string sql = "SELECT SQL_VARIANT_PROPERTY(CONVERT(sql_variant, @testParam),'BaseType') AS BaseType";
var param = new { testParam = "TestString" };
var result01 = connection.QueryFirstOrDefault <string>(sql, param);
Assert.Equal("nvarchar", result01);
SqlMapper.PurgeQueryCache();
SqlMapper.AddTypeMap(typeof(string), DbType.AnsiString); // Change Default String Handling to AnsiString
var result02 = connection.QueryFirstOrDefault <string>(sql, param);
Assert.Equal("varchar", result02);
SqlMapper.PurgeQueryCache();
SqlMapper.AddTypeMap(typeof(string), DbType.String); // Restore Default to Unicode String
}
public static void ConfigureShared(this IServiceCollection services, IConfiguration configuration)
{
SqlMapper.Settings.CommandTimeout = 120; //override execution timeout for all queries
SqlMapper.AddTypeMap(typeof(uint), System.Data.DbType.Int64);
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IUserBanRepository, UserBanRepository>();
services.AddScoped <ISubscriptionRepository, SubscriptionRepository>();
services.AddScoped <ISubscriptionStatisticRepository, SubscriptionStatisticRepository>();
services.AddScoped <IMessageRepository, MessageRepository>();
services.AddScoped <ITwitchApiService, TwitchApiService>();
services.AddElasticSearch(configuration);
services
.Configure <Services.Models.Telegram.BotSettings>(configuration.GetSection($"Telegram:{nameof(Services.Models.Telegram.BotSettings)}"))
.Configure <Services.Models.Twitch.BotSettings>(configuration.GetSection($"Twitch:{nameof(Services.Models.Twitch.BotSettings)}"))
.AddOptions();
}
public void TestFixtureSetUp()
{
if (!SqlLocalDbApi.IsLocalDBInstalled())
{
throw new Exception("LocalDB is not installed!");
}
this.databaseName = "SqlServerUserManagerTests_" + Guid.NewGuid().ToString("N");
// Configure dapper to support datetime2
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
// Create test instance
this.instance = TemporarySqlLocalDbInstance.Create(deleteFiles: true);
// Seed test data
using (var connection = this.instance.CreateConnection())
{
connection.Open();
try
{
connection.Execute("CREATE DATABASE " + this.databaseName);
connection.Execute("USE " + this.databaseName);
connection.Execute("CREATE TABLE Users (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), UserId VARCHAR(255) NOT NULL, Password VARCHAR(MAX) NOT NULL, Enabled BIT NULL, FirstName NVARCHAR(255) NOT NULL, LastName NVARCHAR(255) NOT NULL, LastLogin DATETIMEOFFSET, Created DATETIMEOFFSET)");
connection.Execute("INSERT INTO Users (UserId, Password, FirstName, LastName, Enabled) VALUES ('azzlack', '10000:gW7zpVeugKl8IFu7TcpPskcgQjy4185eAwBk9fFlZK6JNd1I45tLyCYtJrzWzE+kVCUP7lMSY8o808EjUgfavBzYU/ZtWypcdCdCJ0BMfMcf8Mk+XIYQCQLiFpt9Rjrf5mAY86NuveUtd1yBdPjxX5neMXEtquNYhu9I6iyzcN4=:Lk2ZkpmTDkNtO/tsB/GskMppdAX2bXehP+ED4oLis0AAv3Q1VeI8KL0SxIIWdxjKH0NJKZ6qniRFkfZKZRS2hS4SB8oyB34u/jyUlmv+RZGZSt9nJ9FYJn1percd/yFA7sSQOpkGljJ6OTwdthe0Bw0A/8qlKHbO2y2M5BFgYHY=', 'Ove', 'Andersen', 'true')");
connection.Execute("CREATE TABLE UserApiKeys (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), UserId VARCHAR(255) NOT NULL, ApiKey VARCHAR(MAX) NOT NULL, Name VARCHAR(255) NOT NULL, Description VARCHAR(MAX) NOT NULL, Created DATETIMEOFFSET, LastUsed DATETIMEOFFSET)");
connection.Execute("INSERT INTO UserApiKeys (UserId, ApiKey, Name, Description) VALUES ('azzlack', 'PFJTQUtleVZhbHVlPjxNb2R1bHVzPnlidFpyM0pWS0p1L2hlUFMrV0Zla1kyYmRYVDlJMU1MeHZheTlIMW9IenRwRmI4QzJtQmUzY1EzVDhjUzE0ajJ4bk9lRkt2YVZ4Ukw5S2ozd0tOL1B3PT08L01vZHVsdXM+PEV4cG9uZW50PkFRQUI8L0V4cG9uZW50PjwvUlNBS2V5VmFsdWU+', 'Test', 'This is a test')");
connection.Execute("CREATE TABLE Clients (Id bigint NOT NULL PRIMARY KEY IDENTITY(1,1), ClientId VARCHAR(255) NOT NULL, ClientSecret VARCHAR(MAX) NOT NULL, PublicKey VARCHAR(MAX) NULL, RedirectUri NVARCHAR(2083) NOT NULL, Name NVARCHAR(255) NOT NULL, Enabled bit, LastUsed DATETIMEOFFSET, Created DATETIMEOFFSET)");
connection.Execute("INSERT INTO Clients (ClientId, ClientSecret, PublicKey, RedirectUri, Name, Enabled) VALUES ('NUnit', '10000:gW7zpVeugKl8IFu7TcpPskcgQjy4185eAwBk9fFlZK6JNd1I45tLyCYtJrzWzE+kVCUP7lMSY8o808EjUgfavBzYU/ZtWypcdCdCJ0BMfMcf8Mk+XIYQCQLiFpt9Rjrf5mAY86NuveUtd1yBdPjxX5neMXEtquNYhu9I6iyzcN4=:Lk2ZkpmTDkNtO/tsB/GskMppdAX2bXehP+ED4oLis0AAv3Q1VeI8KL0SxIIWdxjKH0NJKZ6qniRFkfZKZRS2hS4SB8oyB34u/jyUlmv+RZGZSt9nJ9FYJn1percd/yFA7sSQOpkGljJ6OTwdthe0Bw0A/8qlKHbO2y2M5BFgYHY=', 'PFJTQUtleVZhbHVlPjxNb2R1bHVzPnFKMEtXaXZWSjUxUWtKWGdIU1hidkxOTEJsa09rOE9uSWtvRTljU1FrRzhOZm5VYXBrWHpkTlEvb3FLZE9BSWxYK1hFMnNwN0xFcS9KRnJMaDRNblhRPT08L01vZHVsdXM+PEV4cG9uZW50PkFRQUI8L0V4cG9uZW50PjwvUlNBS2V5VmFsdWU+', 'http://localhost', 'NUnit Test', 1)");
}
finally
{
connection.Close();
}
}
base.TestFixtureSetUp();
}
/// <summary>
/// Init type Sql provider
/// </summary>
private void InitConfig()
{
if (UseQuotationMarks == true)
{
switch (Provider)
{
case SqlProvider.MSSQL:
InitMetaData("[", "]");
break;
case SqlProvider.MySQL:
InitMetaData("`", "`");
break;
case SqlProvider.PostgreSQL:
InitMetaData("\"", "\"");
break;
default:
throw new ArgumentOutOfRangeException(nameof(Provider));
}
}
else
{
TableName = GetTableNameWithSchemaPrefix(TableName, TableSchema);
foreach (var propertyMetadata in SqlJoinProperties)
{
propertyMetadata.TableName = GetTableNameWithSchemaPrefix(propertyMetadata.TableName, propertyMetadata.TableSchema);
}
}
// set ParameterSymbol with : and mapping Boolean type to Int
if (Provider == SqlProvider.Oracle)
{
ParameterSymbol = ":";
SqlMapper.AddTypeMap(typeof(bool), DbType.Int32);
}
}
public void StateInit()
{
SetState(AppState.Init);
bool.TryParse(ConfigurationManager.AppSettings.Get("InitialSyncMandatory"), out var mandatory);
try
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
//обязательная синхронизация баз данных при старте приложения
try
{
DbSyncronizer.GetInstance().SyncDatabases();
}
catch (Exception)
{
if (mandatory)
{
throw;
}
}
//инициализация железа
InitBarcodeScanner();
InitCellsController();
//таймер для периодической синхронизации баз данных
InitDbSyncTimer();
StateMainMenu();
}
catch (Exception ex)
{
_logger.Error(ex, "init error");
StateInitError(ex is SyncException ? "ошибка синхр. бд" : ex.Message);
}
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
var builder = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("appsettings.json", false)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: false)
.Build();
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseSession();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "MyAreas",
pattern: "{area=Shop}/{controller=Home}/{action=Index}/{id?}");
});
}
public static void Initialize()
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
}
public async Task <TC> FetchAsync <T, TC>(string query, object paramValues, bool paginatedQuery = false,
CommandType?dbCommandType = null, int commandTimeout = 0)
where TC : IRestmeDbEntityCollection <T>, new() where T : IRestmeDbEntity
{
try
{
SqlMapper.AddTypeMap(typeof(long), DbType.Int32);
Logger?.LogInformation($"Fetching using DB query: \n {query} ");
Logger?.LogInformation($"DB query parameters: \n {paramValues?.JsonSerialize()}");
var stopwatch = new Stopwatch();
stopwatch.Start();
var resultSet = new TC();
// if (paginatedQuery)
// {
// var results =
// await (await GetOpenConnectionAsync()).QueryMultipleAsync(query, paramValues,
// _currentTransaction,
// commandType: dbCommandType);
// var totalCount = await results.ReadSingleOrDefaultAsync<int>();
// var result = results.Read<T>().AsList();
// if (totalCount <= 0) return resultSet;
//
// resultSet.TotalRecordsCount = Convert.ToInt32(totalCount);
// if (result.Any())
// resultSet.AddRange(result);
// }
// else
// {
var results =
await(await GetOpenConnectionAsync()).QueryAsync <T>(query, paramValues, _currentTransaction,
commandType: dbCommandType, commandTimeout: commandTimeout);
var enumerable = results?.ToList();
resultSet.TotalRecordsCount = enumerable.Count;
if (paginatedQuery && enumerable?.Count > 0)
{
var firstItem = enumerable.FirstOrDefault();
if (firstItem.BaseSearchCount > 0 && firstItem.BaseSearchCount >= resultSet.TotalRecordsCount)
{
resultSet.TotalRecordsCount = firstItem.BaseSearchCount;
}
}
if (enumerable.Any())
{
resultSet.AddRange(enumerable);
}
// }
if (stopwatch.ElapsedMilliseconds >= ExecutionPerformanceThresholdInMs)
{
Logger?.LogWarning($"DB query execution time: \n {stopwatch.ElapsedMilliseconds} ms \n {query}",
dbCommandType,
query, paramValues);
}
else
{
Logger?.LogInformation(
$"DB query execution time: \n {stopwatch.ElapsedMilliseconds} ms \n {query}");
}
return(resultSet);
}
catch (Exception ex)
{
Logger?.LogError(
$"Fetching from db failed\n Query: {query}\n Error: {ex.Message}",
ex, query, paramValues, dbCommandType);
throw ex;
}
}
static Repository()
{
SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
}