예제 #1
0
        public string GetConnectionString(SqlDbConfig config, string user, string password)
        {
            if (String.IsNullOrEmpty(user) || String.IsNullOrEmpty(password))
            {
                if (!(String.IsNullOrEmpty(user) && String.IsNullOrEmpty(password)))
                {
                    throw new Exception("BUG: user and password must both be empty when one is.");
                }

                if (String.IsNullOrEmpty(config.Database.Connection.DefaultUser) || String.IsNullOrEmpty(config.Database.Connection.DefaultPassword))
                {
                    throw new Exception("Please add DefaultUser and DefaultPassword");
                }

                return(GetConnectionString(config, config.Database.Connection.DefaultUser, config.Database.Connection.DefaultPassword));
            }
            else
            {
                var    db   = config.Database;
                string tmp1 = string.Copy(db.Connection.ConnectionString);
                DbConnectionStringBuilder connBuilder = new DbConnectionStringBuilder();
                connBuilder.ConnectionString = tmp1;
                if (connBuilder.ContainsKey(db.Connection.KeyForPassword))
                {
                    connBuilder.Remove(db.Connection.KeyForPassword);
                    connBuilder.Add(db.Connection.KeyForPassword, password);
                }
                if (connBuilder.ContainsKey(db.Connection.KeyForUser))
                {
                    connBuilder.Remove(db.Connection.KeyForUser);
                    connBuilder.Add(db.Connection.KeyForUser, user);
                }
                return(connBuilder.ConnectionString);
            }
        }
예제 #2
0
        private static DbConnectionStringBuilder GetBuilder(string serverNameOrConnectionString)
        {
            // Special handling of a connection string on the form: "powerbi://api.powerbi.com/v1.0/myorg/workspace;initial catalog=dbname"
            if (serverNameOrConnectionString.StartsWith("powerbi://", StringComparison.OrdinalIgnoreCase) && serverNameOrConnectionString.Contains(";"))
            {
                serverNameOrConnectionString = "Provider=MSOLAP;Data Source=" + serverNameOrConnectionString;
            }
            DbConnectionStringBuilder csb = new DbConnectionStringBuilder();

            if (serverNameOrConnectionString.Contains("="))
            {
                try
                {
                    csb.ConnectionString = serverNameOrConnectionString;
                }
                catch (ArgumentException)
                {
                }
            }

            if (!csb.ContainsKey(ProviderKey))
            {
                csb.Add(ProviderKey, "MSOLAP");
            }
            if (!csb.ContainsAny(DataSourceKey, "DataSource"))
            {
                csb.Add(DataSourceKey, serverNameOrConnectionString);
            }

            return(csb);
        }
예제 #3
0
        /// <summary>
        /// Ham nay de mo ket noi den database
        /// </summary>
        /// <param name="ServerName"></param>
        /// <param name="DatabaseName"></param>
        /// <param name="UserId"></param>
        /// <param name="Password"></param>
        /// <returns></returns>
        public static bool DB_OpenConnection(string ServerName, string DatabaseName, string UserId, string Password)
        {
            DbProviderFactory = System.Data.SqlClient.SqlClientFactory.Instance;
            DbConnectionStringBuilder DbConnectionStringBuilder = DbProviderFactory.CreateConnectionStringBuilder();

            DbConnectionStringBuilder.Add("Data Source", ServerName);
            DbConnectionStringBuilder.Add("User ID", UserId);
            DbConnectionStringBuilder.Add("Password", Password);
            DbConnectionStringBuilder.Add("Initial Catalog", DatabaseName);

            bool IsConnected;

            try
            {
                if (DbConnection == null)
                {
                    DbConnection = DbProviderFactory.CreateConnection();
                }
                if (DbConnection.State != ConnectionState.Open)
                {
                    DbConnection.ConnectionString = DbConnectionStringBuilder.ConnectionString;
                    DbConnection.Open();
                }
                IsConnected = true;
            }
            catch
            {
                IsConnected = false;
            }
            return(IsConnected);
        }
