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);
        }
		private void AtribuirPessoa(Entidades.Pessoa.Pessoa pessoa)
		{
			lock (this)
			{
                Primária = pessoa.Nome;

                if (pessoa.Região != null)
                    AlterarTextoFonte(lblMeio, pessoa.Região.Nome, TAMANHO_MÁXIMO_CARACTERES_REGIÃO);

                List<Entidades.Pessoa.Endereço.Endereço> endereços
                   = pessoa.Endereços.ExtrairElementos();

                if (endereços.Count != 0
                    && (endereços[0].Localidade != null)
                    && (endereços[0].Localidade.Estado != null))
                {
                    Secundária = endereços[0].Localidade.Nome + " / " + endereços[0].Localidade.Estado.Sigla;
                }
			
                this.pessoa = pessoa;

                pnlÍcone.BackgroundImage = ControladorÍconePessoa.ObterÍconeComFundoECódigo(pessoa);
			}
		}
Example #3
0
        /// <summary>
        /// Obtém pedidos de um cliente.
        /// </summary>
        public static Pedido[] ObterPedidosRecebidos(Pessoa.Pessoa cliente, DateTime início, DateTime fim, bool períodoPrevisão, bool ocultarJáEntregues, bool apenasPedidos)
        {
            string inicio = início.Date == DateTime.MinValue ? "'null'" : DbTransformar(início.Date);

            if (fim != DateTime.MaxValue)
                fim = fim.Date.AddDays(1);

            Pedido[] pedidos = Mapear<Pedido>(
                string.Format(
                "SELECT * FROM pedido WHERE " + (períodoPrevisão ? "dataPrevisao" : "dataRecepcao")
                + " BETWEEN {0} AND {1} AND (cliente = {2} OR representante = {2}) "
                + (ocultarJáEntregues ? "AND dataEntrega is null " : " ") 
                + "AND tipo = " + (apenasPedidos ? "'E'" : "'C'")
                + " order by dataRecepcao",
                inicio, DbTransformar(fim.Date),
                DbTransformar(cliente.Código))).ToArray();

            PreencherObservaçõesDosItens(pedidos);
            return pedidos;
        }
Example #4
0
        /// <summary>
        /// Obtém pedidos de um cliente.
        /// </summary>
        public static Pedido[] ObterPedidos(Pessoa.Pessoa cliente)
        {
            Pedido[] pedidos = Mapear<Pedido>(
                string.Format(
                "SELECT * FROM pedido WHERE cliente = {0} order by dataRecepcao",
                DbTransformar(cliente.Código))).ToArray();

            PreencherObservaçõesDosItens(pedidos);
            return pedidos;
        }
		/// <summary>
		/// Atribui ao item uma pessoa-física.
		/// </summary>
		/// <param name="pessoa">Pessoa-física.</param>
		private void AtribuirPessoa(PessoaFísica pessoa)
		{
			lock (this)
			{
				lblPrimária.Text   = pessoa.Nome;
				lblSecundária.Text = "CPF: " + pessoa.CPF
					+ "\nRG: " + pessoa.DI + " (" + pessoa.DIEmissor + ")";
				lblDescrição.Text  = pessoa.Setor.Nome;
				this.pessoa        = pessoa;

                //if (pessoa.Foto != null)
                //    picFoto.Image = pessoa.Foto;
			}
		}
Example #6
0
 public static Telefone[] ObterTelefones(Pessoa pessoa)
 {
     return Mapear<Telefone>(
         "SELECT * FROM telefone WHERE pessoa = " + DbTransformar(pessoa.Código)).ToArray();
 }
Example #7
0
        /// <summary>
        /// Obtém vetor de itens de histórico de uma pessoa,
        /// ordenado pela data.
        /// </summary>
        public static Histórico[] ObterHistórico(Pessoa pessoa, TipoAlerta alerta)
        {
            string strAlerta;

            switch (alerta)
            {
                case TipoAlerta.Pedido:
                    strAlerta = "alertarConserto";
                    break;

                case TipoAlerta.Correio:
                    strAlerta = "alertarCorreio";
                    break;

                case TipoAlerta.Saída:
                    strAlerta = "alertarSaida";
                    break;

                case TipoAlerta.Venda:
                    strAlerta = "alertarVenda";
                    break;

                default:
                    throw new NotSupportedException();
            }

            return Mapear<Histórico>(
                "SELECT * FROM historico WHERE pessoa = "
                + DbTransformar(pessoa.Código)
                + " AND " + strAlerta + " = 1"
                + " ORDER BY data").ToArray();
        }
