/// <summary>
        /// Ocorre ao exibir a base de dados de acerto.
        /// </summary>
        protected override void AoExibir(bool primeiraVez)
        {
            base.AoExibir();

            bool liberarPrazo = true;

            foreach (Entidades.Relacionamento.Saída.Saída saída in acerto.Saídas)
                if (!(liberarPrazo &= saída.ObterTravadoEmCache()))
                    break;

            if (liberarPrazo)
            {
                botãoLiberarPrevisão.Text = "Liberar mais prazo";
                informaçõesAcerto.PermitirAlteração = true;
                informaçõesAcerto.LiberarPrazo = false;
            }
            else
            {
                botãoLiberarPrevisão.Text = "Alterar";
                informaçõesAcerto.PermitirAlteração = false;
                informaçõesAcerto.LiberarPrazo = true;
            }

            botãoLiberarPrevisão.Visible = true;

            if (!primeiraVez)
            {
                acerto = AcertoConsignado.ObterAcerto(acerto.Código);
                listaDocumentosAcerto.Recarregar(acerto);
            }

            simulaçãoAcerto1.Carregar(acerto);
        }
        /// <summary>
        /// Obtém vendas vinculadas a um acerto.
        /// </summary>
        public static List<VendaAcerto> ObterVendas(AcertoConsignado acerto)
        {
            List<VendaAcerto> vendas = Mapear<VendaAcerto>(
                "SELECT codigo, data FROM venda WHERE acerto = " + DbTransformar(acerto.Código));

            return vendas;
        }
        public void Carregar(AcertoConsignado acerto)
        {
            this.acerto = acerto;

            if (!bg.IsBusy)
                bg.RunWorkerAsync();
        }
        public void Recarregar(AcertoConsignado acerto)
        {
            AcertoConsignado = acerto;

            exibiçãoDocumentos1.Recarregar(acerto);
            exibiçãoDocumentos2.Recarregar(acerto);
            exibiçãoDocumentos3.Recarregar(acerto);
        }
        private JanelaEscolhaAcerto(Entidades.Pessoa.Pessoa cliente, AcertoConsignado[] acertos)
        {
            InitializeComponent();

            this.pessoa = cliente;

            foreach (AcertoConsignado acerto in acertos)
                AdicionarAcerto(acerto);

            lblInstrução.Text = string.Format(
                lblInstrução.Text, cliente.Nome);
        }
        public void Recarregar(AcertoConsignado acerto)
        {
            this.acerto = acerto;

            if (!bg.IsBusy)
            {

                flowLayoutPanel.SuspendLayout();
                flowLayoutPanel.Controls.Clear();

                bg.RunWorkerAsync();
            }
        }
        private int CompararAcerto(AcertoConsignado a, AcertoConsignado b)
        {
            if (a.Previsão.HasValue && b.Previsão.HasValue)
                return a.Previsão.Value.CompareTo(b.Previsão.Value);

            else if (a.Previsão.HasValue)
                return 1;

            else if (b.Previsão.HasValue)
                return -1;

            else
                return a.DataMarcação.CompareTo(b.DataMarcação);
        }
        private ListViewItem ConstruirItem(AcertoConsignado acerto)
        {
            ListViewItem item = new ListViewItem();

            item.Text = acerto.Código.ToString();
            item.SubItems.Add(acerto.Cliente.Nome);
            item.SubItems.Add(acerto.DataMarcação.ToString("dd/MM/yyyy"));
            item.SubItems.Add(acerto.Previsão.HasValue ? acerto.Previsão.Value.ToString("dd/MM/yyyy") : "Não marcado");
            //item.SubItems.Add(acerto.CalcularValorMercadorias().ToString("C"));
            item.Group = ObterGrupo(acerto);
            item.Tag = acerto;

            return item;
        }
        /// <summary>
        /// Adiciona acerto à lista.
        /// </summary>
        private void AdicionarAcerto(AcertoConsignado acerto)
        {
            ListViewItem item = new ListViewItem();
            item.Text = acerto.Código.ToString();

            if (acerto.Previsão.HasValue)
                item.SubItems.Add(acerto.Previsão.Value.ToLongDateString());
            else
                item.SubItems.Add("Sem previsão");

            if (acerto.DataEfetiva.HasValue)
                item.ForeColor = SystemColors.GrayText;

            lstAcertos.Items.Add(item);

            item.Tag = acerto;
        }
        public void MostrarAcertos(AcertoConsignado[] value)
        {
            acertos = new List<AcertoConsignado>(value);
            acertos.Sort(new Comparison<AcertoConsignado>(CompararAcerto));

            lst.Items.Clear();
            ListViewItem[] itens = new ListViewItem[acertos.Count];

            int x = 0;

            foreach (AcertoConsignado acerto in acertos)
                itens[x++] = ConstruirItem(acerto);

            lst.Items.AddRange(itens);

            lst.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
        }
            /// <summary>
            /// Dado uma chave (ref, peso),
            /// retorna o objeto ÍndiceSaídaMercadoria, contendo a lista de indices daquela mercadoria.
            /// </summary>
            public static Dictionary<string, ÍndicesSaídaMercadoria> ObterHashÍndicesSaídas(AcertoConsignado acerto)
            {
                Dictionary<string, ÍndicesSaídaMercadoria> hash = new Dictionary<string, ÍndicesSaídaMercadoria>(StringComparer.Ordinal);

                using (IDbCommand cmd = Conexão.CreateCommand())
                {
                    cmd.CommandText = " select referencia,peso,indice from saidaitem, saida where "
                    + " saidaitem.saida=saida.codigo "
                    + " and acerto= " + acerto.Código.ToString()
                    + " group by referencia, peso, indice having sum(quantidade) > 0 ";

                    using (IDataReader leitor = cmd.ExecuteReader())
                    {
                        while (leitor.Read())
                        {
                            string referencia = leitor.GetString(0);
                            double peso = leitor.GetDouble(1);
                            double indice = Math.Round(leitor.GetDouble(2), 2);

                            string chave = GerarChave(referencia, peso);

                            ÍndicesSaídaMercadoria item = null;

                            if (!hash.TryGetValue(chave, out item))
                            {
                                item = new ÍndicesSaídaMercadoria(referencia, peso);
                                hash.Add(chave, item);
                            }

                            if (!item.Índices.Contains(indice))
                                item.Índices.Add(indice);
                        }

                        leitor.Close();
                    }
                }

                return hash;
            }
        public void Carregar(AcertoConsignado acerto)
        {
            this.acerto = acerto;

            double totalÍndiceSaída;
            double totalÍndiceVendidoMenosDevolvido;
            double totalVendaPeça;
            double porcentagemObtida;
            double porcentagemDada;

            desconto = 
            acerto.CalcularDesconto(out totalÍndiceSaída,
                out totalÍndiceVendidoMenosDevolvido,
                out totalVendaPeça,
                out porcentagemObtida,
                out porcentagemDada);

            txtDesconto.Text = desconto.ToString("C");
            txtPorcentagemVendida.Text = porcentagemObtida.ToString() + " % ";
            txtÍndiceLevado.Text = totalÍndiceSaída.ToString();
            txtÍndiceVendido.Text = totalÍndiceVendidoMenosDevolvido.ToString();
            txtÍndiceVendidoPeça.Text = totalVendaPeça.ToString();
            txtPorcentagemDesconto.Text = porcentagemDada.ToString() + " %";
        }
 internal void DefinirAcertoConsignado(AcertoConsignado value)
 {
     acertoConsignado = value;
     DefinirDesatualizado();
 }