예제 #4
0
        /// <summary>
        /// Returns the best alias for <paramref name="keyword"/> or null if there are no known aliases.  This is because some builders allow multiple keys for changing the same underlying
        /// property.
        /// </summary>
        /// <param name="keyword"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        private string GetCollisionWithKeyword(string keyword, string value)
        {
            //lets evaluate this alleged keyword!
            _builder.Clear();

            try
            {
                //Make sure it is supported by the connection string builder
                _builder.Add(keyword, value);
            }catch (Exception ex)
            {
                //don't output the value since that could be a password
                throw new ArgumentException(string.Format(FAnsiStrings.ConnectionStringKeyword_ValueNotSupported, keyword), ex);
            }

            //now iterate all the keys we had before and add those too, if the key count doesn't change for any of them we know it's a duplicate semantically
            if (_builder.Keys != null)
            {
                foreach (var current in _keywords)
                {
                    int keysBefore = _builder.Keys.Count;

                    _builder.Add(current.Key, current.Value.Item1);

                    //key count in builder didn't change dispite there being new values added
                    if (_builder.Keys.Count == keysBefore)
                    {
                        return(current.Key);
                    }
                }
            }

            //no collisions
            return(null);
        }
예제 #5
0
        public DbConnection CreateConnexion()
        {
            //fonctoin générique qui ouvre la connection selon n'importa quel type de bdd (ici MySql)

            switch (bddType)
            {
            case connexionType.MaBaseOleDb:
                con = new OleDbConnection("maChaineDeConnexion");
                break;

            case connexionType.MaBaseSqlServer:
                con = new SqlConnection("maChaineDeConnexion");
                break;

            case connexionType.MaBaseMySql:
                //construction de la chaine de connection
                DbConnectionStringBuilder connBuilder = new DbConnectionStringBuilder();
                connBuilder.Add("Database", "Projets_Etudes");
                connBuilder.Add("Data Source", "192.168.2.250");
                connBuilder.Add("User Id", "root_etudes");
                connBuilder.Add("Password", "dB24zK6c");
                con = new MySqlConnection(connBuilder.ConnectionString);
                break;
            }
            return(con);
        }
예제 #6
0
        private void initialize(string path, bool hasHeaders, bool hasMixedData)
        {
            string fullPath = Path.GetFullPath(path);
            string extension = Path.GetExtension(path);

            if (!File.Exists(fullPath))
                throw new FileNotFoundException("File could not be found.", fullPath);

            string tempFileName = Path.GetTempFileName();
            File.Copy(fullPath, tempFileName, true);

            // Reader Settings
            HasHeaders = hasHeaders;
            HasMixedData = hasMixedData;

            switch (extension)
            {
                case ".xls": Version = "Excel 8.0"; break; // Excel 95-2003
                case ".xlsx": Version = "Excel 12.0"; break; // Excel 2007+
                default: throw new ArgumentException("File type could not be determined by file extension.", "path");
            }

            if (IntPtr.Size == 4 && extension == ".xls")
                Provider = "Microsoft.Jet.OLEDB.4.0";   // for x86/95-2003
            else Provider = "Microsoft.ACE.OLEDB.12.0"; // for x64/95-2007+

            var strBuilder = new DbConnectionStringBuilder();

            strBuilder.Add("Provider", Provider);
            strBuilder.Add("Data Source", tempFileName);
            strBuilder.Add("Extended Properties", Version + ";" +
                "HDR=" + (HasHeaders ? "Yes" : "No") + ';' +
                "Imex=" + (HasMixedData ? "2" : "0") + ';');
            strConnection = strBuilder.ToString();
        }