Example #8
0
 public static bool ÉRepresentante(Pessoa pessoa)
 {
     return Representantes.ContainsKey(pessoa.Código);
 }
 /// <summary>
 /// Define atribuição para uma pessoa.
 /// </summary>
 /// <param name="pessoa">Pessoa a ser classificada.</param>
 /// <param name="atribuído">Se a pessoa será classificada ou não.</param>
 public void DefinirAtribuição(Pessoa pessoa, bool atribuído)
 {
     if (atribuído)
         pessoa.Classificações |= Flag;
     else
         pessoa.Classificações &= ~Flag;
 }
 /// <summary>
 /// Verifica se esta classificação está atribuída
 /// a uma pessoa.
 /// </summary>
 /// <param name="pessoa">Pessoa que será verificada.</param>
 /// <returns>Se encontra-se atribuída.</returns>
 public bool AtribuídoA(Pessoa pessoa)
 {
     return (pessoa.Classificações & Flag) > 0;
 }
Example #11
0
 private void NotificarEventoSelecionadoSeNecessário()
 {
     if (Selecionado != null && Pessoa != null && Válido && Pessoa != últimaPessoaSelecionada)
     {
         últimaPessoaSelecionada = Pessoa;
         Selecionado(this, EventArgs.Empty);
     }
 }
