Exemple #1
0
        public void ParcelaCadastraAtualiza(ModeloParcelasCompra modelo)
        {
            ValidaCampos(modelo);
            DALParcelasCompra DALObj = new DALParcelasCompra(conexao);

            DALObj.ParcelaCadastraAtualiza(modelo);
        }
Exemple #2
0
 public void ValidaCampos(ModeloParcelasCompra modelo)
 {
     if (modelo.parcelascompra == null)
     {
         throw new Exception("parcelascompra");
     }
 }
        public void Alterar(ModeloParcelasCompra modelo)
        {
            if (modelo.pco_cod.Equals(""))
            {
                throw new Exception("O Código da parcela é obrigatório!");
            }
            if (modelo.com_cod <= 0)
            {
                throw new Exception("O código da compra é obrigatório!");
            }
            if (modelo.pco_valor.Equals(""))
            {
                throw new Exception("O valor da parcela é obrigatório!");
            }
            DateTime data = DateTime.Now;

            if (modelo.pco_datavecto.Year < data.Year)
            {
                throw new Exception("Ano de vencimento inferior ao ano atual!");
            }

            DAOParcelaCompra daopar = new DAOParcelaCompra(conexao);

            daopar.Alterar(modelo);
        }
        //METEDO ALTERAR
        public void Alterar(ModeloParcelasCompra modelo)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();
                cmd.Connection  = Conexao.ObjetoConexao;
                cmd.CommandText = "update parcelascompra set pco_datapagto = @pco_datapagto" +
                                  "pco_datavecto = @pco_datavecto, pco_valor = @pco_valor where com_cod = @com_cod " +
                                  "and pco_cod = @pco_cod";

                cmd.Parameters.Add("@pco_datapagto", System.Data.SqlDbType.Date);
                if (modelo.Pco_datapagto == null)
                {
                    cmd.Parameters["@pco_datapagto"].Value = DBNull.Value;
                }
                else
                {
                    cmd.Parameters["@pco_datapagto"].Value = modelo.Pco_datapagto;
                }
                cmd.Parameters["@pco_datavecto"].Value = modelo.Pco_datavecto;
                cmd.Parameters.AddWithValue("@pco_valor", modelo.Pco_valor);
                cmd.Parameters.AddWithValue("@com_cod", modelo.Com_cod);
                cmd.Parameters.AddWithValue("@pco_cod", modelo.Pco_cod);
                Conexao.Conectar();
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conexao.Desconectar();
            }
        }
Exemple #5
0
        public void Alterar(ModeloParcelasCompra modelo)
        {
            if (modelo.PcoCod <= 0)
            {
                throw new Exception("Código da parcela é obrigatório");
            }

            if (modelo.ComCod <= 0)
            {
                throw new Exception("Código da compra é obrigatório");
            }

            if (modelo.PcoValor <= 0)
            {
                throw new Exception("Valor da parcela é obrigatório");
            }

            DateTime data = DateTime.Now;

            if (modelo.PcoDataVecto.Year < data.Year)
            {
                throw new Exception("Ano de vencimento inferior ao ano atual");
            }

            DAOParcelasCompra DALobj = new DAOParcelasCompra(conexao);

            DALobj.Alterar(modelo);
        }
