public DatabaseManager(IApplicationDomain applicationDomain, IConnectionStringBuilder connectionStringBuilder, DbProviderFactory databaseProviderFactory, IFileSystem fileSystem)
{
this.ApplicationDomain = applicationDomain ?? throw new ArgumentNullException(nameof(applicationDomain));
this.ConnectionStringBuilder = connectionStringBuilder ?? throw new ArgumentNullException(nameof(connectionStringBuilder));
this.DatabaseProviderFactory = databaseProviderFactory ?? throw new ArgumentNullException(nameof(databaseProviderFactory));
this.FileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
}
public static void Parce(IConnectionStringBuilder conn, ICPath path)
{
List <AD> listAD = new List <AD>();
IDataParser paserProduct = new ParcerProduct(listAD);
paserProduct.SetConnection(conn);
paserProduct.Select(path);
HashSet <AD> distinctAD = new HashSet <AD>(listAD, new SameADComparer());
ADMapper mapper = new ADMapper(Directory.GetCurrentDirectory() + "\\storage.xml");
HashSet <AD> storedListAD = new HashSet <AD>(new SameADComparer());
foreach (AD o in mapper.ReadAll())
{
storedListAD.Add(o);
}
distinctAD = new HashSet <AD>(distinctAD.Except(storedListAD, new SameADComparer()), new SameADComparer());
if (storedListAD.SequenceEqual(storedListAD.Union(distinctAD, new SameADComparer()), new SameADComparer()) == false)
{
// ShowBalloon("Новые товары", GetShortInfoAD(distinctAD, 3));
foreach (AD ad in distinctAD)
{
Console.WriteLine(ad);
}
listAD = storedListAD.Union(distinctAD).ToList();
mapper.WriteAll(listAD);
}
}
public IDbExecutor CreateExecutor(IConnectionStringBuilder connectionStringBuilder)
{
var dbConnection = new SqlConnection(connectionStringBuilder.Build());
dbConnection.Open();
return(new SqlExecutor(dbConnection));
}
public UnitOfWork(IConnectionStringBuilder connectionStringBuilder, IBusinessRuleRegistry businessRuleRegistry)
{
this.RegisterRepositories();
this.connectionStringBuilder = connectionStringBuilder;
this.atanetDbContext = this.CreateContext();
this.businessRuleRegistry = businessRuleRegistry;
this.changeTracker = this.atanetDbContext.ChangeTracker;
}
public ConnectionStringManager(IConfiguration configuration,
IConnectionStringBuilder connectionStringBuilder,
IOptionsSnapshot <AppDbOptions> optionsSnapshot)
{
this.configuration = configuration;
this.connectionStringBuilder = connectionStringBuilder;
dbConnectionOptions = optionsSnapshot.Value;
}
public static string GetActualDatabase(this IConnectionStringBuilder connectionStringBuilder, IApplicationDomain applicationDomain)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
return(connectionStringBuilder.Database ?? connectionStringBuilder.GetActualDatabaseFilePath(applicationDomain));
}
public SSDTExecutor(IConnectionStringBuilder connectionStringBuilder)
{
dacService = new DacServices(connectionStringBuilder.GetConnectioString());
options = new DacDeployOptions()
{
CreateNewDatabase = true, RegisterDataTierApplication = true
};
dacService.Message += statusupdate;
}
///<inheritdoc/>
public string CreateConnectionString(DatabaseFacade database, ConnectionInformation connectionInformation)
{
Check.NotNull(database, nameof(database));
Check.NotNull(connectionInformation, nameof(connectionInformation));
IConnectionStringBuilder builder = GetBuilder(database.ProviderName);
return(builder.CreateConnectionString(connectionInformation));
}
///<inheritdoc/>
public ConnectionInformation GetConnectionInformation(DatabaseFacade database)
{
Check.NotNull(database, nameof(database));
IConnectionStringBuilder builder = GetBuilder(database.ProviderName);
string connectionString = database.GetDbConnection().ConnectionString;
return(builder.ParseConnectionString(connectionString));
}
/// <summary>
/// Standard Constructor
/// </summary>
public ConnectionStringBuilder(IConnectionStringBuilder builder)
{
if (null == builder)
{
builder = Dependencies.GetService <IConnectionStringBuilder>();
}
Builder = builder ?? throw new ArgumentNullException(nameof(builder));
}
public FluentMigratorHandler(FluentMigratorConfiguration configuration,
IConnectionStringBuilder connectionStringBuilder,
DatabaseCreator databaseCreator,
ICommandExecutor commandExecutor)
: base(configuration)
{
_configuration = configuration;
_connectionStringBuilder = connectionStringBuilder;
_databaseCreator = databaseCreator;
_commandExecutor = commandExecutor;
}
public IEvolutionContext CreateContext <TContext>(IConnectionStringBuilder connectionStringBuilder)
where TContext : IEvolutionContext
{
if (typeof(TContext) == typeof(OracleEvolutionContext))
{
return(new OracleEvolutionContext(connectionStringBuilder.CreateConnectionString()));
}
else
{
throw new NotSupportedException("The DB context provided is not supported : " + typeof(TContext).AssemblyQualifiedName);
}
}
protected internal virtual void DetachDatabase(IConnectionStringBuilder connectionStringBuilder)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
var databaseName = connectionStringBuilder.GetActualDatabase(this.ApplicationDomain);
var commandText = "EXEC sp_detach_db '" + databaseName + " ', 'true';";
var serverConnectionStringBuilder = this.CreateConnectionStringBuilderWithoutDatabaseAndDatabaseFilePath(connectionStringBuilder.ConnectionString);
this.ExecuteCommand(commandText, serverConnectionStringBuilder);
}
protected internal virtual bool TryConnection(IConnectionStringBuilder connectionStringBuilder, out Exception exception)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
exception = null;
using (var connection = this.DatabaseProviderFactory.CreateConnection())
{
var databaseFilePath = connectionStringBuilder.DatabaseFilePath;
var actualDatabaseFilePath = connectionStringBuilder.GetActualDatabaseFilePath(this.ApplicationDomain);
connectionStringBuilder = connectionStringBuilder.Copy();
connectionStringBuilder.DatabaseFilePath = actualDatabaseFilePath;
// ReSharper disable PossibleNullReferenceException
connection.ConnectionString = connectionStringBuilder.ConnectionString;
// ReSharper restore PossibleNullReferenceException
try
{
connection.Open();
return(true);
}
catch (Exception catchedException)
{
exception = catchedException;
if (catchedException is SqlException sqlException && sqlException.Number == 15350) // An attempt to attach an auto-named database for file *.* failed. A database with the same name exists, or specified file cannot be opened, or it is located on UNC share.
{
try
{
if (!string.IsNullOrWhiteSpace(actualDatabaseFilePath) && !this.FileSystem.File.Exists(actualDatabaseFilePath) && this.DatabaseExists(connectionStringBuilder))
{
exception = new FileNotFoundException($"The database-file \"{databaseFilePath}\", \"{actualDatabaseFilePath}\", does not exist.", actualDatabaseFilePath, catchedException);
}
}
// ReSharper disable EmptyGeneralCatchClause
catch { }
// ReSharper restore EmptyGeneralCatchClause
}
return(false);
}
}
}
protected internal virtual void DropDatabase(IConnectionStringBuilder connectionStringBuilder)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
var databaseFilePath = connectionStringBuilder.GetActualDatabaseFilePath(this.ApplicationDomain);
var databaseName = connectionStringBuilder.GetActualDatabase(this.ApplicationDomain);
var serverConnectionStringBuilder = this.CreateConnectionStringBuilderWithoutDatabaseAndDatabaseFilePath(connectionStringBuilder.ConnectionString);
if (string.IsNullOrEmpty(databaseFilePath) || this.FileSystem.File.Exists(databaseFilePath))
{
var alterDatabaseCommandText = "ALTER DATABASE [" + databaseName + "] SET SINGLE_USER WITH ROLLBACK IMMEDIATE;"; // To close existing connections.
this.ExecuteCommand(alterDatabaseCommandText, serverConnectionStringBuilder);
}
else if (this.DatabaseExists(connectionStringBuilder))
{
var databaseLogFilePath = this.GetDatabaseLogFilePath(databaseFilePath);
if (this.FileSystem.File.Exists(databaseLogFilePath))
{
this.FileSystem.File.Delete(databaseLogFilePath);
}
}
var dropDatabaseCommandText = "DROP DATABASE [" + databaseName + "];";
try
{
this.ExecuteCommand(dropDatabaseCommandText, serverConnectionStringBuilder);
}
catch (SqlException sqlException)
{
// If the mdf-file does not exist we get this exception. The database is dropped anyhow.
var isFileDoesNotExistException = sqlException.Class == 16 && sqlException.ErrorCode == -2146232060 && sqlException.Number == 5120;
if (!isFileDoesNotExistException)
{
throw;
}
}
}
protected internal virtual void CreateDatabase(IConnectionStringBuilder connectionStringBuilder, bool force)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
if (force)
{
this.DropDatabase(connectionStringBuilder);
}
var databaseFilePath = connectionStringBuilder.GetActualDatabaseFilePath(this.ApplicationDomain);
var databaseName = connectionStringBuilder.GetActualDatabase(this.ApplicationDomain);
var serverConnectionStringBuilder = this.CreateConnectionStringBuilderWithoutDatabaseAndDatabaseFilePath(connectionStringBuilder.ConnectionString);
var commandText = "CREATE DATABASE [" + databaseName + "]";
if (string.IsNullOrEmpty(databaseFilePath))
{
commandText += ";";
}
else
{
if (this.FileSystem.File.Exists(databaseFilePath))
{
commandText += " ON(FILENAME=[" + databaseFilePath + "])";
commandText += " FOR ATTACH_REBUILD_LOG;";
}
else
{
var databaseLogFilePath = this.GetDatabaseLogFilePath(databaseFilePath);
databaseName = this.FileSystem.Path.GetFileNameWithoutExtension(databaseFilePath);
commandText += " ON PRIMARY(NAME=[" + databaseName + "-Data], FILENAME=[" + databaseFilePath + "])";
commandText += " LOG ON(NAME=[" + databaseName + "-Log], FILENAME=[" + databaseLogFilePath + "]);";
}
}
this.ExecuteCommand(commandText, serverConnectionStringBuilder);
}
private void cboDataProvider_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
csb = null;
var provider = (DatabaseProvider)cboDatabaseProvider.SelectedItem;
switch (provider)
{
case DatabaseProvider.Odbc:
case DatabaseProvider.OleDb:
case DatabaseProvider.OracleClient:
case DatabaseProvider.OracleDataProvider:
case DatabaseProvider.SqlClient:
sqLiteConnectionStringBuilder1.Visible = false;
rdbmsConnectionStringBuilder1.Visible = true;
csb = rdbmsConnectionStringBuilder1;
csb.DatabaseProvider = provider;
break;
case DatabaseProvider.SQLite:
sqLiteConnectionStringBuilder1.Visible = true;
rdbmsConnectionStringBuilder1.Visible = false;
csb = sqLiteConnectionStringBuilder1;
csb.DatabaseProvider = provider;
break;
case DatabaseProvider.Unspecified:
throw new ArgumentException("Provider cannot be Unspecified!");
default:
throw new ArgumentOutOfRangeException("provider=" + provider);
}
}
catch (Exception ex)
{
FormUtil.WinException(ex);
}
}
protected internal virtual void ExecuteCommand(string commandText, IConnectionStringBuilder connectionStringBuilder)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
using (var connection = this.DatabaseProviderFactory.CreateConnection())
{
// ReSharper disable PossibleNullReferenceException
connection.ConnectionString = connectionStringBuilder.ConnectionString;
// ReSharper restore PossibleNullReferenceException
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = commandText;
command.CommandType = CommandType.Text;
command.ExecuteNonQuery();
}
}
}
public static string GetActualDatabaseFilePath(this IConnectionStringBuilder connectionStringBuilder, IApplicationDomain applicationDomain)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
if (applicationDomain == null)
{
throw new ArgumentNullException(nameof(applicationDomain));
}
var databaseFilePath = connectionStringBuilder.DatabaseFilePath;
// ReSharper disable InvertIf
if (!string.IsNullOrWhiteSpace(databaseFilePath))
{
const string dataDirectory = "DataDirectory";
var pattern = Regex.Escape("|") + dataDirectory + Regex.Escape("|");
if (Regex.IsMatch(databaseFilePath, pattern, RegexOptions.IgnoreCase))
{
var dataDirectoryPath = applicationDomain.GetDataDirectoryPath();
const string backslash = @"\";
if (!dataDirectoryPath.Trim().EndsWith(backslash, StringComparison.OrdinalIgnoreCase))
{
dataDirectoryPath += backslash;
}
databaseFilePath = Regex.Replace(databaseFilePath, pattern, dataDirectoryPath, RegexOptions.IgnoreCase);
}
}
// ReSharper restore InvertIf
return(databaseFilePath);
}
protected internal virtual bool DatabaseExists(IConnectionStringBuilder connectionStringBuilder)
{
if (connectionStringBuilder == null)
{
throw new ArgumentNullException(nameof(connectionStringBuilder));
}
var databaseName = connectionStringBuilder.GetActualDatabase(this.ApplicationDomain);
var serverConnectionStringBuilder = this.CreateConnectionStringBuilderWithoutDatabaseAndDatabaseFilePath(connectionStringBuilder.ConnectionString);
using (var connection = this.DatabaseProviderFactory.CreateConnection())
{
// ReSharper disable PossibleNullReferenceException
connection.ConnectionString = serverConnectionStringBuilder.ConnectionString;
// ReSharper restore PossibleNullReferenceException
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT DB_ID('" + databaseName + "');";
command.CommandType = CommandType.Text;
var reader = command.ExecuteReader();
while (reader.Read())
{
var value = reader[0];
return(!(value is DBNull));
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Could not select the database \"{0}\" to check if it exist.", databaseName));
}
}
}
public void ChangeBuilder(IConnectionStringBuilder _builder)
{
builder = _builder;
}
public ConnectionStringBuilderDirector(IConnectionStringBuilder _builder)
{
builder = _builder;
}
public DatabaseDropper(IConnectionStringBuilder connBuilder)
{
_connBuilder = connBuilder;
}
public DataFileHelper(IConnectionStringBuilder connectionStringBuilder)
{
_connectionStringBuilder = connectionStringBuilder;
_filePath = new Lazy <string>(GetFilePath);
}
public DatabasePermissionChecker(IConnectionStringBuilder connBuilder)
{
_connBuilder = connBuilder;
}
public ParcerProduct(IConnectionStringBuilder conn, ICPath initPath)
{
SetConnection(conn);
_initPath = initPath; ;
}
public WorkerConfiguration(IConnectionTester connectionTester, IConnectionStringBuilder connectionBuilder)
{
_connectionTester = connectionTester;
_connectionBuilder = connectionBuilder;
}
public UnitOfWorkFactory(IConnectionStringBuilder connectionStringBuilder, IBusinessRuleRegistry businessRuleRegistry)
{
this.connectionStringBuilder = connectionStringBuilder;
this.businessRuleRegistry = businessRuleRegistry;
}
public LojaContext(DbContextOptions <LojaContext> options, IConnectionStringBuilder connectionStringBuilder)
: base(options)
{
_connectionStringBuilder = connectionStringBuilder;
}
public ContextConnectionStringSetter(IConnectionStringBuilder connectionStringBuilder)
{
_connectionStringBuilder = connectionStringBuilder;
}
public FoodNetworkDataBaseConnectionFactory(IConnectionStringBuilder connectionStringBuilder)
{
_connectionBuilder = connectionStringBuilder;
}
public SqlConnectionFactory(IConnectionContextFactory connectionContextFactory, IConnectionStringBuilder connectionStringBuilder)
{
_connectionContextFactory = connectionContextFactory ?? throw new ArgumentNullException(nameof(connectionContextFactory));
_connectionStringBuilder = connectionStringBuilder ?? throw new ArgumentNullException(nameof(connectionStringBuilder));
}
public DatabaseCreator(IConnectionStringBuilder connBuilder)
{
_connBuilder = connBuilder;
}
public void SetConnection(IConnectionStringBuilder connectionStringBuilder)
{
this.connectionStringBuilder = connectionStringBuilder;
}
public WorkerConfiguration(IConnectionTester connectionTester, IConnectionStringBuilder connectionBuilder)
{
_connectionTester = connectionTester;
_connectionBuilder = connectionBuilder;
}
public DatabaseUpgrader(IConnectionStringBuilder connBuilder, IDatabasePermissionChecker dbChecker)
{
_connBuilder = connBuilder;
DbChecker = dbChecker;
}