예제 #7
0
파일: Program.cs 프로젝트: zj8487/HyDM
        static void Main()
        {
            DbConnectionStringBuilder dcsBuilder = new DbConnectionStringBuilder();

            dcsBuilder.Add("User ID", "wjzgis");
            dcsBuilder.Add("Password", "wjzgis");
            dcsBuilder.Add("Service Name", "sunz");
            dcsBuilder.Add("Host", "172.16.1.9");
            dcsBuilder.Add("Integrated Security", false);
            string licPath = Application.StartupPath + "\\DDTek.lic";
            //dcsBuilder.Add("License Path", licPath);
            //若路径中存在空格,则会在路径名称前加上"\""
            string conStr = dcsBuilder.ConnectionString;

            conStr = conStr.Replace("\"", "");

            Configuration config = new Configuration();

            config.AddDirectory(new System.IO.DirectoryInfo(System.IO.Path.Combine(Application.StartupPath, "DataMapping")));

            config.Properties["connection.connection_string"] = conStr;


            NHibernate.ISessionFactory sFactory = config.BuildSessionFactory();
            NHibernate.ISession        session  = sFactory.OpenSession();


            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
예제 #8
0
        private void CreateConnectionFromParameters()
        {
            DbConnectionStringBuilder builder = _factory.CreateConnectionStringBuilder();

            try
            {
                // most builders should translate these generic keywords
                // to provider-specific native keywords.

                if (!String.IsNullOrEmpty(this.UserName))
                {
                    builder.Add("User", this.UserName);
                }
                if (!String.IsNullOrEmpty(this.Password))
                {
                    builder.Add("Password", this.Password);
                }
                if (!String.IsNullOrEmpty(this.Server))
                {
                    builder.Add("Server", this.Server);
                }
                if (!String.IsNullOrEmpty(this.Database))
                {
                    builder.Add("Database", this.Database);
                }
            }
            catch (ArgumentException ex)
            {
                // invalid keyword(s)
                throw new ArgumentException(GetValidKeywords(builder), ex);
            }

            _connection = _factory.CreateConnection();
            _connection.ConnectionString = builder.ConnectionString;
        }
예제 #9
0
        public DbConnectionStringBuilder GetConnectionStringBuilder()
        {
            DbConnectionStringBuilder connectionStringBuilder = OleDbFactory.Instance.CreateConnectionStringBuilder();

            connectionStringBuilder.Add("Data Source", DataSource);
            connectionStringBuilder.Add("Provider", Provider);
            return(connectionStringBuilder);
        }
예제 #10
0
        public Task SaveCredentialsAsync(string teamId, CredentialsModel value)
        {
            var secret = new DbConnectionStringBuilder();

            secret.Add("username", value.Username);
            secret.Add("password", value.Password);
            secret.Add("baseAddress", value.BaseAddress);
            return(SaveSecretAsync(teamId, Providers.Jda, secret.ConnectionString));
        }
예제 #11
0
        public Task SaveTokenAsync(string teamId, TokenModel value)
        {
            var secret = new DbConnectionStringBuilder();

            secret.Add("accessToken", value.AccessToken);
            secret.Add("refreshToken", value.RefreshToken);
            secret.Add("expiresDate", value.ExpiresDate);
            return(SaveSecretAsync(teamId, Providers.Graph, secret.ConnectionString));
        }
예제 #12
0
        static void extractTablesAsClasses(CodeGenArgs args2)
        {
            string                    connStr = null, appName = Assembly.GetEntryAssembly().GetName().Name, providerClass;
            DbProviderFactory         factory = args2.providerFactory;
            DbConnectionStringBuilder sb      = null;
            bool isSqlclient = false;

            providerClass = factory.GetType().FullName;

            if (string.Compare(providerClass, "System.Data.SqlClient.SqlClientFactory", true) == 0)
            {
                sb = args2.providerFactory.CreateConnectionStringBuilder();
                sb.Add("Application Name", appName);
                sb.Add("Data Source", args2.server);
                sb.Add("Initial Catalog", args2.database);
                if (!string.IsNullOrEmpty(args2.userName) && !string.IsNullOrEmpty(args2.password))
                {
                    //sb.use
                    System.Data.SqlClient.SqlConnectionStringBuilder sb2;
                    sb2          = sb as System.Data.SqlClient.SqlConnectionStringBuilder;
                    sb2.UserID   = args2.userName;
                    sb2.Password = args2.password;
                }
                else
                {
                    sb.Add("Integrated Security", true);
                }
                isSqlclient = false;
            }
            else
            {
                Debug.Print("user/pass here?");
            }
            if (sb != null)
            {
                connStr = sb.ConnectionString;
                Trace.WriteLine("ConnectionString is " + connStr);
                try {
                    using (DbConnection conn = factory.CreateConnection()) {
                        conn.ConnectionString = connStr;
                        if (isSqlclient)
                        {
                            ((System.Data.SqlClient.SqlConnection)conn).InfoMessage += infoMessageHandler;
                        }
                        ;
                        conn.Open();
                        generateCodeFromTables(conn, args2);
                        conn.Close();
                    }
                } catch (Exception ex) {
                    Trace.WriteLine(ex.Message);
                    //throw new ApplicationException("another", ex);
                    throw;
                } finally {
                }
            }
        }
예제 #13
0
        /// <summary>
        /// Мутод - открытия базы данных
        /// </summary>
        public void OpenSimplePlayerBD()
        {
            DbConnectionStringBuilder builder = new DbConnectionStringBuilder();

            builder.Add(@"Data Source", System.Windows.Forms.Application.StartupPath + "\\SimplePlayer.db");
            builder.Add(@"Version", 3);
            BD = new SQLiteConnection(builder.ConnectionString);
            //Console.Write(builder.ConnectionString);
            BD.Open();
        }
예제 #14
0
        //[ConnectionStringORA]Oracle接続用ConnectionString(ODP/ADO共通)
        private static string ConnectionStringORA(DbProviderFactory factory)
        {
            DbConnectionStringBuilder csb = factory.CreateConnectionStringBuilder();

            csb.Add("Data Source", "xxx.xxx.xxx.xxx:9999/SID");
            csb.Add("User ID", "USERID");
            csb.Add("Password", "PASSWORD");

            return(csb.ConnectionString);
        }
        /// <summary>
        /// "UserName=;Role=;Password=;PasswordHash="
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            var builder = new DbConnectionStringBuilder();

            builder.Add("UserName", this.UserName ?? "");
            //builder.Add("Role", this.Role ?? "");
            builder.Add("Password", this.Password ?? "");
            builder.Add("PasswordHash", this.PasswordHash ?? "");
            return(builder.ConnectionString);
        }