Exemple #6
0
        public void Incluir(ModeloParcelasCompra modelo)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.Connection  = conexao.ObjetoConexao;
            cmd.Transaction = conexao.ObejtoTransacao;
            cmd.CommandText = "insert into parcelascompra(pco_cod, com_cod, pco_datavecto, pco_valor) values (@pco_cod, @com_cod, @pco_datavecto, @pco_valor);";

            cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
            cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
            cmd.Parameters.AddWithValue("@pco_valor", modelo.PcoValor);
            cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.Date);

            if (modelo.PcoDataVecto == null)
            {
                cmd.Parameters["@pco_datavecto"].Value = DBNull.Value;
            }
            else
            {
                cmd.Parameters["@pco_datavecto"].Value = modelo.PcoDataVecto;
            }

            // conexao.Conectar();
            cmd.ExecuteNonQuery();
            // conexao.Desconectar();
        }
        //CARREGA MODELO
        public ModeloParcelasCompra compraModeloParcela(int com_cod, int pco_cod)
        {
            try
            {
                ModeloParcelasCompra compra = new ModeloParcelasCompra();
                SqlCommand           cmd    = new SqlCommand();
                cmd.Connection  = Conexao.ObjetoConexao;
                cmd.CommandText = "select * from parcelascompra where pco_cod = @pco_cod " +
                                  "and com_cod = @com_cod";
                cmd.Parameters.AddWithValue("@pco_cod", pco_cod);
                cmd.Parameters.AddWithValue("@com_cod", com_cod);
                Conexao.Conectar();
                SqlDataReader registro = cmd.ExecuteReader();
                if (registro.HasRows)
                {
                    registro.Read();

                    compra.Pco_cod       = pco_cod;
                    compra.Com_cod       = com_cod;
                    compra.Pco_datapagto = Convert.ToDateTime(registro["pco_datapagto"]);
                    compra.Pco_datavecto = Convert.ToDateTime(registro["pco_datavecto"]);
                    compra.Pco_valor     = Convert.ToDouble(registro["pco_valor"]);
                }
                return(compra);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conexao.Desconectar();
            }
        }
        public void Alterar(ModeloParcelasCompra modelo)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.Connection  = conexao.ObjetoConexao;
            cmd.Transaction = conexao.ObjetoTransacao;
            cmd.CommandText = "update parcelascompra set pco_valor = @pco_valor, pco_datapagto = @pco_datapagto," +
                              "pco_datavecto = @datavecto where pco_cod = @pco_cod and com_cod = @com_cod;";
            cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
            cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
            cmd.Parameters.AddWithValue("@pco_valor", modelo.PcoValor);
            cmd.Parameters.Add("@pco_datapagto", System.Data.SqlDbType.Date);
            cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.Date);
            if (modelo.PcoDataPagto == null)
            {
                cmd.Parameters["@pco_datapagto"].Value = DBNull.Value;
            }
            else
            {
                cmd.Parameters["@pco_datapagto"].Value = modelo.PcoDataPagto;
            }

            cmd.Parameters["@pco_datavecto"].Value = modelo.PcoDataVecto;


            //conexao.Conectar();
            cmd.ExecuteNonQuery();
            //conexao.Desconectar();
        }
Exemple #9
0
        public ModeloParcelasCompra CarregaModeloParcelasCompra(int pcocod, int comcod)
        {
            try
            {
                ModeloParcelasCompra modelo = new ModeloParcelasCompra();
                SqlCommand           cmd    = new SqlCommand("[dbo].[spParcelasCompraLocalizarCarrega]", conexao._conexao);
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.AddWithValue("@pcocod", pcocod);
                cmd.Parameters.AddWithValue("@comcod", comcod);
                conexao.Conectar();
                SqlDataReader dr = cmd.ExecuteReader();
                if (dr.HasRows)
                {
                    dr.Read();
                    modelo.pco_cod       = Convert.ToInt32(dr["CODIGO"]);
                    modelo.pco_valor     = Convert.ToInt32(dr["VALOR_PARCELA"]);
                    modelo.pco_datapagto = Convert.ToDateTime(dr["DATA_PAGAMENTO"]);
                    modelo.pco_datavecto = Convert.ToDateTime(dr["DATA_VENCIMENTO"]);
                    modelo.com_cod       = Convert.ToInt32(dr["CODIGO_COMPRA"]);
                }

                return(modelo);
            }
            catch (Exception erro)
            {
                throw new Exception(erro.Message);
            }
            finally
            {
                conexao.Desconectar();
            }
        }
