Example #1
0
        public MetadataSettings SettingsCopy() // This method is used to save settings to file
        {
            MetadataSettings copy = new MetadataSettings()
            {
                Catalog = this.Catalog
            };

            foreach (DatabaseServer server in Servers)
            {
                DatabaseServer serverCopy = new DatabaseServer()
                {
                    Name     = server.Name,
                    Address  = server.Address,
                    UserName = server.UserName,
                    Password = server.Password
                };
                foreach (DatabaseInfo database in server.Databases)
                {
                    serverCopy.Databases.Add(new DatabaseInfo()
                    {
                        Name     = database.Name,
                        UserName = database.UserName,
                        Password = database.Password
                    });
                }
                copy.Servers.Add(serverCopy);
            }
            return(copy);
        }
Example #2
0
        public void AttachDatabase(string serverAddress, DatabaseInfo database)
        {
            if (database == null)
            {
                throw new ArgumentNullException(nameof(database));
            }
            if (string.IsNullOrWhiteSpace(serverAddress))
            {
                throw new ArgumentNullException(nameof(serverAddress));
            }

            if (Settings == null)
            {
                Settings = new MetadataSettings();
            }

            DatabaseServer server = Settings.Servers.Where(s => s.Address == serverAddress || s.Name == serverAddress).FirstOrDefault();

            if (server == null)
            {
                server = new DatabaseServer()
                {
                    Name = serverAddress, Address = serverAddress
                };
                Settings.Servers.Add(server);
            }
            CurrentServer = server;

            DatabaseInfo test = server.Databases.Where(db => db.Name == database.Name).FirstOrDefault();

            if (test == null)
            {
                server.Databases.Add(database);
            }
            CurrentDatabase = database;

            SqlConnectionStringBuilder csb = new SqlConnectionStringBuilder(ConnectionString)
            {
                DataSource          = string.IsNullOrWhiteSpace(server.Address) ? server.Name : server.Address,
                InitialCatalog      = database.Name,
                IntegratedSecurity  = true,
                PersistSecurityInfo = false
            };

            ConnectionString = csb.ToString();
        }
Example #3
0
        public void Configure(MetadataSettings settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException(nameof(settings));
            }
            if (string.IsNullOrWhiteSpace(settings.Catalog))
            {
                throw new ArgumentNullException(nameof(settings.Catalog));
            }
            if (!Directory.Exists(settings.Catalog))
            {
                throw new DirectoryNotFoundException(settings.Catalog);
            }

            Settings = settings;

            if (settings.Servers.Count == 0)
            {
                return;
            }

            int            s = 0;
            int            i = 0;
            DatabaseInfo   database;
            DatabaseServer server;
            string         serverCatalogPath;
            string         metadataFilePath;

            while (s < settings.Servers.Count)
            {
                server            = settings.Servers[s];
                serverCatalogPath = ServerCatalogPath(server.Name);

                if (server == null || string.IsNullOrWhiteSpace(server.Name) || !Directory.Exists(serverCatalogPath))
                {
                    settings.Servers.RemoveAt(s);
                    continue;
                }
                s++;

                if (server.Databases.Count == 0)
                {
                    continue;
                }

                i = 0;
                while (i < server.Databases.Count)
                {
                    database         = server.Databases[i];
                    metadataFilePath = MetadataFilePath(server.Name, database.Name);

                    if (database == null || string.IsNullOrWhiteSpace(database.Name) || !File.Exists(metadataFilePath))
                    {
                        server.Databases.RemoveAt(i);
                        continue;
                    }
                    i++;

                    InitializeMetadata(database, metadataFilePath);
                }
            }
        }