/// <summary>
        ///
        /// </summary>
        /// <param name="produto">Objeto Produto</param>
        /// <returns>true ou flase</returns>
        public bool cadastraProduto(Produto produto, Configuracoes config)
        {
            #region Declaração

              string sql = string.Empty;
              SqlConnection conn = null;
              SqlCommand cmd = null;
              string data = DateTime.Now.ToString("dd-MM-yyyy");

              #endregion Declaração

              #region Implementação

              conn = new SqlConnection(config.ConectionString);
              cmd = new SqlCommand();
              cmd.CommandType = CommandType.Text;
              cmd.Connection = conn;
              try
              {

            sql = @"INSERT INTO dbo.Produtos (nome, idCategoria, codigoBarras, quantidade, diponivel, idFornecedor, valorAVista, valorBase, valorPrazo, valorCredito, cadastradoEm, cadstradoPor)
                VALUES (@nome, @idcategoria, @codigobarras, @quantidade, @disponivel, @idfornecedor, @valoravista, @valorbase, @valorprazo, @valorcredito, @cadastradoem, @cadstradopor)";

            cmd.CommandText = sql;

            cmd.Parameters.AddWithValue("@nome", produto.Nome);
            cmd.Parameters.AddWithValue("@idcategoria", int.Parse(produto.IdCategoria.ToString()));
            cmd.Parameters.AddWithValue("@codigobarras", produto.CodigoBarras);
            cmd.Parameters.AddWithValue("@quantidade", int.Parse(produto.Quantidade.ToString()));
            cmd.Parameters.AddWithValue("@disponivel", produto.Disponivel);
            cmd.Parameters.AddWithValue("@idfornecedor", int.Parse(produto.IdFornecedor.ToString()));
            cmd.Parameters.AddWithValue("@valoravista", int.Parse(produto.ValoraVista.ToString()));
            cmd.Parameters.AddWithValue("@valorbase", int.Parse(produto.ValorBase.ToString()));
            cmd.Parameters.AddWithValue("@valorprazo", int.Parse(produto.ValorAPrazo.ToString()));
            cmd.Parameters.AddWithValue("@valorcredito", int.Parse(produto.ValorCrediario.ToString()));
            cmd.Parameters.AddWithValue("@cadastradoem", DateTime.Now);
            cmd.Parameters.AddWithValue("@cadstradopor", int.Parse("1"));

            conn.Open();

            cmd.ExecuteNonQuery();

            return true;
              }
              catch (Exception ex)
              {
            return false;
              }
              finally
              {
            if (conn.State == ConnectionState.Open)
              conn.Close();
            cmd.Dispose();
            conn.Dispose();

              }

              #endregion Implementação
        }
        private void btnNovo_Click(object sender, EventArgs e)
        {
            #region Declaração

              int Id = 0;
              dataBase db = null;
              List<Categoria> categoriasDB = null;

              #endregion

              #region Implementação

              produtosControler prodControl = new produtosControler();

              config = new Configuracoes();
              db = new dataBase();
              categoriasDB = new List<Categoria>();

              config = db.iserirConexao();

              categoriasDB = prodControl.categoriaBanco(config);

              if (categoriasDB.Count > 0)
              {

            cbCategorias.DataSource = categoriasDB;

            if (carregado == false) //verifica se ja foi clicado uma vez no botão Novo
            {
              Id = prodControl.LastID(config);
              Id++;
              tbCodigoPro.Text = Convert.ToString(Id);
              carregado = true; //Seta para true para nao carregar as Categorias novamente
            }

            btnSalvar.Enabled = true;
            btnPesForne.Enabled = false;
            tbNomePro.Enabled = true;
            tbCodBarras.Enabled = true;
            tbQuantidade.Enabled = true;
            cbCategorias.Enabled = true;
            cbxDisponivel.Enabled = true;
            gbFornecedor.Enabled = true;
            gbPrecos.Enabled = true;
            //btnPesForne.Enabled = true; Habilitar após criar a Tabela no banco

            limpaForm();

              }
              else
              {
            MessageBox.Show("Erro ao carregar Dados","Erro");
              }
              #endregion
        }
        public bool BackupDataBase(Configuracoes config)
        {
            #region Declaração

              if (config.SqlServer != null)
              {

            Backup bkpDataBase = null;
            string data = DateTime.Now.Date.ToString("dd-mm-yyyy");
            BackupDeviceItem bkpDeviceItem = null;
            string fileName = string.Empty;
            string path = string.Empty;
              #endregion

              #region Implementação

            fileName = "Backup_" + data + ".bak";

            bkpDataBase = new Backup();
            bkpDeviceItem = new BackupDeviceItem();

            bkpDataBase.Action = BackupActionType.Database;
            bkpDataBase.Database = config.Database;

            path = "C:\\Sistema\\Backup\\";

            if (!Directory.Exists(path))
            {
              Directory.CreateDirectory(path);
            }

            path = path + fileName.Replace(" ","_").Replace("/","_").Replace(":","_");

            if (!File.Exists(path))
            {
              File.CreateText(path);
            }

            bkpDataBase.Incremental = false;
            bkpDataBase.BackupSetName = fileName;

            bkpDataBase.Checksum = true;
            bkpDataBase.Devices.Add(new BackupDeviceItem(path, DeviceType.File));

            bkpDataBase.SqlBackup(config.SqlServer);

            return true;

              }
              else
            return false;

              #endregion
        }
        private void frmPrincipal_Load(object sender, EventArgs e)
        {
            dataBase db = new dataBase();
              Configuracoes config = new Configuracoes();
              config = db.iserirConexao();

              if (config != null)
              {
            this.strConn = config.ConectionString;
              }
        }
        public List<Categoria> categoriaBanco(Configuracoes config)
        {
            #region Declaração
            produtosDAO produto = null;
            #endregion

            #region Implementação
            produto = new produtosDAO();

            return produto.carregaCatProd(config);

            #endregion
        }
        public int LastID(Configuracoes config)
        {
            #region Declaração

            produtosDAO produtoDAO = null;
            #endregion

            #region Implementação

            produtoDAO = new produtosDAO();

            return produtoDAO.carregaUltimoRegistro(config);
            #endregion
        }
        public bool cadastraProduto(Produto produto, Configuracoes config)
        {
            #region Declaração

            produtosDAO prod = null;
            #endregion

            #region Implementação

            prod = new produtosDAO();

            return prod.cadastraProduto(produto, config);

            #endregion
        }
        /// <summary>
        /// Carrega os Servidores Sql Rodando na maquina
        /// </summary>
        /// <param name="config">Passa a Classe Configurações</param>
        /// <returns>Configurações</returns>
        public Configuracoes CarregaServidor(Configuracoes config)
        {
            #region Declaração

              configuracoesDAO configDAO = null;

              #endregion

              #region Implementação

              configDAO = new configuracoesDAO();

              return configDAO.carregaServer(config);

              #endregion
        }
        /// <summary>
        /// Carrega os Banco de dados presentes no Sevidor
        /// </summary>
        /// <param name="config">Configurações</param>
        /// <returns>Configurações</returns>
        public Configuracoes CarregaBanco(Configuracoes config)
        {
            #region Declaração

              configuracoesDAO configDAO = null;

              #endregion

              #region Implementação

              configDAO = new configuracoesDAO();

              return configDAO.ListaBanco(config);

              #endregion
        }
        public bool Backup(Configuracoes config)
        {
            #region Declaração

              configuracoesDAO configDAO = null;

              #endregion

              #region Implementação

              configDAO = new configuracoesDAO();

              return configDAO.BackupDataBase(config);

              #endregion
        }
        public Configuracoes iserirConexao()
        {
            AppSettingsSection appSetSec = configFile.AppSettings;
              configuracoesControler configControl = new configuracoesControler();
              Configuracoes config = new Configuracoes();

              config = configControl.CarregaServidor(config);
              //config = configControl.CarregaBanco(config);

              config.Servidor = appSetSec.Settings["servidor"].Value;
              config.Database = appSetSec.Settings["database"].Value;
              config.User = appSetSec.Settings["user"].Value;
              config.Senha = appSetSec.Settings["senha"].Value;
              config.ConectionString = appSetSec.Settings["connectionString"].Value;

              return config;
        }
        public bool salvaConfiguracoes(Configuracoes config)
        {
            AppSettingsSection appSetSec = configFile.AppSettings;

              appSetSec.Settings["servidor"].Value = config.Servidor;
              appSetSec.Settings["database"].Value = config.Database;
              appSetSec.Settings["user"].Value = config.User;
              appSetSec.Settings["senha"].Value = config.Senha;
              appSetSec.Settings["connectionString"].Value = config.ConectionString;

              configFile.AppSettings.Settings.Remove("connectionString");

              configFile.AppSettings.Settings.Add("connectionString", "Data Source=GSJP01PD011\\SQLEXPRESS;Initial Catalog=estoque;User ID=estoque;Password=estoque");

              configFile.Save();

              return true;
        }
        private void frmRestoreDataBase_Load(object sender, EventArgs e)
        {
            #region Declaração

              configuracoesControler configControl = null;
              #endregion

              #region Implementação
              configControl = new configuracoesControler();

              config = configControl.ListaArquivos(config);

              if (config.ArquivosRestore != null)
            ltbArquivos.DataSource = config.ArquivosRestore;
              else
            MessageBox.Show("Não há arquivos de restauração!", "Erro");

              #endregion
        }
        private void btnCarregaBanco_Click(object sender, EventArgs e)
        {
            #region Implementação

              config.Servidor = cbListServer.Text;

              configuracoesControler configColtrol = new configuracoesControler();

              config = configColtrol.CarregaBanco(config);

              cbDataBase.DataSource = config.Databases;

              if (config.Databases.Count > 0)
              {
            btnTeste.Enabled = true;
              }

              #endregion
        }
        public SqlConnection conectar(Configuracoes config)
        {
            conn = new SqlConnection();
              try
              {
            conn.ConnectionString = config.ConectionString;

            conn.Open();

              }
              catch
              {
            if (conn.State != ConnectionState.Open)
            {
              return conn;
            }
              }

              return conn;
        }
        public Configuracoes carregaServer(Configuracoes config)
        {
            #region Declaração

              DataTable dtServers = null;

              #endregion

              #region Implementação
              dtServers = new DataTable();
              dtServers = SmoApplication.EnumAvailableSqlServers(true);
              //Instancia uma nova Lista
              config.Servidores = new List<string>();
              if (dtServers.Rows.Count > 0)
              {
            foreach (DataRow drServer in dtServers.Rows)
            {
              config.Servidores.Add(drServer["Name"].ToString());
            }
              }

               return config;
              #endregion
        }
 public frmRestoreDataBase(Configuracoes config)
 {
     InitializeComponent();
       this.config = config;
 }
        public Fornecedor PesquisaFornecedor(Configuracoes config)
        {
            #region Declaração

              SqlConnection conn = null;
              SqlCommand cmd = null;
              string sql = string.Empty;
              Fornecedor fornecedor = null;

              #endregion

              #region Implementação

              conn = new SqlConnection(config.ConectionString);
              fornecedor = new Fornecedor();

              sql = @"SELECT ident_current('dbo.Produtos')";

              conn.Open();

              cmd = new SqlCommand(sql, conn);

              SqlDataReader dr = cmd.ExecuteReader();

              if (dr.HasRows)
              {
            while (dr.Read())
            {
              fornecedor.IdFornecedor = Convert.ToInt32(dr[0].ToString());
            }
              }
              return fornecedor;

              #endregion
        }
        /// <summary>
        /// Carrega o ultimo registro do banco
        /// </summary>
        /// <param name="config">Configuraçções da conexão</param>
        /// <returns>Int - ultimo registro do banco</returns>
        public int carregaUltimoRegistro(Configuracoes config)
        {
            #region Declaração

              SqlConnection conn = null;
              SqlCommand cmd = null;
              string sql = string.Empty;
              int ultimoRegistro = 0;

              #endregion

              #region Implementação

              conn = new SqlConnection(config.ConectionString);

              sql = @"SELECT ident_current('dbo.Produtos')";

              conn.Open();

              cmd = new SqlCommand(sql, conn);

              SqlDataReader dr = cmd.ExecuteReader();

              if (dr.HasRows)
              {
            while (dr.Read())
            {
              ultimoRegistro = Convert.ToInt32(dr[0].ToString());
            }
              }
              return ultimoRegistro;

              #endregion
        }
        public Configuracoes ListaArquivos(Configuracoes config)
        {
            #region Declaração

              DirectoryInfo dirInfo = null;
              FileInfo[] arquivos = null;
              string path = string.Empty;

              #endregion

              #region Implementação

              path = "C:\\Sistema\\Backup\\";

              dirInfo = new DirectoryInfo(path);
              config.Path = path;

              arquivos = dirInfo.GetFiles("*.bak");

              if (arquivos.Length > 0)
              {
            config.ArquivosRestore = new List<string>();

            foreach (FileInfo fileinfo in arquivos)
            {
              config.ArquivosRestore.Add(fileinfo.Name);
            }
            return config;
              }
              else
            return config;
              #endregion
        }
        public Configuracoes ListaBanco(Configuracoes config)
        {
            #region Declaração
              ServerConnection srConn = null;
              Server server = null;

              #endregion

              #region Implementação

              srConn = new ServerConnection(config.Servidor);

              srConn.LoginSecure = false;

              srConn.Login = config.User;

              srConn.Password = config.Senha;

              server = new Server(srConn);

              config.SqlServer = server;

              config.Databases = new List<string>();

              foreach ( Microsoft.SqlServer.Management.Smo.Database  dbserver in server.Databases)
              {
            config.Databases.Add(dbserver.Name);
              }

              return config;

              #endregion
        }
        private void frmConfiguracao_Load(object sender, EventArgs e)
        {
            #region Declaração

              dataBase data = null;
              string conexao = string.Empty;

              #endregion

              #region Implementação

              data = new dataBase();

              config = data.iserirConexao();

              foreach (string item in config.Servidores)
              {
            cbListServer.Items.Add(item);
            cbListServer.DisplayMember = "";
            cbListServer.ValueMember = "";
              }
              tbUser.Text = config.User;
              tbSenha.Text = config.Senha;

              #endregion
        }
        private void btnTeste_Click(object sender, EventArgs e)
        {
            #region Declaração

              dataBase data = null;
              SqlConnection conn = null;

              #endregion

              #region Implementação
              if (cbDataBase.Text != "")
              {

            data = new dataBase();

            //config = data.iserirConexao();
            config.Servidor = cbListServer.Text;
            config.Database = cbDataBase.Text;
            config.User = tbUser.Text;
            config.Senha = tbSenha.Text;

            config = mudaConfigurações();

            conn = data.conectar(config);

            lbConString.Text = config.ConectionString;

            if (conn.State == ConnectionState.Open)
            {
              lbTeste.Text = "Conectado com Sucesso!";
              lbTeste.ForeColor = Color.Blue;
              btnBackup.Enabled = true;

            }
            else
            {
              lbTeste.Text = "Não foi possível conectar ao Banco de Dados";
              lbTeste.ForeColor = Color.Red;
            }
              }
              else
            MessageBox.Show("Selecione o Banco!", "Aviso");

              #endregion
        }
        /// <summary>
        /// Carrega as Categorias do Banco
        /// </summary>
        /// <param name="config"> Configuração da ConnectionString</param>
        /// <returns>List<string> Categoria</returns>
        public List<Categoria> carregaCatProd(Configuracoes config)
        {
            #region Declaração

              string sql = string.Empty;
              SqlConnection conn = null;
              SqlCommand cmd = null;

              #endregion Declaração

              #region Implementação

              Categoria categoria = null;
              List<Categoria> listCategoria = null;
              try
              {
            conn = new SqlConnection(config.ConectionString);
            cmd = new SqlCommand();

            listCategoria = new List<Categoria>();

            SqlDataReader dr = null;
            sql = "SELECT idCategoria, categoria FROM dbo.categoria";

            cmd.CommandType = CommandType.Text;
            cmd.Connection = conn;
            cmd.CommandText = sql;

            if (conn.State == ConnectionState.Closed)
              conn.Open();

            dr = cmd.ExecuteReader();

            while (dr.Read())
            {
              categoria = new Categoria();
              categoria.IdCategoria = int.Parse(dr["idCategoria"].ToString().Trim());
              categoria.CategoriaP = dr["categoria"].ToString().Trim();

              listCategoria.Add(categoria);
            }

            return listCategoria;
              }
              catch (Exception ex)
              {
            return listCategoria;
              }
              finally
              {
            if (conn.State == ConnectionState.Open)
              conn.Close();
              }

              #endregion Implementação
        }
        public bool salvaServidor(Configuracoes config)
        {
            #region Declaração

            #endregion

            #region Implementação

            System.Configuration.Configuration conf = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            return true;

            #endregion
        }
        public Configuracoes ListaArquivos(Configuracoes config)
        {
            #region Declaração

              configuracoesDAO configDAO = null;

              #endregion

              #region Implementação

              configDAO = new configuracoesDAO();

              return configDAO.ListaArquivos(config);

              #endregion
        }
        public bool RestoreDataBase(Configuracoes config)
        {
            #region Declaração

              Restore rstDataBase = null;
              BackupDeviceItem bkpDevice = null;

              #endregion

              #region Implementação
              var sc = new SqlConnection("Data Source=GSJP01PD011\\SQLEXPRESS;Initial Catalog=master;User ID=estoque;Password=estoque");

              String sql = @"USE [master]; RESTORE DATABASE "+config.Database +" FROM DISK = '"+config.Path+"' WITH REPLACE;";

              var cmd = new SqlCommand(sql, sc);
              sc.Open();

              cmd.ExecuteNonQuery();
              //var serverConn = new ServerConnection(sc);
              //var server = new Server(serverConn);
              //server.ConnectionContext.DatabaseName = "master";

              //Database db = server.Databases[config.Database];
              //var restore = new Restore();

              //server.KillAllProcesses(config.Database);
              //db.Alter(TerminationClause.RollbackTransactionsImmediately);
              //restore.Action = RestoreActionType.Database;

              //restore.Database = config.Database;
              //restore.ReplaceDatabase = true;
              //restore.Devices.AddDevice(config.Path, DeviceType.File);
              //restore.ReplaceDatabase = true;
              //restore.NoRecovery = false;

              //restore.SqlRestore(server);

              return true;
              #endregion
        }