private void selectSqlConnection(string connectionString, DBType dbType, string connectionName, bool isODBC)
        {
            if (!this.cbConnection.Items.OfType <LastDirectConnectionString>().Any(
                    x => x.ConnectionString == connectionString &&
                    x.IsODBC == isODBC
                    )
                )
            {
                LastDirectConnectionString newItem = new LastDirectConnectionString()
                {
                    DataBaseType     = dbType.Id.ToString(),
                    ConnectionString = connectionString,
                    IsODBC           = isODBC,
                    Name             = connectionName
                };

                this.cbConnection.Items.Add(newItem);
                this.cbConnection.SelectedItem = newItem;
            }
            else
            {
                LastDirectConnectionString item =
                    this.cbConnection.Items.OfType <LastDirectConnectionString>()
                    .First(x => x.ConnectionString == connectionString && x.IsODBC == isODBC);

                this.cbConnection.SelectedItem = item;
            }
        }
        private static DbConnectionStringBuilder GetConnectionStringBuilder(LastDirectConnectionString connectionString)
        {
            if (connectionString.IsODBC)
            {
                return(new OdbcConnectionStringBuilder(connectionString.ConnectionString));
            }

            DbConnectionStringBuilder builder;
            QuerySource dbType;

            if (Enum.TryParse(connectionString.DataBaseType, out dbType))
            {
                switch (dbType)
                {
                case QuerySource.MSSQL:
                    builder = new SqlConnectionStringBuilder();
                    break;

                case QuerySource.SQLite:
                    // ODBC connection string builder is used
                    // for SQLite internal connection
                    // since it handles special connection string adequately
                    builder = new OdbcConnectionStringBuilder();
                    break;

                default:
                    builder = new DbConnectionStringBuilder();
                    break;
                }
            }
            else
            {
                builder = new DbConnectionStringBuilder();
            }

            builder.ConnectionString = connectionString.ConnectionString;
            return(builder);
        }
        private bool ValidateAddConnectionForm()
        {
            bool result = true;

            LastDirectConnectionString connectionString =
                this.cbConnection.SelectedItem as LastDirectConnectionString;

            LastDirectConnectionStringGroup connectionStringGroup =
                this.cbConnection.SelectedItem as LastDirectConnectionStringGroup;

            if ((connectionString == null || string.IsNullOrEmpty(connectionString.ConnectionString)) &&
                (connectionStringGroup == null || connectionStringGroup.ConnectionStrings == null))
            {
                this.errorProvider.SetError(this.cbConnection, this.GetLocalizedText("SelectServerError"));

                result = false;
            }
            else
            {
                this.errorProvider.SetError(this.cbConnection, string.Empty);
            }

            return(result);
        }
        private void cbConnectionUpdate()
        {
            string selDbType = String.Empty;
            LastDirectConnectionStringGroup selectedGroup = null;

            if (cbDataBaseType.SelectedItem != null)
            {
                DBType selItem = cbDataBaseType.SelectedItem as DBType;
                setModuleTypeItems(selItem);
                selDbType = selItem.Id.ToString();
            }

            cbConnection.Items.Clear();

            foreach (LastDirectConnectionString connectionString in Program.Model.Settings.LastDirectConnectionStringsItems.Where(c => c.DataBaseType == selDbType))
            {
                this.cbConnection.Items.Add(connectionString);
            }

            foreach (LastDirectConnectionStringGroup connectionStringGroup in Program.Model.Settings.LastDirectConnectionStringsGroups)
            {
                LastDirectConnectionString firstGroupConnection = connectionStringGroup.ConnectionStrings.ElementAt(0);
                if (firstGroupConnection.DataBaseType != selDbType)
                {
                    continue;
                }

                if (connectionStringGroup.ConnectionStrings.Count == 1 &&
                    firstGroupConnection.ConnectionString.Equals(connectionStringGroup.GroupName))
                {
                    continue;
                }

                this.cbConnection.Items.Add(connectionStringGroup);

                if (IsConnStrGroupWasSelected(connectionStringGroup) && selectedGroup == null)
                {
                    selectedGroup = connectionStringGroup;
                }
            }

            if (this.cbConnection.Items.Count == 1)
            {
                this.cbConnection.SelectedIndex = 0;
                return;
            }

            if (selectedGroup != null)
            {
                this.cbConnection.SelectedItem = selectedGroup;
            }
            else
            {
                LastDirectConnectionString ldcStr = Program.Model.Settings.LastDirectConnectionStrings.FirstOrDefault();

                if (ldcStr != null)
                {
                    foreach (object item in cbConnection.Items)
                    {
                        if (!(item is LastDirectConnectionString))
                        {
                            continue;
                        }

                        string itemName = (item as LastDirectConnectionString).Name;

                        if (itemName == ldcStr.Name)
                        {
                            cbConnection.SelectedItem = item;
                        }
                    }
                }
            }
        }