예제 #16
0
        private string GetConnectionString(string fileOrServerOrConnectionString)
        {
            if (fileOrServerOrConnectionString.IndexOf('=') >= 0)
            {
                return(fileOrServerOrConnectionString);
            }
            DbConnectionStringBuilder builder = new DbConnectionStringBuilder();

            if (fileOrServerOrConnectionString.EndsWith(".mdf", StringComparison.OrdinalIgnoreCase))
            {
                builder.Add("AttachDBFileName", fileOrServerOrConnectionString);
                builder.Add("Server", @"localhost\sqlexpress");
                builder.Add("Integrated Security", "SSPI");
                builder.Add("User Instance", "true");
                builder.Add("MultipleActiveResultSets", "true");
            }
            else if (fileOrServerOrConnectionString.EndsWith(".sdf", StringComparison.OrdinalIgnoreCase))
            {
                builder.Add("Data Source", fileOrServerOrConnectionString);
            }
            else
            {
                builder.Add("Server", fileOrServerOrConnectionString);
                builder.Add("Database", services.Model.DatabaseName);
                builder.Add("Integrated Security", "SSPI");
            }
            return(builder.ToString());
        }
예제 #17
0
        static void InitConnection()
        {
            DbConnectionStringBuilder dbsb = new DbConnectionStringBuilder();

            dbsb.Add("Server", "localhost");
            dbsb.Add("Database", "istoredb");
            dbsb.Add("User Id", "root");
            dbsb.Add("Password", "admin");

            connectionString = dbsb.ConnectionString;
        }
예제 #18
0
파일: StartUp.cs 프로젝트: msalah85/CMS
        public static string MakeConnectionString(string server_IP, string loginName, string password, string dataBase)
        {
            DbConnectionStringBuilder con = new DbConnectionStringBuilder();

            con.Add("Data Source", server_IP);
            con.Add("Initial Catalog", dataBase);
            con.Add("uid", loginName);
            con.Add("pwd", password);

            return(con.ConnectionString);
        }
예제 #19
0
        private static string GetConnectionString()
        {
            var sb = new DbConnectionStringBuilder();

            sb.Add("Data Source", @"(localdb)\MSSQLLocalDB");
            sb.Add("Initial Catalog", "Hotel");    //database name
            sb.Add("Integrated Security", "True"); //enable windows authentication
            var connection = sb.ConnectionString;

            return(connection);
        }
