Пример #1
0
        protected void DescadastrarEntidade(IDbCommand cmd, DbManipulação entidade)
        {
            if (!Transacionando)
                throw new NotSupportedException("Não é permitido o uso de compartilhamento de IDbCommand sem o uso do atributo \"DbTransação\".");

            entidade.MarcarTransação();

            try
            {
                entidade.DispararAntesDeDescadastrar();
                entidade.Descadastrar(cmd);
                entidade.cadastrado = false;
                entidade.atualizado = false;

                if (entidade.DepoisDeDescadastrar != null)
                    entidade.DepoisDeDescadastrar(entidade);
            }
            finally
            {
                entidade.DesmarcarTransação();
            }
        }
Пример #2
0
 private static void AoAlterarMercadoria(DbManipulação entidade)
 {
     árvore = null;
 }
Пример #3
0
 public virtual bool Referente(DbManipulação entidade)
 {
     return Equals(entidade);
 }
Пример #4
0
        public override bool Referente(DbManipulação entidade)
        {
            if (entidade is Pessoa)
                return ((Pessoa)entidade).Código == this.Código;

            return false;
        }
        public override bool Referente(DbManipulação entidade)
        {
            if (this.GetType() != entidade.GetType())
                return false;

            bool referente = true;

            foreach (FieldInfo campo in infoManipulação.ChavePrimária)
                referente &= campo.GetValue(this).Equals(campo.GetValue(entidade));

            return referente;
        }
Пример #6
0
 /// <summary>
 /// Ocorre ao alterar um débito.
 /// </summary>
 private void AoAlterarCrédito(DbManipulação entidade)
 {
     if (entidade.Cadastrado)
         entidade.Atualizar();
 }
Пример #7
0
        /// <summary>
        /// Ocorre sempre que a composição de débitos for modificada.
        /// </summary>
        private void AoAlterarItensCrédito(DbManipulação entidade)
        {
            if (!Cadastrado)
                CadastrarCapturandoErro();

            entidade.Atualizar();
        }
		public AlteraçãoChavePrimária(DbManipulação entidade) : base(entidade, "Não é possível alterar chave primária de uma entidade já cadastrada.")
		{}
		public AlteraçãoChavePrimária(DbManipulação entidade, string mensagem) : base(entidade, mensagem)
		{}
Пример #10
0
        public override bool Referente(DbManipulação entidade)
        {
            if (entidade is AcertoConsignado)
                if (((AcertoConsignado)entidade).código == código)
                    return true;

            return base.Referente(entidade);
        }
Пример #11
0
        /// <summary>
        /// Disparado antes de cadastrar uma saída.
        /// </summary>
        private void AntesDeCadastrarSaída(DbManipulação entidade, out bool cancelar)
        {
            if (!Cadastrado)
            {
                // Verificar se realmente a entidade é deste acerto.
                if (!Saídas.Contém((Saída)entidade))
                {
                    cancelar = false;
                    return;
                }

                // Atribuir cotação caso cliente não seja do alto-atacado
                if (!cotação.HasValue && ((Saída)entidade).Pessoa.Setor == null || ((Saída)entidade).Pessoa.Setor.Código != Setor.ObterSetor(SetorSistema.AltoAtacado).Código)
                {
                    double valor = ((Saída)entidade).Cotação;

                    if (valor <= 0)
                        throw new NotSupportedException("Cotação deve ser maior que zero.");

                    cotação = valor;
                }

                Cadastrar();
            }

            cancelar = false;
        }
Пример #12
0
        /// <summary>
        /// Antes de atualizar um relacioamento.
        /// </summary>
        /// <param name="entidade">Entidade a ser verificada.</param>
        /// <param name="cancelar">Se deve cancelar a operação.</param>
        /// <exception cref="DocumentoInconsistente">Tabela ou índice de mercadoria ou cliente inconsistente.</exception>
        void AntesDeAtualizarRelacionamento(DbManipulação entidade, out bool cancelar)
        {
            Relacionamento.RelacionamentoAcerto relacionamento = (Relacionamento.RelacionamentoAcerto)entidade;

            /* Garantir que a entidade ainda está vinculada
             * a este acerto.
             */
            if (relacionamento.AcertoConsignado != null &&
                relacionamento.AcertoConsignado.Equals(this))
            {
                cancelar = true;

                GarantirConsitênciaPreço(relacionamento);
                GarantirConsistênciaPessoa(relacionamento);
            }

            cancelar = false;
        }