Exemple #14
0
        /// <summary>
        /// Obtém retornos vinculados a um acerto.
        /// </summary>
        public static List<Retorno> ObterRetornos(AcertoConsignado acerto)
        {
            List<Retorno> retornos = Mapear<Retorno>(
                "SELECT * FROM retorno WHERE acerto = " + DbTransformar(acerto.Código));

            // Itens serão recuperados quando necessário.
            //RecuperarColeções(retornos);

            return retornos;
        }
 /// <summary>
 /// Dado a numeração dos documentos,
 /// recupera todas as mercadorias que compõe o acerto
 /// </summary>
 public ControleAcertoMercadorias(AcertoConsignado acerto)
 {
     this.acerto = acerto;
     this.hash = new Dictionary<string, SaquinhoAcerto>(StringComparer.Ordinal);
     Entidades.Relacionamento.Saída.Saída.ObterAcerto(CódigoSaídas, hash, acerto.FórmulaAcerto);
     Entidades.Relacionamento.Retorno.Retorno.ObterAcerto(CódigoRetornos, hash, acerto.FórmulaAcerto);
     Entidades.Relacionamento.Venda.Venda.ObterAcerto(CódigoVendas, hash, acerto.FórmulaAcerto);
 }
        /// <summary>
        /// Restringe a verificação às mercadorias relacionadas
        /// como saída para um acerto.
        /// </summary>
        /// <param name="acerto">Acerto a ser considerado.</param>
        /// <remarks>
        /// Processo realizado em segundo plano.
        /// </remarks>
        public void Restringir(AcertoConsignado acerto)
        {
            mercadorias = null;

            foreach (DigitaçãoComum controle in controles)
                DesmarcarMercadorias(controle);

            if (acerto != null)
                mercadorias = ÍndicesSaídaMercadoria.ObterHashÍndicesSaídas(acerto);


            if (ligado)
            {
                    foreach (DigitaçãoComum controle in controles)
                        MarcarMercadorias(controle);
            }
        }
        /// <summary>
        /// Cadastra novo acerto.
        /// </summary>
        private static AcertoConsignado CadastrarAcerto(Entidades.Pessoa.Pessoa pessoa, DateTime? previsão)
        {
            AcertoConsignado acerto = new AcertoConsignado();

            acerto.Previsão = previsão;
            acerto.FuncConsignado = Funcionário.FuncionárioAtual;
            acerto.Cliente = pessoa;

            return acerto;
        }
        public void Carregar(AcertoConsignado acerto)
        {
            this.acerto = acerto;

            if (Representante.ÉRepresentante(acerto.Cliente))
                opçãoLançarVendas.Enabled = false;
            else
                opçãoLançarVendas.Enabled &= !acerto.Acertado;

            opçãoZerarAcerto.Enabled &= !acerto.Acertado;
        }
