/// <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)); }