// UPDATE
        //------------------------------------------------------------------------------------------------------------
        public bool UpdateEntrada(objEntrada entrada)
        {
            try
            {
                AcessoDados db = new AcessoDados();

                //--- clear Params
                db.LimparParametros();

                //--- define Params
                db.AdicionarParametros("@IDEntrada", entrada.IDEntrada);
                db.AdicionarParametros("@EntradaData", entrada.EntradaData);
                db.AdicionarParametros("@EntradaValor", entrada.EntradaValor);
                db.AdicionarParametros("@IDEntradaTipo", entrada.EntradaTipo.IDEntradaTipo);
                db.AdicionarParametros("@IDSetor", entrada.IDSetor);
                db.AdicionarParametros("@IDConta", entrada.IDConta);
                db.AdicionarParametros("@IDEntradaOrigem", entrada.EntradaOrigem.IDEntradaOrigem);
                db.AdicionarParametros("@EntradaDescricao", entrada.EntradaDescricao);

                //--- convert null parameters
                db.ConvertNullParams();

                //--- create query
                string query = db.CreateUpdateSQL("tblEntrada", "@IDEntrada");

                //--- update
                db.ExecutarManipulacao(CommandType.Text, query);
                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        // CONVERT ROW IN CLASS
        //------------------------------------------------------------------------------------------------------------
        public objEntrada ConvertRowInClass(DataRow row)
        {
            objEntrada entrada = new objEntrada((long)row["IDEntrada"])
            {
                EntradaDescricao = (string)row["EntradaDescricao"],
                EntradaData      = (DateTime)row["EntradaData"],
                EntradaValor     = (decimal)row["EntradaValor"],
                EntradaTipo      = new objEntradaTipo()
                {
                    IDEntradaTipo = (byte)row["IDEntradaTipo"],
                    EntradaTipo   = (string)row["EntradaTipo"]
                },
                IDSetor       = row["IDSetor"] == DBNull.Value ? null : (int?)row["IDSetor"],
                Setor         = row["Setor"] == DBNull.Value ? "A DEFINIR" : (string)row["Setor"],
                IDConta       = (int)row["IDConta"],
                Conta         = (string)row["Conta"],
                EntradaOrigem = new objEntradaOrigem()
                {
                    IDEntradaOrigem = (int)row["IDEntradaOrigem"],
                    OrigemDescricao = (string)row["OrigemDescricao"],
                    CNP             = (string)row["CNP"]
                },
            };

            return(entrada);
        }
        // INSERT Entrada SIMPLES
        //------------------------------------------------------------------------------------------------------------
        private long AddEntrada(objEntrada cont, AcessoDados dbTran)
        {
            try
            {
                //--- clear Params
                dbTran.LimparParametros();

                //--- define Params
                dbTran.AdicionarParametros("@EntradaData", cont.EntradaData);
                dbTran.AdicionarParametros("@EntradaValor", cont.EntradaValor);
                dbTran.AdicionarParametros("@IDEntradaTipo", cont.EntradaTipo.IDEntradaTipo);
                dbTran.AdicionarParametros("@IDSetor", cont.IDSetor);
                dbTran.AdicionarParametros("@IDConta", cont.IDConta);
                dbTran.AdicionarParametros("@IDEntradaOrigem", cont.EntradaOrigem.IDEntradaOrigem);
                dbTran.AdicionarParametros("@EntradaDescricao", cont.EntradaDescricao);

                //--- convert null parameters
                dbTran.ConvertNullParams();

                string query = dbTran.CreateInsertSQL("tblEntrada");

                //--- insert and Get new ID
                long newID = dbTran.ExecutarInsertAndGetID(query);

                return(newID);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        // INSERT
        //------------------------------------------------------------------------------------------------------------
        public long InsertEntrada(
            objEntrada cont,
            Action <int, decimal> ContaSldLocalUpdate,
            Action <int, decimal> SetorSldLocalUpdate)
        {
            AcessoDados     db      = new AcessoDados();
            long?           newID   = null;
            objMovimentacao entrada = null;

            try
            {
                db.BeginTransaction();

                //--- Check Conta Bloqueio
                if (!new ContaBLL().ContaDateBlockPermit(cont.IDConta, cont.EntradaData, db))
                {
                    throw new AppException("A Data da Conta está BLOQUEADA nesta Data de Crédito proposta...", 2);
                }

                //--- Insert Entrada
                newID = AddEntrada(cont, db);

                //--- Create NEW Entrada
                entrada = new objMovimentacao(null)
                {
                    MovTipo         = 1,
                    IDConta         = cont.IDConta,
                    IDSetor         = cont.IDSetor,
                    IDOrigem        = (long)newID,
                    Origem          = EnumMovOrigem.Entrada,
                    MovData         = cont.EntradaData,
                    MovValor        = cont.EntradaValor,
                    Consolidado     = true,
                    DescricaoOrigem = "ENTRADA: " + cont.EntradaOrigem.OrigemDescricao,
                };

                //--- Insert MOVIMENTACAO Entrada
                new MovimentacaoBLL().InsertMovimentacao(entrada, ContaSldLocalUpdate, SetorSldLocalUpdate, db);

                if (newID == 0)
                {
                    throw new Exception("Não foi possível inserir um novo registro de Entrada...");
                }

                db.CommitTransaction();
                return((long)newID);
            }
            catch (Exception ex)
            {
                db.RollBackTransaction();
                throw ex;
            }
        }
        // EXCLUIR ENTRADA
        //------------------------------------------------------------------------------------------------------------
        private void btnExcluir_Click(object sender, EventArgs e)
        {
            //--- check selected item
            if (dgvListagem.SelectedRows.Count == 0)
            {
                AbrirDialog("Favor selecionar um registro para Excluir...",
                            "Selecionar Registro", DialogType.OK, DialogIcon.Information);
                return;
            }

            //--- get Selected item
            objEntrada item = (objEntrada)dgvListagem.SelectedRows[0].DataBoundItem;

            try
            {
                // --- Ampulheta ON
                Cursor.Current = Cursors.WaitCursor;

                // --- ask USER
                var resp = AbrirDialog("Você deseja realmente EXCLUIR definitivamente a Entrada abaixo?\n" +
                                       $"\nREG: {item.IDEntrada:D4}\nDATA: {item.EntradaData.ToShortDateString()}\nVALOR: {item.EntradaValor:c}",
                                       "Excluir Entrada", DialogType.SIM_NAO, DialogIcon.Question, DialogDefaultButton.Second);

                if (resp != DialogResult.Yes)
                {
                    return;
                }

                //--- EXECUTE DELETE
                eBLL.DeleteEntrada((long)item.IDEntrada, ContaSaldoLocalUpdate, SetorSaldoLocalUpdate);

                //--- REQUERY LIST
                ObterDados();
            }
            catch (AppException ex)
            {
                AbrirDialog("A Entrada está protegida de exclusão porque:\n" +
                            ex.Message, "Bloqueio de Exclusão", DialogType.OK, DialogIcon.Exclamation);
            }
            catch (Exception ex)
            {
                AbrirDialog("Uma exceção ocorreu ao Excluir a Entrada..." + "\n" +
                            ex.Message, "Exceção", DialogType.OK, DialogIcon.Exclamation);
            }
            finally
            {
                // --- Ampulheta OFF
                Cursor.Current = Cursors.Default;
            }
        }
        // ABRIR ENTRADA ESCOLHIDA
        //------------------------------------------------------------------------------------------------------------
        private void btnVisualizar_Click(object sender, EventArgs e)
        {
            //--- check selected item
            if (dgvListagem.SelectedRows.Count == 0)
            {
                AbrirDialog("Favor selecionar um registro para Editar...",
                            "Selecionar Registro", DialogType.OK, DialogIcon.Information);
                return;
            }

            //--- get Selected item
            objEntrada item = (objEntrada)dgvListagem.SelectedRows[0].DataBoundItem;

            frmEntrada frm = new frmEntrada(item);

            frm.MdiParent = Application.OpenForms.OfType <frmPrincipal>().FirstOrDefault();
            DesativaMenuPrincipal();
            Close();
            frm.Show();
        }
Exemple #7
0
        // CONTRUCTOR CONTINUE
        //------------------------------------------------------------------------------------------------------------
        private void ConstructorContinue(objEntrada entrada)
        {
            _entrada = entrada;
            GetTipos();

            // Define Conta and Setor padrao
            contaSelected = ContaPadrao();
            setorSelected = SetorPadrao();

            // binding
            bind.DataSource = typeof(objEntrada);
            bind.Add(_entrada);
            BindingCreator();

            if (_entrada.IDEntrada == null)
            {
                Sit = EnumFlagEstado.NovoRegistro;
            }
            else
            {
                Sit = EnumFlagEstado.RegistroSalvo;
            }

            // define DEFAULT DATE
            DefineDataPadrao();

            // handlers
            _entrada.PropertyChanged += RegistroAlterado;
            HandlerKeyDownControl(this);

            txtEntradaTipo.Enter      += text_Enter;
            txtEntradaOrigem.Enter    += text_Enter;
            txtEntradaDescricao.Enter += text_Enter;

            numEntradaAno.KeyDown += Numeric_KeyDown;
            numEntradaAno.Enter   += Numeric_Enter;
            numEntradaDia.KeyDown += Numeric_KeyDown;
            numEntradaDia.Enter   += Numeric_Enter;
        }
Exemple #8
0
        private ErrorProvider EP = new ErrorProvider(); // default error provider

        #region SUB NEW | PROPERTIES

        // SUB NEW
        //------------------------------------------------------------------------------------------------------------
        public frmEntrada(objEntrada entrada)
        {
            InitializeComponent();
            ConstructorContinue(entrada);
        }