public override void Abrir(Relacionamento relacionamento)
        {
            base.Abrir(relacionamento);

            DefinirTítulo(relacionamento);

            relacionamento.DepoisDeCadastrar += relacionamento_DepoisDeCadastrar;
        }
 private void DefinirTítulo(Relacionamento relacionamento)
 {
     título.Descrição = "";
     
     if (relacionamento.Cadastrado)
         título.Título = "Relacionar entrada nr. " + relacionamento.Código.ToString();
     else
         título.Título = "Novo documento de entrada";
 }
 private void AbreBandejas(Relacionamento relacionamento)
 {
     AguardeDB.Mostrar();
     CamposLivres = true;
     digitação.Abrir(relacionamento.Itens, relacionamento, this);
     CamposLivres = false;
     AguardeDB.Fechar();
 }
        /// <summary>
        /// Deve ser chamado para abrir a propria base inferior
        /// </summary>
        /// <exception cref="ExceçãoTabelaVazia">Ocorre quando usuário não define uma tabela para o relacionamento.</exception>
        public virtual void Abrir(Entidades.Relacionamento.Relacionamento relacionamento)
        {
            if (relacionamento == null)
                throw new NullReferenceException("Relacionamento é nulo no Abrir() do RelacionamentoBaseInferior");

            this.entidade = relacionamento;

            txtObservação.Text = relacionamento.Observações == null ? "" : relacionamento.Observações;
            AbreBandejas(relacionamento);

            RelacionamentoAcerto relacionamentoAcerto = relacionamento as RelacionamentoAcerto;

            if (relacionamentoAcerto != null)
            {
                AtualizarTravamento(relacionamentoAcerto.Travado);

                verificadorMercadoria.Enabled = relacionamentoAcerto.AcertoConsignado != null;
                verificadorMercadoria.Restringir(relacionamentoAcerto.AcertoConsignado);
                digitação.Verificador = verificadorMercadoria;

                if (relacionamentoAcerto.AcertoConsignado != null && relacionamentoAcerto.AcertoConsignado.Acertado)
                    SinalizaçãoAcertado.Sinalizar(this);
            }
        }
        private Control Construir(Relacionamento relacionamento)
        {
            LinkLabel lnk = new LinkLabel();
            lnk.Text = string.Format(
                "{0} {1}, {2:D} às {2:HH:mm}",
                tipo.ToString(),
                relacionamento.Código,
                relacionamento.Data);
            lnk.LinkBehavior = LinkBehavior.HoverUnderline;
            lnk.LinkColor = Color.Black;
            lnk.Margin = new Padding(5);
            lnk.Tag = relacionamento;
            lnk.AutoSize = true;
            lnk.Click += new EventHandler(lnk_Click);

            return lnk;
        }
        /// <summary>
        /// Dá lugar para uma nova base inferior de digitação de consignado.
        /// </summary>
        /// <param name="consignado"></param>
        public BaseEditarRelacionamento PrepararBaseConsignado(Relacionamento consignado)
        {
            BaseEditarRelacionamento novaBase = CriarBaseConsignado();

            novaBase.Abrir(consignado);
            novaBase.TravaAlterada += new BaseEditarRelacionamento.TravaAlteradaHandler(TravaAlterada);

            return novaBase;
        }
        internal void Abrir(HistóricoRelacionamento coleção, Relacionamento entidade, BaseEditarRelacionamento baseInferior)
        {
            this.baseInferior = baseInferior;
            this.coleção = coleção;
            this.entidade = entidade;

            RelacionamentoAcerto entidadeAcerto = entidade as RelacionamentoAcerto;

            /* Não permitir edição de tabela em documentos cujo
             * acerto possui tabela definida.
             */
            if (entidadeAcerto == null || entidadeAcerto.AcertoConsignado != null && 
                entidadeAcerto.AcertoConsignado.TabelaPreço != null)
            {
                bandejaAgrupada.PermitirSeleçãoTabela = false;
                bandejaHistórico.PermitirSeleçãoTabela = false;
            }

            bool acertoPossuiTabela = entidadeAcerto != null && 
                entidadeAcerto.AcertoConsignado != null && entidadeAcerto.AcertoConsignado.TabelaPreço != null;

            if (entidade.TabelaPreço == null)
            {
                if (acertoPossuiTabela)
                    entidadeAcerto.TabelaPreço = entidadeAcerto.AcertoConsignado.TabelaPreço;
                else
                    QuestionarTabelaPreço(entidadeAcerto);
            }

            // Deve-se garantir que existe uma tabelad e preço definida.
            while (entidade.TabelaPreço == null)
            {
                if (MessageBox.Show(
                    ParentForm,
                    "Por favor, escolha uma tabela de preços para iniciar a sua digitação de mercadorias.",
                    "Digitação de mercadorias",
                    MessageBoxButtons.RetryCancel, MessageBoxIcon.Warning) == DialogResult.Cancel)
                {
                    throw new ExceçãoTabelaVazia();
                }
                else
                    QuestionarTabelaPreço(entidadeAcerto);
            }

            quadroMercadoria.Tabela = entidade.TabelaPreço;
            bandejaAgrupada.Tabela = entidade.TabelaPreço;
            bandejaHistórico.Tabela = entidade.TabelaPreço;
            bandejaAgrupada.Abrir(coleção);
            bandejaHistórico.Abrir(coleção);

            entidade.AoAlterarTabela += new Acesso.Comum.DbManipulação.DbManipulaçãoHandler(AoAlterarTabelaEntidade);

            if (coleção.Count > 0)
                PermitirSeleçãoTabela = false;
            else if (entidade is Entidades.Relacionamento.Venda.Venda &&
                Entidades.Privilégio.PermissãoFuncionário.ValidarPermissão(Entidades.Privilégio.Permissão.PersonalizarVenda))
            {
                bandejaAgrupada.PermitirSeleçãoTabela = true;
                bandejaHistórico.PermitirSeleçãoTabela = true;
            }
        }
		public HistóricoRelacionamento(Relacionamento pai)
		{
            lista = new List<HistóricoRelacionamentoItem>();
            this.entidadePai = pai;
		}
        /// <summary>
        /// Garante que todas os relacionamentos possuem o mesmo índice.
        /// </summary>
        /// <param name="relacionamento">Relacionamento a ser verificado.</param>
        /// <exception cref="DocumentoInconsistente">Tabela ou índice de mercadoria inconsistente.</exception>
        private void GarantirConsitênciaPreço(Relacionamento.RelacionamentoAcerto entidade)
        {
            if (entidade.TabelaPreço == null)
                entidade.TabelaPreço = TabelaPreço;

                /* um acerto de auto atacado pega documentos de tabela diferente.
                 * andré 15/01/2008
                 */

            else if (!entidade.TabelaPreço.Equals(TabelaPreço)
                && (cliente.Setor == null || Setor.ObterSetor(SetorSistema.AltoAtacado).Código != cliente.Setor.Código))
            {
                throw new DocumentoInconsistente("A tabela de preço não é a mesma utilizada no acerto.");
            }

            /* Verificar cotação apenas para clientes do atacado, visto
             * que representantes e alto-atacadistas sempre vendem na
             * cotação vigente e saem em outra data. Para representantes,
             * a cotação da saída não é relevante.
             * 
             * Verificação de consistencia para cotaçao comentada em 3/dez/07 
             * solicitado por toninho., André.
             */
            if (cotação.HasValue && !Representante.ÉRepresentante(cliente)
                && (cliente.Setor == null || Setor.ObterSetor(SetorSistema.AltoAtacado).Código != cliente.Setor.Código))
            {
                if (entidade is Saída && ((Saída)entidade).Cotação != cotação.Value)
                {
                    if (((Saída)entidade).Cotação == 0)
                        ((Saída)entidade).Cotação = cotação.Value;
                }
                else if (entidade is Venda && ((Venda)entidade).Cotação != cotação)
                {
                    if (((Venda)entidade).Cotação == 0)
                        ((Venda)entidade).Cotação = cotação.Value;
                }
            }
        }
        /// <summary>
        /// Garante a consistência do documento adicionado com o
        /// restante do acerto.
        /// </summary>
        /// <param name="entidade">Relacionamento a ser verificado.</param>
        /// <param name="composição">Conjunto de dados a ser verificado.</param>
        /// <exception cref="DocumentoEmOutroAcerto">Documento adicionado já encontrava-se em outro acerto.</exception>
        /// <exception cref="DocumentoInconsistente">Tabela ou índice de mercadoria inconsistente.</exception>
        private void GarantirConsistênciaAdição(Relacionamento.RelacionamentoAcerto entidade, IEnumerable composição)
        {
            try
            {
                if (entidade.AcertoConsignado != null)
                    throw new DocumentoEmOutroAcerto();

                if (Acertado)
                    throw new NotSupportedException("Não é possível adicionar um documento a um acerto já finalizado.");

                GarantirConsitênciaPreço(entidade);
                GarantirConsistênciaPessoa(entidade);
            }
            catch (Exception e)
            {
                Remover(entidade);
                throw e;
            }

            Venda venda = entidade as Venda;

            entidade.AntesDeCadastrarItem += new Entidades.Relacionamento.Relacionamento.AntesDeCadastrarItemCallback(AntesDeCadastrarItemRelacionamento);
        }