Exemple #10
0
        public void Incluir(ModeloParcelasCompra modelo)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();
                cmd.Connection  = conexao.ObjetoConexao;
                cmd.CommandText = "insert into parcelascompra (pco_cod ,pco_valor, pco_datavecto, com_cod)" +
                                  "values(@pco_cod ,@pco_valor,  @datavecto, @comcod);";
                cmd.Parameters.AddWithValue("@pco_cod", modelo.pco_cod);
                cmd.Parameters.AddWithValue("@pco_valor", modelo.pco_valor);

                cmd.Parameters.Add("@datavecto", System.Data.SqlDbType.Date);
                if (modelo.pco_datavecto.Equals(null))
                {
                    cmd.Parameters["@datavecto"].Value = DBNull.Value;
                }
                else
                {
                    cmd.Parameters["@datavecto"].Value = modelo.pco_datapagto;
                }

                cmd.Parameters.AddWithValue("@comCod", modelo.com_cod);

                conexao.Conectar();
                cmd.ExecuteNonQuery();
                conexao.Desconectar();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Exemple #11
0
        public void Incluir(ModeloParcelasCompra modelo)
        {
            DateTime Data = DateTime.Now;

            if (modelo.PcoCod <= 0)
            {
                MessageBox.Show("O código da parcelas é obrigatório !");
            }
            if (modelo.ComCod <= 0)
            {
                MessageBox.Show("O código da compra é obrigatório !");
            }
            if (modelo.PcoValor < 0)
            {
                MessageBox.Show("O valor da parcela é obrigatório !");
            }
            if (modelo.PcoDataVencimento.Year < Data.Year)
            {
                MessageBox.Show("Ano de vencimento inferior ao ano atual !");
            }

            DALparcelasCompra parcelasCompra = new DALparcelasCompra(conexao);

            parcelasCompra.GetIncluir(modelo);
        }
        public ModeloParcelasCompra CarregaModeloParcelasCompra(int PcoCod, int ComCod)
        {
            ModeloParcelasCompra modelo = new ModeloParcelasCompra();
            SqlCommand           cmd    = new SqlCommand();

            cmd.Connection  = conexao.ObjetoConexao;
            cmd.CommandText = "select * from parcelascompra where pco_cod = @pco_cod and com_cod = @com_cod ;";
            cmd.Parameters.AddWithValue("@pco_cod", PcoCod);
            cmd.Parameters.AddWithValue("@com_cod", ComCod);
            conexao.Conectar();
            SqlDataReader registro = cmd.ExecuteReader();

            if (registro.HasRows)
            {
                registro.Read();
                modelo.PcoCod       = PcoCod;
                modelo.ComCod       = ComCod;
                modelo.PcoDataPagto = Convert.ToDateTime(registro["pco_datapagto"]);
                modelo.PcoDataVecto = Convert.ToDateTime(registro["pco_datavecto"]);
                modelo.PcoValor     = Convert.ToDouble(registro["pco_valor"]);
            }
            registro.Close();
            conexao.Desconectar();
            return(modelo);
        }
 //METEDO INCLUIR
 public void Incluir(ModeloParcelasCompra modelo)
 {
     try
     {
         SqlCommand cmd = new SqlCommand();
         cmd.Connection  = Conexao.ObjetoConexao;
         cmd.CommandText = "insert into parcelascompra (pco_cod,com_cod,pco_datavecto,pco_valor)" +
                           " values(@pco_cod,@com_cod,@pco_datavecto,@pco_valor) ";
         cmd.Parameters.AddWithValue("@pco_cod", modelo.Pco_cod);
         cmd.Parameters.AddWithValue("@com_cod", modelo.Com_cod);
         cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.Date);
         cmd.Parameters["@pco_datavecto"].Value = modelo.Pco_datavecto;
         cmd.Parameters.AddWithValue("@pco_valor", modelo.Pco_valor);
         Conexao.Conectar();
         cmd.ExecuteNonQuery();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
     finally
     {
         Conexao.Desconectar();
     }
 }
Exemple #14
0
        private void Incluir(ModeloParcelasCompra modelo)
        {
            try
            {
                SqlCommand cmd = new SqlCommand();
                cmd.Connection  = conexao.ObjetoConexao;
                cmd.CommandText = "insert into parcelascompra (pco_cod, pco_valor, com_cod, pco_datavecto)"
                                  + "values (@pco_cod, @pco_valor, @com_cod, @pco_datavecto);";

                cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
                cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
                cmd.Parameters.AddWithValue("@pco_valor", modelo.PcoValor);
                cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.Date);
                cmd.Parameters["@pco_datavecto"].Value = modelo.PcoDataVencimento;

                conexao.Conectar();

                cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.Message, ex.StackTrace + "Detalhes Exception");
            }
            finally
            {
                conexao.Desconectar();
            }
        }
