public AkkaPersistenceDataConnectionFactory(IProviderConfig <SnapshotTableConfiguration> config)
{
providerName = config.ProviderName;
connString = config.ConnectionString;
//Build Mapping Schema to be used for all connections.
//Make a unique mapping schema name here to avoid problems
//with multiple configurations using different schemas.
var configName = "akka.persistence.l2db." + HashCode.Combine(config.ConnectionString, config.ProviderName, config.TableConfig.GetHashCode());
var ms = new MappingSchema(configName, MappingSchema.Default);
//ms.SetConvertExpression<DateTime, DateTime>(dt => DateTime.SpecifyKind(dt, DateTimeKind.Utc));
var fmb = ms
.GetFluentMappingBuilder();
MapSnapshotRow(config, fmb);
useCloneDataConnection = config.UseCloneConnection;
mappingSchema = fmb.MappingSchema;
opts = new LinqToDbConnectionOptionsBuilder()
.UseConnectionString(providerName, connString)
.UseMappingSchema(mappingSchema).Build();
if (providerName.ToLower().StartsWith("sqlserver"))
{
policy = new SqlServerRetryPolicy();
}
_cloneConnection = new Lazy <DataConnection>(() => new DataConnection(opts));
}
public void Setup()
{
_configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddUserSecrets(typeof(TableInheritanceTests).Assembly)
.Build();
_connectionOptions = new LinqToDbConnectionOptionsBuilder()
.UsePostgreSQL(_configuration.GetConnectionString("Default"))
.Build();
var fm = MappingSchema.Default.GetFluentMappingBuilder();
fm.Entity <DbClassifier>().HasTableName("classifier")
.Inheritance(x => x.Type, null, typeof(DbClassifier), true)
.Inheritance(x => x.Type, "company", typeof(DbCompany))
.Inheritance(x => x.Type, "user", typeof(DbUser))
.Property(x => x.Uid).HasColumnName("uid").HasDataType(DataType.Guid).IsPrimaryKey()
.Property(x => x.Type).HasColumnName("type").HasDataType(DataType.VarChar).IsDiscriminator()
.Property(x => x.Name).HasColumnName("name").HasDataType(DataType.VarChar);
fm.Entity <DbCompany>().HasTableName("company")
.Property(x => x.FullName).HasColumnName("full_name").HasDataType(DataType.VarChar)
.Property(x => x.Vatin).HasColumnName("vatin").HasDataType(DataType.VarChar);
fm.Entity <DbUser>().HasTableName("user")
.Property(x => x.FirstName).HasColumnName("first_name").HasDataType(DataType.VarChar)
.Property(x => x.LastName).HasColumnName("last_name").HasDataType(DataType.VarChar);
}
public LinqToDbGenericRepository(
LinqToDbConnectionOptions connectionOptions,
ILogger <LinqToDbGenericRepository <TEntity, TId> > logger)
{
_connectionOptions = connectionOptions;
_logger = logger;
}
protected SqlServerDataConnection(LinqToDbConnectionOptions <CaminoDataConnection> options) : base(options)
{
var mappingSchema = new MappingSchema();
FluentMapBuilder = mappingSchema.GetFluentMappingBuilder();
AddMappingSchema(mappingSchema);
OnMappingSchemaCreating();
}
protected static LinqToDbConnectionOptions <NotesConnection> ChangeType <T>(LinqToDbConnectionOptions <T> TDataContext)
where T : DataConnection
{
var builder = new LinqToDbConnectionOptionsBuilder();
builder.UseSqlServer(TDataContext.ConnectionString);
#if DEBUG
builder.WriteTraceWith((a, b, c) =>
{
Console.WriteLine(a);
Console.WriteLine(b);
});
#endif
return(builder.Build <NotesConnection>());
}
public TopManagementEarnedEntryWriteDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public Contexto(LinqToDbConnectionOptions <Contexto> options)
: base(options)
{
}
public WeatherConnection(LinqToDbConnectionOptions <WeatherConnection> options)
: base(options)
{
}
public UsersRepository(LinqToDbConnectionOptions <UnitOfWork> options)
: base(options)
{
}
public LinqToDbRepository(LinqToDbConnectionOptions connectionOptions, ILogger <LinqToDbGenericRepository <TEntity, string> > logger) : base(connectionOptions, logger)
{
}
public WritterConnection(LinqToDbConnectionOptions <WritterConnection> options) : base(ChangeType(options))
{
}
// public ShwaDB()
// {
// InitDataContext();
// InitMappingSchema();
// }
public ShwaDB(LinqToDbConnectionOptions <ShwaDB> options)
: base(options)
{
// InitDataContext();
// InitMappingSchema();
}
public AppDataConnection(LinqToDbConnectionOptions <AppDataConnection> options)
: base(options)
{
}
public OPDataConnection(LinqToDbConnectionOptions <OPDataConnection> options)
: base(options)
{
}
public TransactionsDataConnection(LinqToDbConnectionOptions <TransactionsDataConnection> options) : base(options)
{
}
public DatabaseConnection(LinqToDbConnectionOptions <DatabaseConnection> options)
: base(options)
{
}
public NotesConnection(LinqToDbConnectionOptions <NotesConnection> options) : base(options)
{
}
public AnimalConnection(LinqToDbConnectionOptions <AnimalConnection> options)
: base(options)
{
}
public SQLiteDatabaseConnection(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public UserNotificationSettingsGetDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public LinqDB(LinqToDbConnectionOptions options)
: base(options)
{
InitDataContext();
InitMappingSchema();
}
public AssigneeDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public UnitOfWork(LinqToDbConnectionOptions <UnitOfWork> options)
: base(options)
{
_options = options;
}
public CaminoDataConnection(LinqToDbConnectionOptions <CaminoDataConnection> options) : base(options)
{
}
public ReaderConnection(LinqToDbConnectionOptions <ReaderConnection> options) : base(ChangeType(options))
{
}
public GenericRepository(LinqToDbConnectionOptions <AppDataConnection> options)
: base(options)
{
}
public EstimatedGoalsDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public TransactionsDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public GoalCostDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
public AccountsGetDbOperations(LinqToDbConnectionOptions <SQLiteDatabaseConnection> options) : base(options)
{
}
