コード例 #1
0
        public frmProduto()
        {
            InitializeComponent();

            InicializeBotoes(EnumTipoDeForm.Cadastro);
            _tipoDoForm             = EnumTipoDeForm.Cadastro;
            cbStatus.Text           = "Ativo";
            txtCodigo.Text          = "Novo";
            cbVigencia.Enabled      = false;
            txtLineVigencia.Enabled = false;
        }
コード例 #2
0
        private void btnCancelarExcluir_Click_1(object sender, EventArgs e)
        {
            switch (_switchBotaoCancelarExcluir)
            {
            case EnumBotoesForm.Cancelar:
                InicializeBotoes(EnumTipoDeForm.Detalhamento);
                _tipoDoForm = EnumTipoDeForm.Detalhamento;

                Produto produto;
                using (var servicoDeProduto = new ServicoDeProduto())
                {
                    produto = servicoDeProduto.Consulte(int.Parse(txtCodigo.Text.Trim()));
                }

                CarregueControlesComObjeto(produto);
                DesabiliteControles();
                cbVigencia.Enabled      = true;
                txtLineVigencia.Enabled = true;
                CarregueComboDeVigencias(produto.Codigo);
                SelecioneUltimaVigencia();
                break;

            case EnumBotoesForm.Excluir:
                var resultado = MessageBox.Show(Mensagens.TEM_CERTEZA_QUE_DESEJA_EXCLUIR_ESSE_X("produto"), "Confirmação", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                if (resultado == DialogResult.Yes)
                {
                    var codigoDoProduto = int.Parse(txtCodigo.Text);

                    var listaDeInconsistenciasExclusao = new List <Inconsistencia>();
                    using (var servicoDeProduto = new ServicoDeProduto())
                    {
                        listaDeInconsistenciasExclusao = servicoDeProduto.Exclua(codigoDoProduto);
                    }

                    if (listaDeInconsistenciasExclusao.Count == 0)
                    {
                        MessageBox.Show(Mensagens.O_X_FOI_EXCLUIDO_COM_SUCESSO("produto"));
                        this.Close();
                    }
                    else
                    {
                        foreach (var inconsistencia in listaDeInconsistenciasExclusao)
                        {
                            MessageBox.Show(inconsistencia.Mensagem);
                        }
                    }
                }
                else if (resultado == DialogResult.No)
                {
                    // Não faz nada
                }
                break;
            }
        }
コード例 #3
0
        public frmProduto(Produto produto)
        {
            InitializeComponent();

            InicializeBotoes(EnumTipoDeForm.Detalhamento);
            _tipoDoForm = EnumTipoDeForm.Detalhamento;

            CarregueControlesComObjeto(produto);
            CarregueComboDeVigencias(produto.Codigo);
            SelecioneUltimaVigencia();
            DesabiliteControles();
        }
コード例 #4
0
        private void btnEditarSalvar_Click(object sender, EventArgs e)
        {
            switch (_switchBotaoEditarSalvar)
            {
            case EnumBotoesForm.Editar:
                HabiliteControles();
                InicializeBotoes(EnumTipoDeForm.Edicao, ref btnEditarSalvar, ref btnCancelarExcluir, ref _switchBotaoEditarSalvar, ref _switchBotaoCancelarExcluir);
                _tipoDoForm = EnumTipoDeForm.Edicao;
                break;

            case EnumBotoesForm.Salvar:
                var interacao = CarregueObjetoComControles();

                // Valida entradas sem valores
                // Ver pra colocar no validador
                if (((EnumTipoDeInteracao)cbTipo.SelectedIndex + 1) == EnumTipoDeInteracao.ENTRADA &&
                    GStxtValor.Valor == 0)
                {
                    var resultado = MessageBox.Show(Mensagens.TEM_CERTEZA_QUE_QUER_DAR_ENTRADA_SEM_VALOR(), "Confirmação", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                    if (resultado == DialogResult.Yes)
                    {
                        //Não faz nada
                    }
                    else if (resultado == DialogResult.No)
                    {
                        GStxtValor.Focus();
                        return;
                    }
                }

                var horario = DateTime.Now;
                //txtHorario.Text = horario.ToString(Cultura);

                using (var servicoDeInteracao = new ServicoDeInteracao())
                {
                    _listaDeInconsistencias = servicoDeInteracao.Salve(interacao, _tipoDoForm, horario);
                }

                if (_listaDeInconsistencias.Count == 0)
                {
                    MessageBox.Show(Mensagens.X_FOI_CADASTRADO_COM_SUCESSO("Entrada/Saída"));
                    InicializeBotoes(EnumTipoDeForm.Detalhamento, ref btnEditarSalvar, ref btnCancelarExcluir, ref _switchBotaoEditarSalvar, ref _switchBotaoCancelarExcluir);
                    _tipoDoForm = EnumTipoDeForm.Edicao;
                    DesabiliteControles();
                    return;
                }

                InicializeInconsistencias();
                break;
            }
        }
コード例 #5
0
        private void btnEditarSalvar_Click_1(object sender, EventArgs e)
        {
            switch (_switchBotaoEditarSalvar)
            {
            case EnumBotoesForm.Editar:
                HabiliteControles();
                cbVigencia.SelectedIndex = -1;
                cbVigencia.Enabled       = false;
                txtLineVigencia.Enabled  = false;

                txtCodigo.Enabled     = false;
                txtLineCodigo.Enabled = false;
                InicializeBotoes(EnumTipoDeForm.Edicao);
                _tipoDoForm = EnumTipoDeForm.Edicao;
                break;

            case EnumBotoesForm.Salvar:
                if (string.IsNullOrEmpty(txtCodigo.Text) || txtCodigo.Text == "Novo")
                {
                    PreenchaCodigoComProximoDisponivel();
                }

                var produto = CarregueObjetoComControles();

                var listaDeInconsistencias = new List <Inconsistencia>();

                using (var servicoDeProduto = new ServicoDeProduto())
                    listaDeInconsistencias = servicoDeProduto.Salve(produto, _tipoDoForm);

                if (listaDeInconsistencias.Count == 0)
                {
                    MessageBox.Show(Mensagens.X_FOI_CADASTRADO_COM_SUCESSO("Produto"));
                    InicializeBotoes(EnumTipoDeForm.Detalhamento);
                    _tipoDoForm = EnumTipoDeForm.Edicao;
                    DesabiliteControles();
                    CarregueComboDeVigencias(produto.Codigo);
                    SelecioneUltimaVigencia();
                    cbVigencia.Enabled      = true;
                    txtLineVigencia.Enabled = true;
                    return;
                }

                foreach (var inconsistencia in listaDeInconsistencias)
                {
                    MessageBox.Show(inconsistencia.Mensagem);
                    //Invoke metodo para destacar o form, ou então fazer um destaque automático
                }
                break;
            }
        }
コード例 #6
0
        private void btnCancelarExcluir_Click(object sender, EventArgs e)
        {
            switch (_switchBotaoCancelarExcluir)
            {
            case EnumBotoesForm.Cancelar:
                InicializeBotoes(EnumTipoDeForm.Detalhamento, ref btnEditarSalvar, ref btnCancelarExcluir, ref _switchBotaoEditarSalvar, ref _switchBotaoCancelarExcluir);
                _tipoDoForm = EnumTipoDeForm.Detalhamento;

                Interacao interacao;
                using (var servicoDeInteracao = new ServicoDeInteracao())
                {
                    interacao = servicoDeInteracao.Consulte(_codigoInteracao);
                }

                CarregueControlesComObjeto(interacao);
                DesabiliteControles();
                break;

            case EnumBotoesForm.Excluir:
                var resultado = MessageBox.Show($"Tem certeza que deseja excluir essa interação?", "Confirmação", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                if (resultado == DialogResult.Yes)
                {
                    using (var servicoDeInteracao = new ServicoDeInteracao())
                    {
                        var inconsistencias = servicoDeInteracao.Exclua(_codigoInteracao);

                        if (inconsistencias.Count > 0)
                        {
                            foreach (var inconsitencia in inconsistencias)
                            {
                                MessageBox.Show(inconsitencia.Mensagem);
                            }
                        }
                        else
                        {
                            MessageBox.Show("Interação excluída com sucesso!");
                            this.Close();
                        }
                    }
                }
                break;
            }
        }
コード例 #7
0
        private void InicializeBotoes(EnumTipoDeForm tipoDeForm)
        {
            switch (tipoDeForm)
            {
            case EnumTipoDeForm.Cadastro:
                btnCancelarExcluir.Enabled = false;
                btnCancelarExcluir.Visible = false;

                txtLineQuantidadeEstoque.Enabled = false;
                txtQuantidadeEmEstoque.Enabled   = false;

                btnEditarSalvar.Image    = Properties.Resources.floppy_icon;
                _switchBotaoEditarSalvar = EnumBotoesForm.Salvar;
                break;

            case EnumTipoDeForm.Edicao:
                btnCancelarExcluir.Enabled  = true;
                btnCancelarExcluir.Visible  = true;
                btnCancelarExcluir.Image    = Properties.Resources.cancel_icon;
                _switchBotaoCancelarExcluir = EnumBotoesForm.Cancelar;

                btnEditarSalvar.Image    = Properties.Resources.floppy_icon;
                _switchBotaoEditarSalvar = EnumBotoesForm.Salvar;

                txtLineQuantidadeEstoque.Enabled = true;
                txtQuantidadeEmEstoque.Enabled   = true;

                break;

            case EnumTipoDeForm.Detalhamento:
                btnCancelarExcluir.Enabled  = true;
                btnCancelarExcluir.Visible  = true;
                btnCancelarExcluir.Image    = Properties.Resources.delete;
                _switchBotaoCancelarExcluir = EnumBotoesForm.Excluir;

                btnEditarSalvar.Image    = Properties.Resources.edit_512;
                _switchBotaoEditarSalvar = EnumBotoesForm.Editar;
                break;
            }

            btnEditarSalvar.Refresh();
            btnCancelarExcluir.Refresh();
        }
コード例 #8
0
        public List <Inconsistencia> Salve(Produto produto, EnumTipoDeForm tipoDoForm)
        {
            var listaDeInconsistencias = new List <Inconsistencia>();

            if (tipoDoForm == EnumTipoDeForm.Cadastro)
            {
                using (var validadorDeProduto = new ValidadorDeProduto())
                {
                    listaDeInconsistencias = validadorDeProduto.ValideCadastroInicial(produto);
                }

                if (listaDeInconsistencias.Count > 0)
                {
                    return(listaDeInconsistencias);
                }
            }

            using (var validadorDeProduto = new ValidadorDeProduto())
            {
                listaDeInconsistencias = validadorDeProduto.ValideSalvar(produto);
            }

            if (listaDeInconsistencias.Count == 0)
            {
                using (var mapeadorDeProduto = new RepositorioDeProduto())
                {
                    mapeadorDeProduto.Insira(produto);

                    if (tipoDoForm == EnumTipoDeForm.Cadastro)
                    {
                        mapeadorDeProduto.InsiraNaTabelaQuantidade(produto.Codigo);
                    }

                    if (tipoDoForm == EnumTipoDeForm.Edicao)
                    {
                        AltereQuantidadeDeProduto(produto.Codigo, produto.QuantidadeEmEstoque);
                    }
                }
            }

            return(listaDeInconsistencias);
        }
コード例 #9
0
        protected void InicializeBotoes(EnumTipoDeForm tipoDeForm,
                                        ref PictureBox btnEditarSalvar,
                                        ref PictureBox btnCancelarExcluir,
                                        ref EnumBotoesForm switchBotaoEditarSalvar,
                                        ref EnumBotoesForm switchBotaoCancelarExcluir)
        {
            switch (tipoDeForm)
            {
            case EnumTipoDeForm.Cadastro:
                btnCancelarExcluir.Enabled = false;
                btnCancelarExcluir.Visible = false;

                btnEditarSalvar.Image   = Properties.Resources.floppy_icon;
                switchBotaoEditarSalvar = EnumBotoesForm.Salvar;
                break;

            case EnumTipoDeForm.Edicao:
                btnCancelarExcluir.Enabled = true;
                btnCancelarExcluir.Visible = true;
                btnCancelarExcluir.Image   = Properties.Resources.cancel_icon;
                switchBotaoCancelarExcluir = EnumBotoesForm.Cancelar;

                btnEditarSalvar.Image   = Properties.Resources.floppy_icon;
                switchBotaoEditarSalvar = EnumBotoesForm.Salvar;
                break;

            case EnumTipoDeForm.Detalhamento:
                btnCancelarExcluir.Enabled = true;
                btnCancelarExcluir.Visible = true;
                btnCancelarExcluir.Image   = Properties.Resources.delete;
                switchBotaoCancelarExcluir = EnumBotoesForm.Excluir;

                btnEditarSalvar.Image   = Properties.Resources.edit_512;
                switchBotaoEditarSalvar = EnumBotoesForm.Editar;
                break;
            }

            btnEditarSalvar.Refresh();
            btnCancelarExcluir.Refresh();
        }
コード例 #10
0
        public List <Inconsistencia> Salve(Interacao interacao, EnumTipoDeForm tipoDoForm, DateTime horario)
        {
            var listaDeInconsistencias = new List <Inconsistencia>();

            using (var validadorDeInteracao = new ValidadorDeInteracao())
            {
                listaDeInconsistencias = validadorDeInteracao.Valide(interacao);
            }

            if (listaDeInconsistencias.Count == 0)
            {
                using (var mapeadorDeInteracao = new RepositorioDeInteracao())
                    using (var mapeadorDeNumeroDeSerie = new RepositorioDeNumeroDeSerie())
                        using (var servicoDeProduto = new ServicoDeProduto())
                        {
                            interacao.Horario = horario;
                            interacao.Codigo  = mapeadorDeInteracao.ObtenhaProximoCodigoDisponivel();
                            mapeadorDeInteracao.Insira(interacao);

                            foreach (var numeroDeSerie in interacao.NumerosDeSerie)
                            {
                                mapeadorDeNumeroDeSerie.Insira(numeroDeSerie, interacao.Codigo, interacao.Produto.Codigo);
                            }

                            int quantidadeInterada    = 0;
                            int quantidadeInteradaAux = 0;
                            switch (interacao.TipoDeInteracao)
                            {
                            case EnumTipoDeInteracao.ENTRADA:
                                quantidadeInterada = interacao.QuantidadeInterada;
                                break;

                            case EnumTipoDeInteracao.SAIDA:
                                quantidadeInterada = interacao.QuantidadeInterada * (-1);
                                break;

                            case EnumTipoDeInteracao.BASE_DE_TROCA:
                                // Entrada
                                quantidadeInterada = interacao.QuantidadeInterada;

                                // Saída
                                quantidadeInteradaAux = interacao.QuantidadeAuxiliar.GetValueOrDefault() * (-1);
                                break;
                            }

                            var produtoConsultado = servicoDeProduto.Consulte(interacao.Produto.Codigo);

                            // Nesse caso atualizamos o produto com o novo valor
                            if (interacao.AtualizarValorDoProdutoNoCatalogo)
                            {
                                var valorDoProduto = interacao.TipoDeInteracao == EnumTipoDeInteracao.ENTRADA
                                           ? produtoConsultado.PrecoDeCompra
                                           : produtoConsultado.PrecoDeVenda;

                                // Só devemos criar uma nova vigência, caso o valor seja diferente, senão é desnecessário
                                if (interacao.ValorInteracao != valorDoProduto)
                                {
                                    if (interacao.TipoDeInteracao == EnumTipoDeInteracao.ENTRADA)
                                    {
                                        produtoConsultado.PrecoDeCompra = interacao.ValorInteracao;

                                        produtoConsultado.PrecoDeVenda = Math.Round(produtoConsultado.PrecoDeCompra * (1 + produtoConsultado.PorcentagemDeLucro), 2);
                                    }
                                    else
                                    {
                                        produtoConsultado.PrecoDeVenda = interacao.ValorInteracao;
                                    }

                                    servicoDeProduto.Salve(produtoConsultado, EnumTipoDeForm.Edicao);
                                }
                            }

                            servicoDeProduto.AltereQuantidadeDeProduto(produtoConsultado.Codigo,
                                                                       produtoConsultado.QuantidadeEmEstoque + quantidadeInterada + quantidadeInteradaAux);
                        }
            }

            return(listaDeInconsistencias);
        }