public void ExcluirCondicaoPagamento(int condicaoPagamentoCodigo)
{
var condicaoPagamentoAtual = _condicaoPagamentoRepository.ObterPorCodigo(condicaoPagamentoCodigo);
AssertionConcern.AssertArgumentNotEquals(condicaoPagamentoAtual, null, Erros.PaymentConditionDoesNotExist);
_condicaoPagamentoRepository.Deletar(condicaoPagamentoAtual);
}
/// <summary>
/// Validate Entity Data
/// </summary>
public override void Validate()
{
AssertionConcern.AssertArgumentLength(this.Name, 3, 64, string.Format(ValidationMessages.MinMaxLength, "name", 3, 64));
AssertionConcern.AssertArgumentLength(this.Unit, 3, 16, string.Format(ValidationMessages.MinMaxLength, "unit", 3, 16));
AssertionConcern.AssertArgumentNotEquals(this.Price, 0, string.Format(ValidationMessages.InvalidPrice, "0"));
AssertionConcern.AssertArgumentNotNull(this.Category, string.Format(ValidationMessages.RequiredField, "category"));
}
public void AtualizarCompra(Compra compra)
{
compra.Validar();
compra.ItensCompra.ForEach(x => x.Validar());
AssertionConcern.AssertArgumentNotEquals(0, compra.CompraCodigo,
string.Format(Erros.NotZeroParameter, "CompraCodigo"));
var compraAtual = _compraRepository.ObterPorCodigoComItensCompra(compra.CompraCodigo);
if (compra.StatusCompra == StatusCompraEnum.Aberto)
{
AplicaValidacoesPadrao(compra);
AdicionaFornecedorFormaECondicaoDePagamento(compra, compraAtual);
AtualizaItensCompra(compraAtual, compra.ItensCompra);
compraAtual.StatusCompra = StatusCompraEnum.Confirmado;
AdicionaContaPagarNaCompra(compraAtual);
compraAtual.ContasPagar.ForEach(x => x.Validar());
AdicionarNoEstoque(compra.ItensCompra, compra);
}
else
{
compraAtual.StatusCompra = StatusCompraEnum.Cancelado;
RemoveContaPagarDaCompra(compraAtual);
AtualizarDoEstoque(compraAtual.ItensCompra);
}
_compraRepository.Atualizar(compraAtual);
}
private void AtualizarEnderecoPessoa(Pessoa pessoa, Pessoa pessoaAtual)
{
//Adiciona um novo endereço ou modifica o exitente para principal
var enderecoAtualizar = pessoa.Enderecos.FirstOrDefault();
AssertionConcern.AssertArgumentNotEquals(enderecoAtualizar, null, Erros.EmptyAddress);
if (enderecoAtualizar != null && enderecoAtualizar.EnderecoCodigo.Equals(0) &&
!pessoaAtual.Enderecos.Any(x =>
x.Bairro.Equals(enderecoAtualizar.Bairro) &&
x.CEP.Equals(enderecoAtualizar.CEP) &&
x.Cidade.Equals(enderecoAtualizar.Cidade) &&
x.Logradouro.Equals(enderecoAtualizar.Logradouro) &&
x.Numero.Equals(enderecoAtualizar.Numero)))
{
enderecoAtualizar.Pessoa = pessoaAtual;
enderecoAtualizar.Estado = _estadoRepository.ObterPorCodigo(enderecoAtualizar.Estado.EstadoCodigo);
var novoEndereco = _enderecoRepository.Criar(enderecoAtualizar);
pessoaAtual.Enderecos.Add(novoEndereco);
}
else if (enderecoAtualizar != null && !enderecoAtualizar.EnderecoCodigo.Equals(0))
{
//Encotra o endereço que sera o principal
foreach (var item in pessoaAtual.Enderecos)
{
item.Principal = item.EnderecoCodigo.Equals(enderecoAtualizar.EnderecoCodigo);
}
}
}
private void AtualizarMeioCominicacaoPessoa(Pessoa pessoa, Pessoa pessoaAtual, TipoComunicacaoEnum tipoComunicacao)
{
//Adiciona um meio de cominicação ou modifica o exitente para principal
var meioComunicacaoAtualizar = pessoa.MeiosComunicacao.FirstOrDefault(x => x.TipoComunicacao.Equals(tipoComunicacao));
if (meioComunicacaoAtualizar == null && (tipoComunicacao == TipoComunicacaoEnum.Email || tipoComunicacao == TipoComunicacaoEnum.Celular))
{
return;
}
AssertionConcern.AssertArgumentNotEquals(meioComunicacaoAtualizar, null, Erros.EmptyPhone);
if (meioComunicacaoAtualizar != null && meioComunicacaoAtualizar.MeioComunicacaoCodigo.Equals(0) &&
!pessoaAtual.MeiosComunicacao.Any(x => x.MeioComunicacaoNome.Equals(meioComunicacaoAtualizar.MeioComunicacaoNome)))
{
meioComunicacaoAtualizar.Pessoa = pessoaAtual;
var novoMeioComunicacao = _meioComunicacaoRepository.Criar(meioComunicacaoAtualizar);
pessoaAtual.MeiosComunicacao.Add(novoMeioComunicacao);
}
else if (meioComunicacaoAtualizar != null && !meioComunicacaoAtualizar.MeioComunicacaoCodigo.Equals(0))
{
//Encotra o endereço que sera o principal
foreach (var item in pessoaAtual.MeiosComunicacao)
{
item.Principal = item.MeioComunicacaoCodigo.Equals(meioComunicacaoAtualizar.MeioComunicacaoCodigo);
}
}
}
public void AtualizarVenda(Venda venda)
{
venda.Validar();
venda.ItensVenda.ForEach(x => x.Validar());
AssertionConcern.AssertArgumentNotEquals(0, venda.VendaCodigo,
string.Format(Erros.NotZeroParameter, "VendaCodigo"));
VerificarEstoque(venda.ItensVenda);
var vendaAtual = _vendaRepository.ObterPorCodigoComItensVenda(venda.VendaCodigo);
if (venda.StatusVenda == StatusVendaEnum.Aberto)
{
AplicaValidacoesPadrao(venda);
AdicionaClienteFormaECondicaoDePagamento(venda, vendaAtual);
AtualizaItensVenda(vendaAtual, venda.ItensVenda);
vendaAtual.StatusVenda = StatusVendaEnum.Confirmado;
AdicionaContaReceberNaVenda(vendaAtual);
vendaAtual.ContasReceber.ForEach(x => x.Validar());
BaixarDoEstoque(vendaAtual.ItensVenda);
}
else
{
vendaAtual.StatusVenda = StatusVendaEnum.Cancelado;
RemoveContaReceberDaVenda(vendaAtual);
DevolverNoEstoque(vendaAtual.ItensVenda);
}
_vendaRepository.Atualizar(vendaAtual);
}
public void Validacoes()
{
AssertionConcern.AssertArgumentNotEquals(this.VeiculoId, 0, "Veiculo é obrigatório!");
AssertionConcern.AssertArgumentNotEquals(this.MotoristaId, 0, "Motorista é obrigatório!");
AssertionConcern.AssertArgumentNotEquals(this.DataSaida.Date, new DateTime(0001, 01, 01).Date, "A Data de saida é obrigatória!");
AssertionConcern.AssertArgumentNotEquals(this.DataChegada.Date, new DateTime(0001, 01, 01).Date, "A Data de chegada é obrigatória!");
AssertionConcern.AssertArgumentNotEquals(this.OrigemCidadeId, 0, "Cidade de origem é obrigatória!");
AssertionConcern.AssertArgumentNotEquals(this.DestinoCidadeId, 0, "Cidade de destino é obrigatória!");
AssertionConcern.AssertArgumentNotEquals(this.OrigemCidadeId, 0, "Cidade de origem é obrigatória!");
AssertionConcern.AssertArgumentTrue(this.ToneladaPrecoUnitario > 1, "O preço unitário deve ser maior do que R$1,00!");
AssertionConcern.AssertArgumentTrue(this.ToneladaCarga > 1, "A quantidade transportada deve ser maior do que 1!");
AssertionConcern.AssertArgumentFalse(this.OrigemCidadeId == this.DestinoCidadeId, "As cidades devem ser diferentes!");
AssertionConcern.AssertArgumentTrue(this.ValorTotalBruto == (this.ToneladaCarga * this.ToneladaPrecoUnitario), "Erro ao calcular o total bruto!");
AssertionConcern.AssertArgumentTrue(this.ValorTotalLiquido == (this.ValorTotalBruto - this.ValorTotalDespesa), "Erro ao calcular o total liquido!");
AssertionConcern.AssertArgumentFalse(this.DataSaida.Date > this.DataChegada.Date, "A data de chegada não pode ser menor que a data de saida!");
if (this.despesas != null)
{
foreach (var item in this.despesas)
{
AssertionConcern.AssertArgumentEquals(this.DataChegada.Date, item.DataLancamento.Date, "A Data de Lançamento deve ser a mesma da chegada!");
}
}
if (this.combustivel != null)
{
foreach (var item in this.combustivel)
{
AssertionConcern.AssertArgumentEquals(this.DataChegada.Date, item.DataLancamento.Date, "A Data de Lançamento deve ser a mesma da chegada!");
}
}
}
public void ExcluirProduto(int produtoCodigo)
{
var produtoAtual = _produtoRepository.ObterPorCodigo(produtoCodigo);
AssertionConcern.AssertArgumentNotEquals(produtoAtual, null, Erros.ProductDoesNotExist);
_produtoRepository.Deletar(produtoAtual);
}
public void ExcluirFormaPagamento(int formaPagamentoCodigo)
{
var formaPagamentoAtual = _formaPagamentoRepository.ObterPorCodigo(formaPagamentoCodigo);
AssertionConcern.AssertArgumentNotEquals(formaPagamentoAtual, null, Erros.FormOfPaymentDoesNotExist);
_formaPagamentoRepository.Deletar(formaPagamentoAtual);
}
public void ChangeValue(int value)
{
AssertionConcern.AssertArgumentNotEquals(0, value, "The Value must be provided.");
this.value = value;
//Apply(new CalendarDescriptionChanged(this.tenant, this.calendarId, this.name, description));
}
public void ExcluirPessoa(int pessoaCodigo)
{
AssertionConcern.AssertArgumentNotEquals(pessoaCodigo, 0, Erros.InvalidCode);
var pessoa = _pessoaRepository.ObterPorCodigoComPessoaCompleta(pessoaCodigo);
AssertionConcern.AssertArgumentNotNull(pessoa, Erros.PersonDoesNotExist);
_pessoaRepository.Deletar(pessoa);
}
public void Validar()
{
AssertionConcern.AssertArgumentNotNull(ProdutoNome, string.Format(Erros.NullParameter, "ProdutoNome"));
AssertionConcern.AssertArgumentNotEmpty(ProdutoNome, string.Format(Erros.EmptyParameter, "ProdutoNome"));
AssertionConcern.AssertArgumentNotEquals(0.0M, PrecoCusto, string.Format(Erros.NotZeroParameter, "PrecoCusto"));
AssertionConcern.AssertArgumentNotEquals(0.0M, PrecoVenda, string.Format(Erros.NotZeroParameter, "PrecoVenda"));
AssertionConcern.AssertArgumentNotNull(Unidade, string.Format(Erros.NullParameter, "Unidade"));
}
public void ExcluirVenda(int codigoVenda)
{
var venda = _vendaRepository.ObterPorCodigo(codigoVenda);
AssertionConcern.AssertArgumentNotEquals(venda, null, Erros.SaleDoesNotExist);
AssertionConcern.AssertArgumentNotEquals(venda.StatusVenda, StatusVendaEnum.Confirmado, Erros.SaleConfirmedCanNotBeExcluded);
_vendaRepository.Deletar(venda);
}
public void ExcluirCompra(int codigoCompra)
{
var compra = _compraRepository.ObterPorCodigo(codigoCompra);
AssertionConcern.AssertArgumentNotEquals(compra, null, Erros.PurchaseDoesNotExist);
AssertionConcern.AssertArgumentNotEquals(compra.StatusCompra, StatusVendaEnum.Confirmado, Erros.PurchaseConfirmedCanNotBeExcluded);
_compraRepository.Deletar(compra);
}
private void ProtectPassword(string currentPassword, string changedPassword)
{
AssertionConcern.AssertArgumentNotEquals(currentPassword, changedPassword, "The password is unchanged.");
AssertionConcern.AssertArgumentFalse(DomainRegistry.PasswordService.IsWeak(changedPassword), "The password must be stronger.");
AssertionConcern.AssertArgumentNotEquals(this.Username, changedPassword, "The username and password must not be the same.");
this.Password = AsEncryptedValue(changedPassword);
}
public void ConferirContato(string contato1, string contato2)
{
AssertionConcern.AssertArgumentNotEquals(contato1, contato2, "Os telefones não podem ser iguais.");
AssertionConcern.AssertArgumentLength(contato1, 15, "O Telefone deve ter no máximo 15 caracteres.");
AssertionConcern.AssertArgumentLength(contato2, 15, "O Telefone deve ter no máximo 15 caracteres.");
this.Telefone1 = contato1;
this.Telefone2 = contato2;
}
// Method registration
public void SetPassword(string password, string confirmPassword)
{
if (AssertionConcern.AssertArgumentLength(password, 8, 20, Errors.PasswordIntervalCaractere) &&
AssertionConcern.AssertArgumentEmpty(confirmPassword, Errors.InvalidPasswordConfirmation) &&
AssertionConcern.AssertArgumentNotEquals(password, confirmPassword, Errors.PasswordDoNotMatch))
{
Password = password;
}
}
public void Validar()
{
AssertionConcern.AssertArgumentNotEquals(0, ProdutoCodigo, string.Format(Erros.NotZeroParameter, "ProdutoCodigo"));
AssertionConcern.AssertArgumentNotEmpty(ProdutoNome, string.Format(Erros.EmptyParameter, "ProdutoNome"));
AssertionConcern.AssertArgumentNotEquals(0, Quantidade, string.Format(Erros.NotZeroParameter, "Quantidade"));
AssertionConcern.AssertArgumentNotEquals(0.0M, PrecoVenda, string.Format(Erros.NotZeroParameter, "PrecoVenda"));
AssertionConcern.AssertArgumentNotEquals(0.0M, ValorBruto, string.Format(Erros.NotZeroParameter, "ValorBruto"));
AssertionConcern.AssertArgumentNotEquals(0.0M, ValorLiquido, string.Format(Erros.NotZeroParameter, "ValorLiquido"));
}
public Stretch(string from, string to, int value)
{
AssertionConcern.AssertArgumentNotNull(from, "The From must be provided.");
AssertionConcern.AssertArgumentNotNull(to, "The To must be provided.");
AssertionConcern.AssertArgumentNotEquals(0, value, "The Value id must be provided.");
this.from = new Local(from);
this.to = new Local(to);
this.value = value;
}
public Produto CriarProduto(Produto produto)
{
produto.Validar();
produto.Unidade.Validar();
var unidade = _unidadeRepository.ObterPorCodigo(produto.Unidade.UnidadeCodigo);
AssertionConcern.AssertArgumentNotEquals(unidade, null, Erros.UnitDoesNotExist);
produto.Unidade = unidade;
return(_produtoRepository.Criar(produto));
}
public void Validar()
{
AssertionConcern.AssertArgumentNotEquals(new DateTime(), DataVencimento,
string.Format(Erros.InvalidParameter, "DataVencimento"));
AssertionConcern.AssertArgumentNotEquals(0.0M, ValorDocumento,
string.Format(Erros.NotZeroParameter, "ValorDocumento"));
AssertionConcern.AssertArgumentNotEquals(StatusContaReceber, StatusContaReceberEnum.None,
string.Format(Erros.InvalidParameter, "StatusContaReceber"));
AssertionConcern.AssertArgumentNotNull(Venda, Erros.SaleNotSet);
}
public FormaPagamento AtualizarFormaPagamento(FormaPagamento formaPagamento)
{
formaPagamento.Validar();
AssertionConcern.AssertArgumentNotEquals(0, formaPagamento.FormaPagamentoCodigo,
string.Format(Erros.NotZeroParameter, "FormaPagamentoCodigo"));
var formaPagamentoAtual =
_formaPagamentoRepository.ObterPorCodigo(formaPagamento.FormaPagamentoCodigo);
formaPagamentoAtual.Ativo = formaPagamento.Ativo;
formaPagamentoAtual.Descricao = formaPagamento.Descricao;
return(_formaPagamentoRepository.Atualizar(formaPagamentoAtual));
}
public CondicaoPagamento AtualizarCondicaoPagamento(CondicaoPagamento condicaoPagamento)
{
condicaoPagamento.Validar();
AssertionConcern.AssertArgumentNotEquals(0, condicaoPagamento.CondicaoPagamentoCodigo,
string.Format(Erros.NotZeroParameter, "CondicaoPagamentoCodigo"));
var condicaoPagamentoAtual =
_condicaoPagamentoRepository.ObterPorCodigo(condicaoPagamento.CondicaoPagamentoCodigo);
condicaoPagamentoAtual.Ativo = condicaoPagamento.Ativo;
condicaoPagamentoAtual.Descricao = condicaoPagamento.Descricao;
condicaoPagamentoAtual.QuantidadeParcelas = condicaoPagamento.QuantidadeParcelas;
return(_condicaoPagamentoRepository.Atualizar(condicaoPagamentoAtual));
}
public void Validar()
{
AssertionConcern.AssertArgumentNotEquals(new DateTime(), DataCadastro,
string.Format(Erros.InvalidParameter, "DataCadastro"));
AssertionConcern.AssertArgumentNotEquals(StatusCompra, StatusCompraEnum.None,
string.Format(Erros.InvalidParameter, "StatusCompra"));
AssertionConcern.AssertArgumentNotEquals(0.0M, ValorTotalBruto,
string.Format(Erros.NotZeroParameter, "ValorTotalBruto"));
AssertionConcern.AssertArgumentNotEquals(0.0M, ValorTotalLiquido,
string.Format(Erros.NotZeroParameter, "ValorTotalLiquido"));
AssertionConcern.AssertArgumentNotEquals(0, Usuario.UsuarioCodigo, Erros.UserNotSet);
AssertionConcern.AssertArgumentTrue(ItensCompra.Any(), Erros.SaleItemsNotSet);
}
public Route(string from, string to, int value)
{
AssertionConcern.AssertArgumentNotNull(from, "The From must be provided.");
AssertionConcern.AssertArgumentNotNull(to, "The To must be provided.");
AssertionConcern.AssertArgumentNotEquals(0, value, "The To must be provided.");
AssertionConcern.AssertArgumentLength(from, 3, "The To must be provided.");
AssertionConcern.AssertArgumentLength(to, 3, "The To must be provided.");
this.from = from.ToUpper();
this.to = to.ToUpper();
this.value = value;
}
private void AdicionaClienteFormaECondicaoDePagamento(Venda venda, Venda vendaAtual)
{
AssertionConcern.AssertArgumentNotEquals(0, venda.Cliente.PessoaCodigo, Erros.ClientNotSet);
AssertionConcern.AssertArgumentNotEquals(0, venda.FormaPagamento.FormaPagamentoCodigo,
Erros.NotSetPayment);
AssertionConcern.AssertArgumentNotEquals(0, venda.CondicaoPagamento.CondicaoPagamentoCodigo,
Erros.PaymentConditionNotSet);
var cliente = _pessoaRepository.ObterPorCodigo(venda.Cliente.PessoaCodigo);
var formaPagamento = _formaPagamentoRepository.ObterPorCodigo(venda.FormaPagamento.FormaPagamentoCodigo);
var condicaoPagamento =
_condicaoPagamentoRepository.ObterPorCodigo(venda.CondicaoPagamento.CondicaoPagamentoCodigo);
vendaAtual.Cliente = cliente;
vendaAtual.FormaPagamento = formaPagamento;
vendaAtual.CondicaoPagamento = condicaoPagamento;
}
private void AdicionaFornecedorFormaECondicaoDePagamento(Compra compra, Compra compraAtual)
{
AssertionConcern.AssertArgumentNotEquals(0, compra.Fornecedor.PessoaCodigo, Erros.ProviderNotSet);
AssertionConcern.AssertArgumentNotEquals(0, compra.FormaPagamento.FormaPagamentoCodigo,
Erros.NotSetPayment);
AssertionConcern.AssertArgumentNotEquals(0, compra.CondicaoPagamento.CondicaoPagamentoCodigo,
Erros.PaymentConditionNotSet);
var fornecedor = _pessoaRepository.ObterPorCodigo(compra.Fornecedor.PessoaCodigo);
var formaPagamento = _formaPagamentoRepository.ObterPorCodigo(compra.FormaPagamento.FormaPagamentoCodigo);
var condicaoPagamento =
_condicaoPagamentoRepository.ObterPorCodigo(compra.CondicaoPagamento.CondicaoPagamentoCodigo);
compraAtual.Fornecedor = fornecedor;
compraAtual.FormaPagamento = formaPagamento;
compraAtual.CondicaoPagamento = condicaoPagamento;
}
public Produto AtualizarProduto(Produto produto)
{
produto.Validar();
AssertionConcern.AssertArgumentNotEquals(0, produto.ProdutoCodigo, string.Format(Erros.NotZeroParameter, "ProdutoCodigo"));
produto.Unidade.Validar();
var unidade = _unidadeRepository.ObterPorCodigo(produto.Unidade.UnidadeCodigo);
AssertionConcern.AssertArgumentNotEquals(unidade, null, Erros.UnitDoesNotExist);
var produtoAtual = _produtoRepository.ObterComUnidadePorCodigo(produto.ProdutoCodigo);
AssertionConcern.AssertArgumentNotEquals(produtoAtual, null, Erros.ProductDoesNotExist);
produtoAtual.PrecoCusto = produto.PrecoCusto;
produtoAtual.PrecoVenda = produto.PrecoVenda;
produtoAtual.ProdutoNome = produto.ProdutoNome;
produtoAtual.Unidade = unidade;
return(_produtoRepository.Atualizar(produtoAtual));
}
public void EditarPermissaoUsuario(int codigoUsuario, List <Permissao> permissoes)
{
AssertionConcern.AssertArgumentNotEquals(codigoUsuario, 0, Erros.UserDoesNotExist);
if (!permissoes.Any())
{
throw new Exception(Erros.EmptyAllowList);
}
var temUsuario = _usuarioRepository.ObterPorCodigoComPermissoes(codigoUsuario);
AssertionConcern.AssertArgumentNotEquals(temUsuario, null, Erros.UserDoesNotExist);
var listaPermissao = _permissaoRepository.ObterLista();
permissoes = permissoes.Select(x =>
listaPermissao.FirstOrDefault(a => a.PermissaoCodigo.Equals(x.PermissaoCodigo))).ToList();
temUsuario.Permissoes.Clear();
temUsuario.Permissoes = permissoes;
_usuarioRepository.Atualizar(temUsuario);
}
internal static bool TryConvert(ActiveValues value, out bool result)
{
AssertionConcern.AssertArgumentNotEquals(ActiveValues.None, value, "Specified ActiveValues 'value' cannot be 'None'");
bool tryResult = false;
result = false;
if (!value.HasFlag(ActiveValues.All))
{
if (value.HasFlag(ActiveValues.Active))
{
result = true;
tryResult = true;
}
else if (value.HasFlag(ActiveValues.Inactive))
{
tryResult = true;
}
}
return(tryResult);
}
