/// <inheritdoc/>
public IExternalDatabaseServer GetDefaultFor(PermissableDefaults field)
{
if (field == PermissableDefaults.None)
{
return(null);
}
using (var con = _repository.GetConnection())
{
var cmd = DatabaseCommandHelper.GetCommand("SELECT ExternalDatabaseServer_ID FROM ServerDefaults WHERE DefaultType = @type", con.Connection, con.Transaction);
var p = cmd.CreateParameter();
p.ParameterName = "@type";
p.Value = StringExpansionDictionary[field];
cmd.Parameters.Add(p);
var executeScalar = cmd.ExecuteScalar();
if (executeScalar == DBNull.Value)
{
return(null);
}
return(_repository.GetObjectByID <ExternalDatabaseServer>(Convert.ToInt32(executeScalar)));
}
}
/// <summary>
/// Translates the given <see cref="PermissableDefaults"/> (a default that can be set) to the <see cref="IPatcher"/> which
/// handles the creation/patching of database schema (identifies what type of database it is).
/// </summary>
/// <param name="permissableDefault"></param>
/// <returns></returns>
public static IPatcher ToTier2DatabaseType(this PermissableDefaults permissableDefault)
{
switch (permissableDefault)
{
case PermissableDefaults.LiveLoggingServer_ID:
return(new LoggingDatabasePatcher());
case PermissableDefaults.IdentifierDumpServer_ID:
return(new IdentifierDumpDatabasePatcher());
case PermissableDefaults.DQE:
return(new IdentifierDumpDatabasePatcher());
case PermissableDefaults.WebServiceQueryCachingServer_ID:
return(new QueryCachingPatcher());
case PermissableDefaults.CohortIdentificationQueryCachingServer_ID:
return(new QueryCachingPatcher());
case PermissableDefaults.RAWDataLoadServer:
return(null);
case PermissableDefaults.ANOStore:
return(new ANOStorePatcher());
default:
throw new ArgumentOutOfRangeException("permissableDefault");
}
}
private void InitializeServerDropdown(ComboBox comboBox, PermissableDefaults permissableDefault, ExternalDatabaseServer[] allServers)
{
comboBox.Items.Clear();
var currentDefault = defaults.GetDefaultFor(permissableDefault);
var patcher = permissableDefault.ToTier2DatabaseType();
var toAdd = allServers;
if (patcher != null) //we expect an explicit type e.g. a HIC.Logging.Database
{
var compatibles = Activator.RepositoryLocator.CatalogueRepository.GetAllObjects <ExternalDatabaseServer>().Where(s => s.WasCreatedBy(patcher)).ToArray();
if (currentDefault == null || compatibles.Contains(currentDefault)) //if there is not yet a default or the existing default is of the correct type
{
toAdd = compatibles; //then we can go ahead and use the restricted type
}
//otherwise what we have is a default of the wrong server type! eep.
}
comboBox.Items.AddRange(toAdd);
//select the server
if (currentDefault != null)
{
comboBox.SelectedItem = comboBox.Items.Cast <ExternalDatabaseServer>().Single(s => s.ID == currentDefault.ID);
}
}
private void CreateNewExternalServer(PermissableDefaults defaultToSet, IPatcher patcher)
{
if (CreatePlatformDatabase.CreateNewExternalServer(Activator.RepositoryLocator.CatalogueRepository, defaultToSet, patcher) != null)
{
RefreshUIFromDatabase();
}
}
internal void SetDefaultIfNotExists(ExternalDatabaseServer newServer, PermissableDefaults permissableDefault, bool askYesNo)
{
var defaults = Activator.RepositoryLocator.CatalogueRepository.GetServerDefaults();
var current = defaults.GetDefaultFor(permissableDefault);
if (current == null)
{
if (!askYesNo || YesNo($"Set as the default {permissableDefault} server?", "Set as default"))
{
defaults.SetDefault(permissableDefault, newServer);
}
}
}
/// <inheritdoc/>
public void ClearDefault(PermissableDefaults toDelete)
{
// Repository strictly complains if there is nothing to delete, so we'll check first (probably good for the repo to be so strict?)
if (CountDefaults(toDelete) == 0)
{
return;
}
_repository.Delete("DELETE FROM ServerDefaults WHERE DefaultType=@DefaultType",
new Dictionary <string, object>()
{
{ "DefaultType", StringExpansionDictionary[toDelete] }
});
}
private int CountDefaults(PermissableDefaults type)
{
if (type == PermissableDefaults.None)
{
return(0);
}
using (var con = _repository.GetConnection())
{
var cmd = DatabaseCommandHelper.GetCommand("SELECT COUNT(*) AS NumDefaults FROM ServerDefaults WHERE DefaultType=@DefaultType", con.Connection, con.Transaction);
DatabaseCommandHelper.AddParameterWithValueToCommand("@DefaultType", cmd, StringExpansionDictionary[type]);
var result = cmd.ExecuteScalar();
return(Convert.ToInt32(result));
}
}
private void InsertNewValue(PermissableDefaults toChange, IExternalDatabaseServer externalDatabaseServer)
{
if (toChange == PermissableDefaults.None)
{
throw new ArgumentException("toChange cannot be None", "toChange");
}
_repository.Insert(
"INSERT INTO ServerDefaults(DefaultType,ExternalDatabaseServer_ID) VALUES (@DefaultType,@ExternalDatabaseServer_ID)",
new Dictionary <string, object>()
{
{ "DefaultType", StringExpansionDictionary[toChange] },
{ "ExternalDatabaseServer_ID", externalDatabaseServer.ID }
});
}
public ExecuteCommandCreateNewExternalDatabaseServer(IActivateItems activator, IPatcher patcher, PermissableDefaults defaultToSet) : base(activator)
{
_patcher = patcher;
_defaultToSet = defaultToSet;
_overlayProvider = new IconOverlayProvider();
_databaseIconProvider = new ExternalDatabaseServerStateBasedIconProvider(_overlayProvider);
//do we already have a default server for this?
var existingDefault = Activator.ServerDefaults.GetDefaultFor(_defaultToSet);
if (existingDefault != null)
{
SetImpossible("There is already an existing " + _defaultToSet + " database");
}
}
/// <inheritdoc/>
public void SetDefault(PermissableDefaults toChange, IExternalDatabaseServer externalDatabaseServer)
{
if (toChange == PermissableDefaults.None)
{
throw new ArgumentException("toChange cannot be None", "toChange");
}
var oldValue = GetDefaultFor(toChange);
if (oldValue == null)
{
InsertNewValue(toChange, externalDatabaseServer);
}
else
{
UpdateExistingValue(toChange, externalDatabaseServer);
}
}
private void UpdateExistingValue(PermissableDefaults toChange, IExternalDatabaseServer externalDatabaseServer)
{
if (toChange == PermissableDefaults.None)
{
throw new ArgumentException("toChange cannot be None", "toChange");
}
string sql =
"UPDATE ServerDefaults set ExternalDatabaseServer_ID = @ExternalDatabaseServer_ID where DefaultType=@DefaultType";
int affectedRows = _repository.Update(sql, new Dictionary <string, object>()
{
{ "DefaultType", StringExpansionDictionary[toChange] },
{ "ExternalDatabaseServer_ID", externalDatabaseServer.ID }
});
if (affectedRows != 1)
{
throw new Exception("We were asked to update default for " + toChange + " but the query '" + sql + "' did not result in 1 affected rows (it resulted in " + affectedRows + ")");
}
}
public static ExternalDatabaseServer CreateNewExternalServer(ICatalogueRepository repository, PermissableDefaults defaultToSet, IPatcher patcher)
{
CreatePlatformDatabase createPlatform = new CreatePlatformDatabase(patcher);
createPlatform.ShowDialog();
var db = createPlatform.DatabaseCreatedIfAny;
if (db != null)
{
var newServer = new ExternalDatabaseServer(repository, db.GetRuntimeName(), patcher);
newServer.SetProperties(db);
if (defaultToSet != PermissableDefaults.None)
{
repository.GetServerDefaults().SetDefault(defaultToSet, newServer);
}
return(newServer);
}
return(null);
}
public virtual ExternalDatabaseServer CreateNewPlatformDatabase(ICatalogueRepository catalogueRepository, PermissableDefaults defaultToSet, IPatcher patcher, DiscoveredDatabase db)
{
if (db == null)
{
throw new ArgumentException($"Database must be picked before calling {nameof(CreateNewPlatformDatabase)} when using {nameof(BasicActivateItems)}", nameof(db));
}
MasterDatabaseScriptExecutor executor = new MasterDatabaseScriptExecutor(db);
executor.CreateAndPatchDatabase(patcher, new AcceptAllCheckNotifier());
var eds = new ExternalDatabaseServer(catalogueRepository, "New " + (defaultToSet == PermissableDefaults.None ? "" : defaultToSet.ToString()) + "Server", patcher);
eds.SetProperties(db);
return(eds);
}
public ExecuteCommandCreateNewExternalDatabaseServer(IBasicActivateItems activator, PermissableDefaults defaultToSet, DiscoveredDatabase toCreate)
: this(activator, defaultToSet == PermissableDefaults.None ? null : defaultToSet.ToTier2DatabaseType(), defaultToSet)
{
_database = toCreate;
}
private SqlConnectionStringBuilder CreateServerPointerInCatalogue(IServerDefaults defaults, string prefix, string databaseName, PermissableDefaults defaultToSet, IPatcher patcher)
{
var opts = new PlatformDatabaseCreationOptions()
{
ServerName = TestDatabaseSettings.ServerName,
Prefix = prefix,
Username = TestDatabaseSettings.Username,
Password = TestDatabaseSettings.Password,
ValidateCertificate = false
};
var builder = opts.GetBuilder(databaseName);
if (string.IsNullOrWhiteSpace(databaseName))
{
builder.InitialCatalog = "";
}
//create a new pointer
var externalServerPointer = new ExternalDatabaseServer(CatalogueRepository, databaseName ?? "RAW", patcher)
{
Server = builder.DataSource,
Database = builder.InitialCatalog,
Password = builder.Password,
Username = builder.UserID
};
externalServerPointer.SaveToDatabase();
//now make it the default DQE
defaults.SetDefault(defaultToSet, externalServerPointer);
return(builder);
}
public static ExternalDatabaseServer CreateNewExternalServer(ICatalogueRepository repository, PermissableDefaults defaultToSet, IPatcher patcher)
{
CreatePlatformDatabase createPlatform = new CreatePlatformDatabase(patcher);
createPlatform.ShowDialog();
if (!string.IsNullOrWhiteSpace(createPlatform.DatabaseConnectionString))
{
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(createPlatform.DatabaseConnectionString);
var newServer = new ExternalDatabaseServer(repository, builder.InitialCatalog, patcher);
newServer.Server = builder.DataSource;
newServer.Database = builder.InitialCatalog;
//if there is a username/password
if (!builder.IntegratedSecurity)
{
newServer.Password = builder.Password;
newServer.Username = builder.UserID;
}
newServer.SaveToDatabase();
if (defaultToSet != PermissableDefaults.None)
{
repository.GetServerDefaults().SetDefault(defaultToSet, newServer);
}
return(newServer);
}
return(null);
}
public override ExternalDatabaseServer CreateNewPlatformDatabase(ICatalogueRepository catalogueRepository, PermissableDefaults defaultToSet, IPatcher patcher, DiscoveredDatabase db)
{
//launch the winforms UI for creating a database
return(CreatePlatformDatabase.CreateNewExternalServer(catalogueRepository, defaultToSet, patcher));
}