예제 #20
0
        /// <summary>
        /// Creates a new instance
        /// </summary>
        public OleDb(string Provider, string FilePath, string Password)
        {
            DbConnectionStringBuilder builder = new DbConnectionStringBuilder();

            builder.Add("Provider", Provider);
            builder.Add("Data Source", FilePath);
            if (Password != null)
            {
                builder.Add("Database Password", Password);
            }
            ConnectionString = builder.ConnectionString;
        }
예제 #21
0
        public async Task <string> GetConnectionString()
        {
            if (UseCredentialChain)
            {
                var credential  = new DefaultAzureCredential();
                var accessToken = await credential.GetTokenAsync(new TokenRequestContext(new[] { "https://ossrdbms-aad.database.windows.net" }));

                stringBuilder.Add("password", accessToken.Token);
                stringBuilder.Add("sslmode", "Require");
            }
            return(stringBuilder.ConnectionString);
        }
예제 #22
0
        public override void ActivateOptions()
        {
            base.ActivateOptions();

            DbConnectionStringBuilder sb = new DbConnectionStringBuilder();

            sb.Add("Server", Server);
            sb.Add("Database", Database);
            sb.Add("User Id", UserId);
            sb.Add("Password", Password);

            ConnectionString = sb.ConnectionString;
        }
예제 #23
0
            DbConnection Connect(string path)
            {
                var builder = new DbConnectionStringBuilder();

                builder.Add("Provider", "Microsoft.Jet.OLEDB.4.0");
                path = System.IO.Path.GetDirectoryName(path);
                builder.Add("Data Source", path);
                builder.Add("Extended Properties", "dBASE III");
                var conn = new System.Data.OleDb.OleDbConnection(builder.ConnectionString);

                conn.Open();
                return(conn);
            }
        private static string GenerateConnectionString(string edsSqlSchemaVersion, string connectionString)
        {
            string value = Guid.NewGuid().ToString();
            DbConnectionStringBuilder dbConnectionStringBuilder = new DbConnectionStringBuilder();

            dbConnectionStringBuilder.ConnectionString = connectionString;
            object obj;

            if (dbConnectionStringBuilder.TryGetValue("Site", out obj))
            {
                dbConnectionStringBuilder.Remove("Site");
            }
            SqlConnectionStringBuilder sqlConnectionStringBuilder = new SqlConnectionStringBuilder(dbConnectionStringBuilder.ConnectionString);
            object obj2;

            if (!sqlConnectionStringBuilder.TryGetValue("Password", out obj2))
            {
                throw new ArgumentException("The connection string must contain a password.");
            }
            string password;

            if (!ManageEdsConnectionStrings.DkmEncryptString(obj2.ToString(), out password))
            {
                throw new ApplicationException("Unable to encrypt password");
            }
            sqlConnectionStringBuilder.Password = password;
            object obj3;

            if (!sqlConnectionStringBuilder.TryGetValue("User ID", out obj3) || string.IsNullOrEmpty(obj3.ToString()))
            {
                throw new ArgumentException("The connection string must contains a User ID");
            }
            if (!sqlConnectionStringBuilder.TryGetValue("Initial Catalog", out obj3) || string.IsNullOrEmpty(obj3.ToString()))
            {
                throw new ArgumentException("The connection string must contains an Initial Catalog");
            }
            if (!sqlConnectionStringBuilder.TryGetValue("Data Source", out obj3) || string.IsNullOrEmpty(obj3.ToString()))
            {
                throw new ArgumentException("The connection string must contains a Data Source");
            }
            DbConnectionStringBuilder dbConnectionStringBuilder2 = new DbConnectionStringBuilder();

            dbConnectionStringBuilder2.ConnectionString = sqlConnectionStringBuilder.ConnectionString;
            if (!string.IsNullOrEmpty((string)obj))
            {
                dbConnectionStringBuilder2.Add("Site", obj);
            }
            dbConnectionStringBuilder2.Add("Guid", value);
            dbConnectionStringBuilder2.Add("EdsSqlSchemaVersion", edsSqlSchemaVersion);
            return(dbConnectionStringBuilder2.ToString());
        }