Example #12
0
		/// <summary>
		/// Reconstruir lista de auto-complete
		/// </summary>
		private void txt_TextChanged(object sender, System.EventArgs e)
		{
            if (TxtChanged != null)
                TxtChanged(sender, e);

 			// Verificar se inicia pesquisa
			if (txt.Focused && !travar && !desligarPesquisa && lista != null)
			{
                if (txt.Text.Length == 0)
                {
                    lista.Visible = false;
                    pessoa = null;
                }
                else if (pessoa != null && string.Compare(pessoa.Nome, txt.Text, true) != 0)
                    pessoa = null;

                /* Movido para OnKeyUp, visto que alterações na
                 * formatação do TextBox -- provenientes do FormatadorNome --,
                 * disparam TextChanged, influenciando na marcação de tempo
                 * do Coletor.
                 * -- Júlio, 21/04/2006
                 */
			}

            if ((pessoaAnterior == null) || ((pessoa != null) && (pessoa.Código != pessoaAnterior.Código)))
            {
                if (NomeAlterado != null && Válido)
                    NomeAlterado(sender, e);
            }
		}
		/// <summary>
		/// Ocorre ao clicar em "Abrir ficha".
		/// </summary>
		private void opçãoAbrir_Click(object sender, System.EventArgs e)
		{
			DialogResult            resultado;
			Entidades.Pessoa.Pessoa entidade;

			/* Abaixo será verificado qual o tipo da pessoa. Em caso
			 * de alteração, deve-se tomar o CUIDADO com a ORDEM
			 * de verificação, pois uma classe pai responderá
			 * pelas classes filhas que estiverem após a sua verificação.
			 */

			// Funcionário
			if (Entidades.Pessoa.Funcionário.ÉFuncionário(pessoa))
			{
                AguardeDB.Mostrar();

                try
                {
                    if (!(pessoa is Funcionário))
                        pessoa = Entidades.Pessoa.Funcionário.ObterPessoa(pessoa.Código);
                }
                finally
                {
                    AguardeDB.Fechar();
                }

				using (CadastroFuncionário frm = new CadastroFuncionário((Entidades.Pessoa.Funcionário) pessoa))
				{
					resultado = frm.ShowDialog(this.ParentForm);
					entidade  = frm.Funcionário;
				}
			}
			/* Representante ou Pessoa Física
			 * 
			 * Um representante só possui um único campo inalterável (código)
			 * e, portanto, pode ser encarado como pessoa física.
			 */
			else if (pessoa is Entidades.Pessoa.PessoaFísica)
			{
                using (CadastroCliente frm = new CadastroCliente((PessoaFísica)pessoa))
				{
					resultado = frm.ShowDialog(this.ParentForm);
					entidade = frm.Pessoa;
				}
			}
			// Pessoa jurídica
            else if (pessoa is Entidades.Pessoa.PessoaJurídica)
                using (CadastroCliente frm = new CadastroCliente((PessoaJurídica)pessoa))
                {
                    resultado = frm.ShowDialog(this.ParentForm);
                    entidade = frm.Pessoa;
                }
            else if (pessoa is Entidades.Pessoa.Pessoa)
            {
                Entidades.Pessoa.PessoaJurídica juridica =
                    Entidades.Pessoa.PessoaJurídica.ObterPessoa(pessoa.Código);
                if (juridica != null)
                {
                    using (CadastroCliente frm = new CadastroCliente(juridica))
                    {
                        resultado = frm.ShowDialog(this.ParentForm);
                        entidade = frm.Pessoa;
                    }
                }
                else
                {
                    PessoaFísica fisica = PessoaFísica.ObterPessoa(pessoa.Código);

                    if (fisica != null)
                    {
                        using (CadastroCliente frm = new CadastroCliente(fisica))
                        {
                            resultado = frm.ShowDialog(this.ParentForm);
                            entidade = frm.Pessoa;
                        }
                    }
                    else
                    {
                        throw new Exception("A pessoa é do Tipo Entidades.Pessoa, porém não é física nem jurídica!");
                    }
                }
            }
            else
            {
                throw new NotSupportedException("O tipo de pessoa \"" + pessoa.GetType().Name + "\" não é suportado. Código:" + pessoa.Código.ToString());
            }

			// Atualizar dados.
            if (resultado == DialogResult.OK)
            {
                AtualizarEntidade(entidade);
            }
            else if (resultado == DialogResult.Abort)
            {
                base.SubstituirBaseParaAnterior();
            }
		}
        /// <summary>
        /// Prepara base inferior para exibição de um cliente.
        /// </summary>
        /// <param name="pessoa">Cadastro do cliente.</param>
        public void Carregar(Entidades.Pessoa.Pessoa cliente)
        {
            this.pessoa = cliente;
            classificador.Pessoa = pessoa;

            sinalizaçãoPedido.Visible = false;
            sinalizaçãoMercadoriaEmFalta.Visible = false;

            AdequarModoAtendimento();

            CarregarControlesVisuais(cliente);
            VerificarPessoaSemSetor(cliente);

            sumárioAcerto1.Carregar(cliente);
        }
        /// <summary>
        /// Obtém as pendências de um cliente.
        /// </summary>
        /// <returns>Lista encadeada contendo pendências do cliente.</returns>
        public static LinkedList<ClientePendência> ObterPendências(Pessoa cliente)
        {
            LinkedList<ClientePendência> pendências = new LinkedList<ClientePendência>();
            
            //int pagamentos;
            int pedidosProntos;
            int consertosProntos;
            
            double dívida = 0;
            int totalPagamentosPendentes = 0;

            //saídas = Relacionamento.Saída.Saída.ContarSaídasNãoAcertadas(cliente);
            //retornos = Relacionamento.Retorno.Retorno.ContarRetornosNãoAcertados(cliente);
            //pagamentos = Pagamentos.Pagamento.ContarPagamentosPendentes(cliente);
            //pedidos = Pedido.ContarPedidosPendentes(cliente);

            Pedido.ContarPedidosPendentesProntos(cliente, out pedidosProntos, out consertosProntos);
            //dívida = Dívida.ObterDívida(cliente);
            
            // Valcula valor em pagamentos pendentes.
            Entidades.Pagamentos.Pagamento[] pagamentos = 
            Entidades.Pagamentos.Pagamento.ObterPagamentos(cliente, true);
            foreach (Entidades.Pagamentos.Pagamento p in pagamentos)
            {
                dívida += 
                Entidades.Preço.Corrigir(p.ÚltimoVencimento,
                    Entidades.Configuração.DadosGlobais.Instância.HoraDataAtual,
                    p.Valor,
                    Entidades.Configuração.DadosGlobais.Instância.Juros);
            }
            totalPagamentosPendentes = pagamentos.Length;

            //if (saídas > 0)
            //    pendências.AddLast(new ClientePendência("Saídas ", saídas.ToString()));

            //if (retornos > 0)
            //    pendências.AddLast(new ClientePendência("Retornos em aberto", retornos.ToString()));

            //if (pagamentos > 0)
            //    pendências.AddLast(new ClientePendência("Pagamentos pendentes", pagamentos.ToString()));

            //if (pedidos > 0)
            //    pendências.AddLast(new ClientePendência(Identificações.Pedido, "Pedidos pendentes", pedidos.ToString()));

            if (pedidosProntos > 0)
                pendências.AddLast(new ClientePendência(Identificações.PedidoPronto, "Ped. prontos", pedidosProntos.ToString()));
             
            if (consertosProntos > 0)
                pendências.AddLast(new ClientePendência(Identificações.PedidoPronto, "Cons. prontos", consertosProntos.ToString()));


            double crédito = Entidades.Financeiro.Crédito.ObterSomaCréditos(cliente);
            if (crédito != 0)
                pendências.AddFirst(new ClientePendência("Crédito", crédito.ToString("C")));

            if (dívida > 0)
                pendências.AddFirst(new ClientePendência(totalPagamentosPendentes.ToString() + " " +
                    (totalPagamentosPendentes == 1 ? "Débito" : "Débitos"), string.Format("{0:C}", dívida), true));

            List<MercadoriaEmFaltaCliente> mercadoriasEmFalta = MercadoriaEmFaltaCliente.Obter(cliente.Código);

            if (mercadoriasEmFalta.Count > 0)
                pendências.AddFirst(new ClientePendência(Identificações.MercadoriaEmFalta, "Merc. em falta", mercadoriasEmFalta.Count.ToString(), false));

            return pendências;
        }