Exemple #19
0
        public static List<Saída> ObterSaídas(AcertoConsignado acerto)
        {
            List<Saída> saídas = Mapear<Saída>(
                "SELECT * FROM saida WHERE acerto = " + DbTransformar(acerto.Código));

            return saídas;
        }
        private ListViewGroup ObterGrupo(AcertoConsignado acerto)
        {
            ListViewGroup grupo;

            if (!acerto.Previsão.HasValue)
                return lst.Groups[0];

            else if (!hashGrupo.TryGetValue(acerto.Previsão.Value, out grupo))
            {
                grupo = new ListViewGroup("Acerto para " + acerto.Previsão.Value.ToLongDateString());
                lst.Groups.Add(grupo);
                hashGrupo.Add(acerto.Previsão.Value, grupo);
            }

            return grupo;
        }
        private static List<AcertoConsignado> Obter(string consulta, int inicioAcertoConsignado, int inicioPessoa, int inicioPessoaFisica)
        {
            List<AcertoConsignado> lista = new List<AcertoConsignado>();
            IDataReader leitor = null;
            IDbConnection conexão = Conexão;

            lock (conexão)
            {
                using (IDbCommand cmd = conexão.CreateCommand())
                {
                    cmd.CommandText = consulta;

                    try
                    {
                        using (leitor = cmd.ExecuteReader())
                        {
                            while (leitor.Read())
                            {
                                AcertoConsignado entidade = new AcertoConsignado();
                                entidade.código = (ulong)leitor.GetInt64(inicioAcertoConsignado);

                                entidade.cliente = Pessoa.Pessoa.ObterPessoa(leitor, inicioPessoa, inicioPessoaFisica, 0);

                                entidade.funcConsignado = Funcionário.ObterPessoa((ulong)leitor.GetInt64(inicioAcertoConsignado + 2));

                                if (leitor["funcAcerto"] != DBNull.Value)
                                    entidade.funcAcerto = Funcionário.ObterPessoa((ulong)leitor.GetInt64(inicioAcertoConsignado + 3));

                                if (leitor["previsao"] != DBNull.Value)
                                    entidade.previsão = leitor.GetDateTime(inicioAcertoConsignado + 4);

                                if (leitor["dataEfetiva"] != DBNull.Value)
                                    entidade.dataEfetiva = leitor.GetDateTime(inicioAcertoConsignado + 5);

                                entidade.dataMarcação = leitor.GetDateTime(inicioAcertoConsignado + 6);

                                if (leitor["cotacao"] != DBNull.Value)
                                    entidade.cotação = leitor.GetDouble(inicioAcertoConsignado + 7);

                                entidade.fórmulaAcerto = (FórmulaAcerto)Enum.ToObject(typeof(FórmulaAcerto), leitor.GetInt32(inicioAcertoConsignado + 8));

                                entidade.DefinirCadastrado();
                                entidade.DefinirAtualizado();

                                lista.Add(entidade);
                            }
                        }
                    }
                    finally
                    {
                        if (leitor != null)
                            leitor.Close();
                    }
                }

            }

            return lista;
        }