/// <summary>
/// Constructor.
/// </summary>
protected DbCreateStoredProcedureTemplate(IDbSetup setup, Type tableTemplate, StoredProcedureFunction function) : base(setup)
{
TableTemplate = tableTemplate;
Binding = setup.GetTableBinding(tableTemplate);
SqlTableName = Binding.GetSqlTableName();
SqlSpName = Binding.GetSqlTableSpName(function);
}
/// <summary>
/// Constructor.
/// </summary>
public DropStoredProcedure(IDbSetup setup, Type tableTemplate, StoredProcedureFunction function, bool onlyIfExists = false) : base(setup)
{
var binding = setup.GetTableBinding(tableTemplate);
Name = setup.Naming.GetStoredProcedureName(binding.TableName, function);
OnlyIfExists = onlyIfExists;
}
/// <summary>
/// Checks for migratable data
/// </summary>
/// <param name="cancellationToken">Cancellation Token</param>
/// <returns>Task for the async task</returns>
public async Task StartAsync(CancellationToken cancellationToken)
{
using (IServiceScope serviceScope = _serviceScopeFactory.CreateScope())
{
IUserDbAccess userDbAccess = (IUserDbAccess)serviceScope.ServiceProvider.GetService(typeof(IUserDbAccess));
IDbSetup dbSetup = (IDbSetup)serviceScope.ServiceProvider.GetService(typeof(IDbSetup));
ILogger logger = (ILogger)serviceScope.ServiceProvider.GetService(typeof(ILogger <AutoDataMigrator>));
try
{
await RemoveUnusedRolesForUsers(userDbAccess);
}
catch (Exception ex)
{
logger.LogError(ex, "Could not remove old user roles");
}
try
{
await dbSetup.CheckForNeededMigrations();
}
catch (Exception ex)
{
logger.LogError(ex, "Could not migrate database");
}
}
}
internal DbCommandBinding(Type templateType, IDbSetup setup)
: base(templateType, setup)
{
Mode = DbExecutionMode.NonQuery;
var qattr = TypeHelper.TryGetAttribute <DbQueryAttribute>(templateType, true);
var sattr = TypeHelper.TryGetAttribute <DbStoredProcedureAttribute>(templateType, true);
if ((qattr != null ? 1 : 0) + (sattr != null ? 1 : 0) > 1)
{
throw new ArgumentException($"Multiple template definition in class [{templateType.FullName}]");
}
if (qattr != null)
{
Text = qattr.QueryText;
CommandType = CommandType.Text;
}
if (sattr != null)
{
Text = setup.Naming.GetStoredProcedureName(templateType, sattr.StoredProcedureName);
CommandType = CommandType.StoredProcedure;
}
AddProperties();
}
/// <summary>
/// Configures the database
/// </summary>
/// <returns>Task</returns>
private static async Task ConfigureDb()
{
do
{
string connectionString = MessageService.GetMongoDbConnectionString();
AppSettingUpdater.AddOrUpdateAppSetting((config) => config.MongoDb.ConnectionString = connectionString);
string databaseName = MessageService.GetMongoDbDatabasename();
AppSettingUpdater.AddOrUpdateAppSetting((config) => config.MongoDb.DbName = databaseName);
MessageService.PrintVerifyingDatabase();
try
{
ServiceProvider serviceProvider = ServiceProviderBuilder.BuildServiceProvider();
IDbSetup dbSetup = serviceProvider.GetService <IDbSetup>();
await dbSetup.SetupDatabaseAsync();
MessageService.PrintSuccessVerifyingDatabase();
break;
}
catch (Exception ex)
{
MessageService.PrintErrorVerifyingDatabase(ex);
}
}while(true);
}
protected DbPropertyBinding(IDbSetup setup, PropertyInfo propInfo, TA attr, bool getterRequired, bool setterRequired)
: base(propInfo, attr, getterRequired, setterRequired)
{
this.Setup = setup;
PrimaryTableTemplate = DbHelper.GetForeignKeyPropType(PropertyInfo.PropertyType);
IsForeignKeyProp = PrimaryTableTemplate != null;
GetKeyConstraints(attr);
}
public DbParameterBinding(IDbSetup setup, PropertyInfo propInfo, DbParameterAttribute attr)
: base(setup, propInfo, attr, attr.IsInput, attr.IsOutput)
{
SpParamName = setup.Naming.GetParameterName(propInfo, null, Attributes.ParameterName, attr.DoNotTranslate, KeyConstraint);
if (string.IsNullOrEmpty(SpParamName))
{
throw new ArgumentException($"Null parameter name in DbParameterBinding at class [{propInfo.DeclaringType.Namespace}.{propInfo.DeclaringType.Name}]");
}
}
public DbFieldBinding(IDbSetup setup, PropertyInfo propInfo, DbFieldAttribute attr)
: base(setup, propInfo, attr, false, true)
{
FieldName = setup.Naming.GetFieldName(propInfo, Attributes.DbName, KeyConstraint);
if (string.IsNullOrEmpty(FieldName))
{
throw new ArgumentException($"Null field name in DbFieldBinding at class [{propInfo.DeclaringType.Namespace}.{propInfo.DeclaringType.Name}]");
}
}
/// <summary>
/// Get the primary key type.
/// </summary>
public static Type GetPrimaryKeyType(IDbSetup setup, Type tableType, bool?isNullableForced, out Type columnType)
{
var col = GetPrimaryKeyColumn(setup, tableType);
columnType = col.ColumnType;
if (col.IsNullable || isNullableForced == true)
{
columnType = typeof(Nullable <>).MakeGenericType(columnType);
}
return(typeof(DbForeignKey <,>).MakeGenericType(tableType, columnType));
}
/// <summary>
/// Get the primary key column type.
/// </summary>
public static IDbColumnBinding GetPrimaryKeyColumn(IDbSetup setup, Type tableType)
{
var binding = setup.GetTableBinding(tableType);
var col = binding?.SingleColumnPrimaryKey;
if (col == null)
{
throw new ArgumentException($"Unknown type/foreign key for [{tableType.Name}]");
}
return(col);
}
/// <summary>
/// Constructor.
/// </summary>
public CreateTable(IDbSetup setup, Type tableTemplate) : base(setup)
{
var tableAttr = TypeHelper.TryGetAttribute <MySqlTableAttribute>(tableTemplate, true);
Engine = (tableAttr?.Engine ?? Custom.MySql.Engine.InnoDb).ToString();
DefaultCharset = (tableAttr?.DefaultCharset ?? DefaultKey);
var bindings = setup.GetTableBinding(tableTemplate);
TableName = bindings.TableName;
ColumnDefinition = GetColumnDefinition(bindings.Columns);
TableConstraints = GetTableConstraints(bindings);
}
public SetupManager(
IApplicationEnvironment appEnv,
ILogger <SetupManager> logger,
IOptions <SetupOptions> setupOptionsAccessor,
IDbSetup dbImplementation,
IVersionProviderFactory versionProviderFactory,
SiteManager siteManager)
{
appBasePath = appEnv.ApplicationBasePath;
this.siteManager = siteManager;
log = logger;
db = dbImplementation;
this.versionProviderFactory = versionProviderFactory;
setupOptions = setupOptionsAccessor.Value;
}
public SetupManager(
IApplicationEnvironment appEnv,
IHttpContextAccessor contextAccessor,
ILogger <SetupManager> logger,
IOptions <SetupOptions> setupOptionsAccessor,
IDbSetup dbImplementation,
IVersionProviderFactory versionProviderFactory
)
{
appBasePath = appEnv.ApplicationBasePath;
log = logger;
db = dbImplementation;
this.versionProviderFactory = versionProviderFactory;
setupOptions = setupOptionsAccessor.Value;
_context = contextAccessor?.HttpContext;
}
public SetupManager(
IApplicationEnvironment appEnv,
IHttpContextAccessor contextAccessor,
ILogger<SetupManager> logger,
IOptions<SetupOptions> setupOptionsAccessor,
IDbSetup dbImplementation,
IVersionProviderFactory versionProviderFactory
)
{
appBasePath = appEnv.ApplicationBasePath;
log = logger;
db = dbImplementation;
this.versionProviderFactory = versionProviderFactory;
setupOptions = setupOptionsAccessor.Value;
_context = contextAccessor?.HttpContext;
}
public UserService(
string encryptionKey,
string salt,
IDbSetup dbSetup,
IUserRepository userRepository,
IUserIdRepository userIdRepository,
IUserNameRepository userNameRepository,
IEmailService emailService,
IAuthenticationService authenticationService) : base(encryptionKey, salt)
{
_dbSetup = dbSetup;
_userRepository = userRepository;
_userIdRepository = userIdRepository;
_userNameRepository = userNameRepository;
_emailService = emailService;
_authenticationService = authenticationService;
}
internal DbTableBinding(Type templateType, IDbSetup setup)
: base(templateType, setup)
{
var tattr = TypeHelper.TryGetAttribute <DbTableAttribute>(templateType, true);
if (tattr != null)
{
TableName = setup.Naming.GetTableName(templateType, tattr.TableName);
}
PrimaryKey = TypeHelper.TryGetAttribute <IDbTablePrimaryKeyAttribute>(templateType, true);
foreignKeys = TypeHelper.GetAttributes <IDbTableForeignKeyAttribute>(templateType, true).ToList();
uniqueKeys = TypeHelper.GetAttributes <IDbTableUniqueKeyAttribute>(templateType, true).ToList();
indexes = TypeHelper.GetAttributes <IDbTableIndexAttribute>(templateType, true).ToList();
AddColumns();
}
/// <summary>
/// Constructor.
/// </summary>
protected CreateStoredProcedureInsert(IDbSetup setup, Type tableTemplate, StoredProcedureFunction function)
: base(setup, tableTemplate, function)
{
}
public MySqlArchitecture(IDbSetup setup, string connectionString, bool useReadAfterWrite = true)
: base(setup, connectionString)
{
this.useReadAfterWrite = useReadAfterWrite;
}
/// <summary>
/// Translates a foreign key column type.
/// </summary>
public static Type TranslateForeignKeyType(IDbSetup setup, ref Type columnType, bool?isNullableForced)
{
var primaryTable = GetForeignKeyPropType(columnType);
return(primaryTable != null?GetPrimaryKeyType(setup, primaryTable, isNullableForced, out columnType) : null);
}
/// <summary>
/// Constructor.
/// </summary>
protected DbCommands(IDbSetup setup)
{
Setup = setup;
}
protected DbDataAccess(IDbSetup setup, string connectionString) : base(setup, connectionString)
{
}
/// <summary>
/// Constructor
/// </summary>
public AdministrationController(IDbSetup dbSetup)
{
_DbSetup = dbSetup;
}
protected DbTemplateBinding(Type templateType, IDbSetup setup)
{
TemplateType = templateType;
Setup = setup;
}
/// <summary>
/// Constructor.
/// </summary>
public CreateStoredProcedureUpdateGet(IDbSetup setup, Type tableTemplate)
: base(setup, tableTemplate, StoredProcedureFunction.Update)
{
}
public DbTemplate(IDbSetup setup)
{
Setup = setup;
}
/// <summary>
/// Constructor.
/// </summary>
public CreateStoredProcedureInsert(IDbSetup setup, Type tableTemplate)
: base(setup, tableTemplate, StoredProcedureFunction.Insert)
{
}
public DbRecordsetBinding(IDbSetup setup, PropertyInfo propInfo, DbRecordsetAttribute attr)
: base(setup, propInfo, attr, false, true)
{
}
/// <summary>
/// Constructor.
/// </summary>
public CreateStoredProcedureListAll(IDbSetup setup, Type tableTemplate)
: base(setup, tableTemplate, StoredProcedureFunction.ListAll)
{
}
/// <summary>
/// Constructor.
/// </summary>
public CreateStoredProcedureFind(IDbSetup setup, Type tableTemplate)
: base(setup, tableTemplate, StoredProcedureFunction.Find)
{
}
/// <summary>
/// Creates an instance of a column binding.
/// </summary>
public static IDbColumnBinding CreateInstance(IDbSetup setup, PropertyInfo propInfo, DbColumnAttribute attr, IDbTableBinding table)
{
return(TypeHelper.CreateInstance(typeof(DbColumnBinding <,>), new[] { propInfo.DeclaringType, propInfo.PropertyType }, setup, propInfo, attr, table) as IDbColumnBinding);
}
/// <summary>
/// Constructor.
/// </summary>
public CreateStoredProcedureDelete(IDbSetup setup, Type tableTemplate)
: base(setup, tableTemplate, StoredProcedureFunction.Delete)
{
}