Example #16
0
 public static void AssegurarManipulaçãoComissãoPara(Pessoa.Pessoa comissãoPara)
 {
     if (comissãoPara == null || comissãoPara.Código != Funcionário.FuncionárioAtual.Código)
         Comissão.AssegurarPermissãoManipulaçãoComissão();
 }
		/// <summary>
		/// Constrói um item de lista com uma entidade pessoa.
		/// </summary>
		/// <param name="pessoa">Pessoa</param>
		public ListaEntidadePessoaItemBusca(Entidades.Pessoa.Pessoa pessoa) : this()
		{
			this.pessoa = pessoa;		// Necessário para comparação assíncrona
			this.Pessoa = pessoa;		// Realmente atribui os dados
		}
Example #18
0
        private static void TentaCadastrarPessoaFísica(TipoPessoaFísica tipoPessoaFísica, ref PessoaFísica entidade, CadastroPessoa janela)
        {
            bool insistir;

            do
            {
                insistir = false;

                if (janela.ShowDialog() == DialogResult.OK)
                {
                    switch (tipoPessoaFísica)
                    {
                        case TipoPessoaFísica.Outro:
                            entidade = (PessoaFísica)janela.Pessoa;
                            break;

                        case TipoPessoaFísica.Funcionário:
                            entidade = ((CadastroFuncionário)janela).Funcionário;
                            break;

                        case TipoPessoaFísica.Representante:
                            entidade = (PessoaFísica)((CadastroRepresentante)janela).Pessoa;
                            break;

                        default:
                            throw new NotSupportedException("Tipo de pessoa-física não suportado.");
                    }

                    AguardeDB.Mostrar();

                    if (entidade.CPF != null && PessoaFísica.VerificarExistênciaCPF(entidade.CPF))
                    {
                        AguardeDB.Fechar();

                        insistir = MessageBox.Show(
                            "O CPF " + entidade.CPF + " já encontra-se cadastrado no banco de dados.",
                            "Cadastro de Pessoa Física",
                            MessageBoxButtons.RetryCancel, MessageBoxIcon.Information) == DialogResult.Retry;
                    }
                    else
                    {
                        try
                        {
                            entidade.Cadastrar();
                            AguardeDB.Fechar();
                        }
                        catch (Exception e)
                        {
                            Acesso.Comum.Usuários.UsuárioAtual.RegistrarErro(e);
                            AguardeDB.Fechar();

                            insistir = MessageBox.Show(
                                "Não foi possível cadastrar a pessoa física. Por favor, verifique se os dados estão corretos.",
                                "Erro cadastrando pessoa física",
                                MessageBoxButtons.RetryCancel, MessageBoxIcon.Error) == DialogResult.Retry;
                        }
                    }
                }
            } while (insistir);
        }