Exemple #15
0
        //Metodo para Excluir um item =====================================================================================================
        public void Excluir(ModeloParcelasCompra modelo) //recebe como parametro o codigo do item que se quer excluir
        {
            try
            {
                SqlCommand cmd = new SqlCommand();      // criar um comando SQL
                cmd.Connection = conexao.ObjetoConexao; // Definir a conexão

                //criar a query para o excluir o item conforme codigo recebido,
                cmd.CommandText = "DELETE FROM parcelascompra WHERE pco_cod = @pco_cod AND com_cod = @com_cod;";

                //adicona os parametros:
                cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
                cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);

                //conecta ao banco
                conexao.Conectar();
                cmd.ExecuteNonQuery();//executa o comando que nao retorno valor
            }
            catch (Exception erro)
            {
                throw new Exception(erro.Message);
            }
            finally // tanto se der erro ou nao , ele sera executado
            {
                //desconecta do banco
                conexao.Desconectar();
            }
        }
        private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                ModeloCompra modelo = new ModeloCompra();
                modelo.Com_data      = dateCompra.Value;
                modelo.Com_nfiscal   = Convert.ToInt32(txtNotaFiscal.Text);
                modelo.Com_nparcelas = Convert.ToInt32(cbParcelas.Text);
                modelo.Com_status    = "EFE";
                modelo.For_cod       = Convert.ToInt32(textBox2.Text);
                modelo.Tpa_cod       = Convert.ToInt32(cbPagamento.SelectedValue);
                modelo.Com_total     = Convert.ToDouble(txtTotal.Text);

                DALConexao conexao = new DALConexao(DadosDaConexao.StringDeConexao);
                BLLCompra  compra  = new BLLCompra(conexao);

                ModeloItensCompra itensCompra = new ModeloItensCompra();
                BLLItensCompra    dao         = new BLLItensCompra(conexao);

                ModeloParcelasCompra parcelasCompra = new ModeloParcelasCompra();
                BLLParcelasCompra    daoParcelas    = new BLLParcelasCompra(conexao);
                if (operacao == "inserir")
                {
                    //cadastrar uma compra
                    compra.Incluir(modelo);
                    // cadastrar os itens da compra
                    for (int i = 0; i < GridItens.RowCount; i++)
                    {
                        itensCompra.Itc_cod   = i + 1;
                        itensCompra.Com_cod   = modelo.Com_cod;
                        itensCompra.Pro_cod   = Convert.ToInt32(GridItens.Rows[i].Cells[0].Value);
                        itensCompra.Itc_qtde  = Convert.ToInt32(GridItens.Rows[i].Cells[2].Value);
                        itensCompra.Itc_valor = Convert.ToInt32(GridItens.Rows[i].Cells[3].Value);

                        dao.Inserir(itensCompra);
                    }
                    //cadastrar as parcelas
                    for (int i = 0; i < GridParcelas.RowCount; i++)
                    {
                        parcelasCompra.Com_cod       = modelo.Com_cod;
                        parcelasCompra.Pco_cod       = Convert.ToInt32(GridParcelas.Rows[i].Cells[0].Value);
                        parcelasCompra.Pco_valor     = Convert.ToDouble(GridParcelas.Rows[i].Cells[1].Value);
                        parcelasCompra.Pco_datavecto = Convert.ToDateTime(GridParcelas.Rows[i].Cells[2].Value);

                        daoParcelas.Incluir(parcelasCompra);
                    }

                    MetroFramework.MetroMessageBox.Show(this, "Compra efetuada com sucesso", "OK", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    compra.Alterar(modelo);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Exemple #17
0
        public void ParcelaCadastraAtualiza(ModeloParcelasCompra modelo)
        {
            SqlCommand cmd = new SqlCommand("[dbo].[spParcelasCompraInserir]", conexao._conexao);

            cmd.Transaction = conexao.ObjetoTransacao;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@pcocompra", modelo.parcelascompra);
            cmd.ExecuteNonQuery();
        }
Exemple #18
0
        public void Excluir(ModeloParcelasCompra modelo)
        {
            SqlCommand cmd = new SqlCommand("[dbo].[spParcelasCompraExcluir]", conexao._conexao);

            cmd.Transaction = conexao.ObjetoTransacao;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@pco_cod", modelo.pco_cod);
            cmd.Parameters.AddWithValue("@comcod", modelo.com_cod);
            cmd.ExecuteNonQuery();
        }
Exemple #19
0
        public void Excluir(ModeloParcelasCompra modelo)
        {
            double pcovalor = modelo.pco_valor;

            modelo.pco_valor = 0;
            ValidaCampos(modelo);
            modelo.pco_valor = pcovalor;
            DALParcelasCompra DALObj = new DALParcelasCompra(conexao);

            DALObj.Excluir(modelo);
        }
        //METEDO EXCLUIR
        public void Excluir(ModeloParcelasCompra modelo)
        {
            if (modelo.Pco_cod <= 0)
            {
                throw new Exception("o codigo da parcela é obrigatorio");
            }
            if (modelo.Com_cod <= 0)
            {
                throw new Exception("o codigo da compra é obrigatorio");
            }
            DALParcelasCompra compra = new DALParcelasCompra(Conexao);

            compra.Excluir(modelo);
        }
        public void Excluir(ModeloParcelasCompra modelo)
        {
            if (modelo.pco_cod <= 0)
            {
                throw new Exception("O código da Parcela é obrigatório!");
            }
            if (modelo.com_cod <= 0)
            {
                throw new Exception("O código da compra é obrigatório!");
            }
            DAOParcelaCompra daopar = new DAOParcelaCompra(conexao);

            daopar.Excluir(modelo);
        }
        public void Excluir(ModeloParcelasCompra modelo)
        {
            SqlCommand cmd = new SqlCommand();

            cmd.Connection  = conexao.ObjetoConexao;
            cmd.Transaction = conexao.ObjetoTransacao;
            cmd.CommandText = "delete from parcelascompra " +
                              "where pco_cod = @pco_cod and com_cod = @com_cod;";
            cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
            cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
            //conexao.Conectar();
            cmd.ExecuteNonQuery();
            //conexao.Desconectar();
        }
        public void Excluir(ModeloParcelasCompra modelo)
        {
            if (modelo.PcoCod <= 0)
            {
                throw new Exception("O código da parcela é obrigatório");
            }

            if (modelo.ComCod <= 0)
            {
                throw new Exception("O código da compra é obrigatório");
            }
            DALParcelasCompra DALobj = new DALParcelasCompra(conexao);
            DALobj.Excluir(modelo);
        }
Exemple #24
0
        public void Excluir(ModeloParcelasCompra modelo)
        {
            if (modelo.PcoCod <= 0)
            {
                MessageBox.Show("O código da parcelas é obrigatório !");
            }
            if (modelo.ComCod <= 0)
            {
                MessageBox.Show("O código da compra é obrigatório !");
            }

            DALparcelasCompra parcelasCompra = new DALparcelasCompra(conexao);

            parcelasCompra.GetExcluir(modelo);
        }
Exemple #25
0
        //=============================================================================================================================================================
        //Metodo para incluir
        public void Incluir(ModeloParcelasCompra modelo) //https://youtu.be/Y_D6dfyMAYs?t=409
        {
            try
            {
                SqlCommand cmd = new SqlCommand();         // criar um comando SQL
                cmd.Connection  = conexao.ObjetoConexao;   // Definir a conexão
                cmd.Transaction = conexao.ObjetoTransacao; //https://youtu.be/fA_T1ywEXqw?t=904

                //criar a query para o insert do nome da categoria, utlizando parametro @nome,
                cmd.CommandText = "INSERT INTO parcelascompra (pco_cod, com_cod, pco_datavecto, pco_valor ) " +
                                  "VALUES (@pco_cod, @com_cod, @pco_datavecto, @pco_valor)"; //o selelct retorno

                //adiciona o valor da variavel ao parametro
                cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
                cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
                cmd.Parameters.AddWithValue("@pco_valor", modelo.PcoValor);
                //data de vencimento: ja trata tipo de valor SQL
                cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.DateTime);
                //Valida data de vencimento, se informado ou não: // https://youtu.be/Y_D6dfyMAYs?t=1506
                if (modelo.PcoDatavecto == null)                           //se nao informar a data,
                {
                    cmd.Parameters["@pco_datavecto"].Value = DBNull.Value; //parametro data recebe valor null
                }
                else
                {
                    cmd.Parameters["@pco_datavecto"].Value = modelo.PcoDatavecto;
                }

                //conecta ao banco
                //conexao.Conectar();
                //recebe o valor retornado pelo selecat identity
                //cmd.ExecuteScalar();//ExecuteScalar = quando quer retornor poucs informações da consulta
                //ou: https://youtu.be/uRVZ8LXnQ2M?list=PLfvOpw8k80Wqj1a66Qsjh8jj4hlkzKSjA&t=498
                cmd.ExecuteNonQuery();
            }
            catch (Exception erro)
            {
                throw new Exception(erro.Message);
            }
            finally // tanto se der erro ou nao , ele sera executado
            {
                //desconecta do banco
                //conexao.Desconectar();
            }
        }
Exemple #26
0
        //Metodo para alterar ===================================================================
        public void Alterar(ModeloParcelasCompra modelo) // https://youtu.be/Y_D6dfyMAYs?t=943
        {
            try
            {
                SqlCommand cmd = new SqlCommand();      // criar um comando SQL
                cmd.Connection = conexao.ObjetoConexao; // Definir a conexão

                //criar a query para o update no nome da catagoria, utlizando valor do parametro @nome, onde o cat_Cod for igual ao codigo
                cmd.CommandText = "UPDATE parcelascompra SET pco_valor = @pco_valor, pco_datavecto = @pco_datavecto, " +
                                  "pco_datapagto = @pco_datapagto WHERE pco_cod = @pco_cod AND com_cod = @com_cod;";

                //------------------------------------------------------------------------------------------------------------------------------------
                //adiciona o valor da variavel ao parametro
                //------------------------------------------------------------------------------------------------------------------------------------
                cmd.Parameters.AddWithValue("@pco_cod", modelo.PcoCod);
                cmd.Parameters.AddWithValue("@com_cod", modelo.ComCod);
                cmd.Parameters.AddWithValue("@pco_valor", modelo.PcoValor);
                cmd.Parameters.Add("@pco_datavecto", System.Data.SqlDbType.DateTime);
                cmd.Parameters["@pco_datavecto"].Value = modelo.PcoDatavecto;//armazena a data no parametro

                cmd.Parameters.Add("@pco_datapagto", System.Data.SqlDbType.DateTime);
                //Valida data de pagamento, se informado ou não:
                if (modelo.PcoDatapagto == null)                           //se nao informar a data,
                {
                    cmd.Parameters["@pco_datapagto"].Value = DBNull.Value; //parametro data recebe valor null
                }
                else
                {
                    cmd.Parameters["@pco_datapagto"].Value = modelo.PcoDatapagto;
                }

                //conecta ao banco
                conexao.Conectar();
                cmd.ExecuteNonQuery(); //ExecuteNonQuery = quando não quer ou nao vai retornor informações da consulta
            }
            catch (Exception erro)
            {
                throw new Exception(erro.Message);
            }
            finally // tanto se der erro ou nao , ele sera executado
            {
                //desconecta do banco
                conexao.Desconectar();
            }
        }
Exemple #27
0
        //==============================================================================================================================
        //Metodo para Excluir uma parcela
        public void Excluir(ModeloParcelasCompra modelo)//recebe o modelo como parametro
        {
            //Validação campo nao pode ser vazio
            if (modelo.PcoCod <= 0)                                       //se o tamanho do texto for igual a zero ...
            {
                throw new Exception("O codigo da parcela é obrigatório"); // cria uma exceção, e retornar a mensagem obrigando
            }

            if (modelo.ComCod <= 0)
            {
                throw new Exception("O codigo da compra é obrigatório");
            }

            //sem validação , pois se o codigo informado nao existir, nao vai fazer nada
            DALParcelasCompra DALobj = new DALParcelasCompra(conexao);

            DALobj.Excluir(modelo);
        }
        //METEDO INCLUIR
        public void Incluir(ModeloParcelasCompra modelo)
        {
            if (modelo.Pco_cod <= 0)
            {
                throw new Exception("o codigo da parcela é obrigatorio");
            }
            if (modelo.Pco_valor <= 0)
            {
                throw new Exception("o valor da parcela é obrigatorio");
            }
            DateTime data = DateTime.Now;

            if (modelo.Pco_datavecto.Year < data.Year)
            {
                throw new Exception("a data de pagamento da parcela é obrigatorio");
            }
            DALParcelasCompra compra = new DALParcelasCompra(Conexao);

            compra.Incluir(modelo);
        }
Exemple #29
0
        //==============================================================================================================================
        //Metodo para incluir
        public void Incluir(ModeloParcelasCompra modelo) //https://youtu.be/4FrqeIDgPaQ?list=PLfvOpw8k80Wqj1a66Qsjh8jj4hlkzKSjA
        {
            //Validação campo nao pode ser vazio
            if (modelo.PcoCod <= 0)                                       //se o tamanho do texto for igual a zero ...
            {
                throw new Exception("O codigo da parcela é obrigatório"); // cria uma exceção, e retornar a mensagem obrigando
            }

            if (modelo.ComCod <= 0)
            {
                throw new Exception("O codigo da compra é obrigatório");
            }

            //valdação campo valor:
            if (modelo.PcoValor <= 0)
            {
                throw new Exception("O valor da parcela é obrigatório");
            }

            //criar validação para data de vencimento
            //pegar a data atual:
            DateTime Data = DateTime.Now;

            if (modelo.PcoDatavecto.Year < Data.Year)
            {
                throw new Exception("Ano de vencimento inferior ao ano atual");
            }
            if (modelo.PcoDatavecto == null)
            {
                throw new Exception("A data de vencimento da parcela é obrigatório");
            }

            // criar validação para nao deixar por vencimento anterior a data da compra...!!!
            // ou seja nao se pode pagar antes de comprar!!

            //cria um objeto, e informa a conexão
            DALParcelasCompra DALobj = new DALParcelasCompra(conexao);

            //manda gravar no banco as informações coletadas na tela
            DALobj.Incluir(modelo);//usa o metodo incluir
        }
Exemple #30
0
        //==============================================================================================================================
        //Metodo para alterar
        public void Alterar(ModeloParcelasCompra modelo)
        {
            //Validação campo nao pode ser vazio
            if (modelo.PcoCod <= 0)                                       //se o tamanho do texto for igual a zero ...
            {
                throw new Exception("O codigo da parcela é obrigatório"); // cria uma exceção, e retornar a mensagem obrigando
            }

            if (modelo.ComCod <= 0)
            {
                throw new Exception("O codigo da compra é obrigatório");
            }

            //valdação campo valor:
            if (modelo.PcoValor <= 0)
            {
                throw new Exception("O valor da parcela é obrigatório");
            }

            //criar validação para data de vencimento
            //pegar a data atual:
            DateTime Data = DateTime.Now;

            if (modelo.PcoDatavecto.Year < Data.Year)
            {
                throw new Exception("Ano de vencimento inferior ao ano atual");
            }
            if (modelo.PcoDatavecto == null)
            {
                throw new Exception("A data de vencimento da parcela é obrigatório");
            }

            // criar validação para nao deixar por vencimento anterior a data da compra...!!!
            // ou seja nao se pode pagar antes de comprar!!

            //cria um objeto, e informa a conexão
            DALParcelasCompra DALobj = new DALParcelasCompra(conexao);

            //manda Alterar no banco conforme as informações coletadas na tela
            DALobj.Alterar(modelo);
        }