예제 #25
0
        public static DbConnection GetAccessOleConnection(string dbPath, string dbPassword)
        {
            DbConnection connection        = GetConnection("System.Data.OleDb");
            DbConnectionStringBuilder dbcb = ConnectionStringBuilder("System.Data.OleDb");

            dbcb.Add("Provider", "Microsoft.Jet.OLEDB.4.0");
            dbcb.Add("Data Source", dbPath);
            if (!String.IsNullOrEmpty(dbPassword))
            {
                dbcb.Add("Jet OLEDB:Database Password", dbPassword);
            }
            connection.ConnectionString = dbcb.ConnectionString;
            return(connection);
        }
예제 #26
0
        public void doTests()
        {
            DbConnection conn = createConnection();

            if (_factory is SqlClientFactory)
            {
                DbConnectionStringBuilder dcsb;

                dcsb = new DbConnectionStringBuilder();
                dcsb.Add("User ID", "operator");
                dcsb.Add("Password", "operator");
                dcsb.Add("Application Name", Assembly.GetEntryAssembly().GetName().Name);
                dcsb.Add("Workstation ID", Environment.MachineName);
                dcsb.Add("Data Source", "colt-sql");
                dcsb.Add("Initial Catalog", "checkweigh_data_dev");
                dcsb.Add("Persist Security Info", true);
                dcsb.Add("Integrated Security", true);
                conn.ConnectionString = dcsb.ConnectionString;
            }
            if (_factory.CanCreateDataSourceEnumerator)
            {
                findDataSources(_factory);
            }
            DbCommandSelect(conn);
            ExecuteDbCommand(conn);
            CreateDataAdapter(_factory, conn.ConnectionString);
            CreateDataAdapter2(_factory, conn.ConnectionString);
        }
        private EmpressConnection getCSConnection()
        {
            DbConnectionStringBuilder csb = new DbConnectionStringBuilder();

            csb.ConnectionString = "Server=coral";
            csb.Add("database", "/tmp/BankDb");
            csb.Add("User", "dli");
            csb.Add("Port", 6681);

            EmpressConnection localConnection = new EmpressConnection();

            localConnection.ConnectionString = csb.ToString();

            return(localConnection);
        }
예제 #28
0
        public void CreateFactory_creates_a_ConnectionFactory_from_connectionString(ConnectionStringConnectionFactoryProvider sut, IConfigurationSection section, string hostname, string username, string password, string virtualHost)
        {
            var connectionStringBuilder = new DbConnectionStringBuilder();

            connectionStringBuilder.Add("HostName", hostname);
            connectionStringBuilder.Add("Username", username);
            connectionStringBuilder.Add("Password", password);
            connectionStringBuilder.Add("VirtualHost", virtualHost);

            Mock.Get(section).SetupGet(p => p.Value).Returns(connectionStringBuilder.ConnectionString);

            var factory = sut.CreateFactory(section) as ConnectionFactory;

            Assert.That(factory, Is.Not.Null);
        }
예제 #29
0
        public void Add([NotNull] string keyword, [NotNull] string newValue)
        {
            Assert.ArgumentNotNullOrEmpty(keyword, nameof(keyword));
            Assert.ArgumentNotNullOrEmpty(newValue, nameof(newValue));

            _builder.Add(keyword, newValue);
        }
        public DbConnectionStringBuilder GetConnectionStringBuilder()
        {
            //Data Source=chumsql2;User ID=mysql;Password=******;Allow Zero Datetime=Yes;Allow User Variables=true;Persist Security Info=true;Default Command Timeout=3600
            DbConnectionStringBuilder connectionStringBuilder = MySqlClientFactory.Instance.CreateConnectionStringBuilder();

            connectionStringBuilder.Add("Data Source", ServerName);
            connectionStringBuilder.Add("Database", DatabaseName);
            connectionStringBuilder.Add("User ID", Credentials.UserId);
            connectionStringBuilder.Add("Password", Credentials.Password);
            if (Port > 0)
            {
                connectionStringBuilder.Add("Port", Port.ToString());
            }

            return(connectionStringBuilder);
        }