Example #19
0
        public static bool ÉCliente(Pessoa pessoa)
        {
            if (Funcionário.ÉFuncionário(pessoa))
                return false;

            return !Representante.ÉRepresentante(pessoa);
        }
Example #20
0
        private static PessoaJurídica TentaCadastrarPessoaJurídica(CadastroPessoa dlg)
        {
            bool insistir;
            PessoaJurídica entidade = null;

            do
            {
                insistir = false;

                if (dlg.ShowDialog() == DialogResult.OK)
                {
                    AguardeDB.Mostrar();

                    entidade = (PessoaJurídica)dlg.Pessoa;

                    if (PessoaJurídica.VerificarExistênciaCNPJ(entidade))
                    {
                        AguardeDB.Fechar();

                        insistir = MessageBox.Show(
                            "O CNPJ " + entidade.CNPJ + " já encontra-se cadastrado no banco de dados.",
                            "Cadastro de Pessoa Jurídica",
                            MessageBoxButtons.RetryCancel, MessageBoxIcon.Information) == DialogResult.Retry;
                    }
                    else
                    {
                        try
                        {
                            entidade.Cadastrar();
                            AguardeDB.Fechar();
                        }
                        catch (Exception e)
                        {
                            Acesso.Comum.Usuários.UsuárioAtual.RegistrarErro(e);
                            AguardeDB.Fechar();

                            insistir = MessageBox.Show(
                                "Não foi possível cadastrar a pessoa jurídica. Por favor, verifique se os dados estão corretos.",
                                "Erro cadastrando pessoa jurídica",
                                MessageBoxButtons.RetryCancel, MessageBoxIcon.Error) == DialogResult.Retry;
                        }
                    }
                }
                else
                    entidade = null;
            } while (insistir);

            return entidade;
        }
Example #21
0
 public DataRelevante(Pessoa pessoa)
 {
     this.pessoa = pessoa;
 }
		/// <summary>
		/// Atribui ao item uma pessoa-jurídica.
		/// </summary>
		/// <param name="pessoa">Pessoa-jurídica.</param>
		private void AtribuirPessoa(PessoaJurídica pessoa)
		{
			lock (this)
			{
				lblPrimária.Text   = pessoa.Nome;
				lblSecundária.Text = "CNPJ: " + pessoa.CNPJ;
				lblDescrição.Text  = pessoa.Setor.Nome;
				this.pessoa        = pessoa;

                //if (pessoa.Foto != null)
                //    picFoto.Image = pessoa.Foto;
			}
		}
Example #23
0
 /// <summary>
 /// Obtém vetor de itens de histórico de uma pessoa,
 /// ordenado pela data.
 /// </summary>
 public static Histórico[] ObterHistórico(Pessoa pessoa)
 {
     return Mapear<Histórico>(
         "SELECT * FROM historico WHERE pessoa = "
         + DbTransformar(pessoa.Código)
         + " ORDER BY data").ToArray();
 }
		/// <summary>
		/// Atribui ao item uma pessoa.
		/// </summary>
		/// <param name="pessoa">Pessoa</param>
		private void AtribuirPessoa(Entidades.Pessoa.Pessoa pessoa)
		{
			lock (this)
			{
				lblPrimária.Text   = pessoa.Nome;
				lblSecundária.Text = "";
				lblDescrição.Text  = pessoa.Setor.Nome;
				this.pessoa        = pessoa;

                //if (pessoa.Foto != null)
                //    picFoto.Image  = pessoa.Foto;
			}
		}