/// <summary>
/// Edita um item não será implementado, pois será feito em conjunto
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Editar(RequisicaoEntidadeDto <PedidoItemDto> requisicaoDto, ref RetornoDto retornoDto)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Método não implementado para esta entidade";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
/// <summary>
/// Edita uma entidade existente no banco de dados
/// </summary>
/// <param name="BaseRequisicaoDto"></param>
/// <param name="retornoDto"></param>
public virtual bool Editar(RequisicaoEntidadeDto <Y> requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
Guid idEntidade = (requisicaoDto.EntidadeDto == null) ? Guid.Empty : requisicaoDto.EntidadeDto.Id;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseEditar, idEntidade, mensagemErro);
return(false);
}
if (requisicaoDto.EntidadeDto == null)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Não é possível editar uma entidade nula.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseEditar, Guid.Empty, retornoDto.Mensagem);
return(false);
}
if (!requisicaoDto.EntidadeDto.ValidarEntidade(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseEditar, requisicaoDto.EntidadeDto.Id, mensagemErro);
return(false);
}
return(true);
}
/// <summary>
/// Inclui ou atualiza os dados de um CEP
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="cepDto"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool IncluirEditar(BaseRequisicaoDto requisicaoDto, CepDto cepDto, ref string mensagemErro)
{
if (cepDto == null)
{
mensagemErro = "Preencha o CEP que deseja incluir/editar.";
return(false);
}
CepVo cepVo;
if (!ObterPorIdBd(cepDto.Id, out cepVo, ref mensagemErro) && mensagemErro != "Cadastro não encontrado")
{
mensagemErro = "Problemas para encontrar o cep: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirEditarCep, cepDto.Id, mensagemErro);
return(false);
}
// Incluir se não existir
if (cepVo == null)
{
RequisicaoEntidadeDto <CepDto> requisicaoIncluirDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Incluir(requisicaoIncluirDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
else
{
// verificar se precisa editar
if ((string.IsNullOrWhiteSpace(cepDto.Cep) ? "" : cepDto.Cep.Trim()) != (string.IsNullOrWhiteSpace(cepVo.Cep) ? "" : cepVo.Cep.Trim()) ||
(string.IsNullOrWhiteSpace(cepDto.Logradouro) ? "" : cepDto.Logradouro.Trim()) != (string.IsNullOrWhiteSpace(cepVo.Logradouro) ? "" : cepVo.Logradouro.Trim()) ||
(string.IsNullOrWhiteSpace(cepDto.Bairro) ? "" : cepDto.Bairro.Trim()) != (string.IsNullOrWhiteSpace(cepVo.Bairro) ? "" : cepVo.Bairro.Trim()) ||
(string.IsNullOrWhiteSpace(cepDto.Cidade) ? "" : cepDto.Cidade.Trim()) != (string.IsNullOrWhiteSpace(cepVo.Cidade) ? "" : cepVo.Cidade.Trim()))
{
RequisicaoEntidadeDto <CepDto> requisicaoEditarDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Editar(requisicaoEditarDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
}
return(true);
}
/// <summary>
/// Método prático para registrar um log no banco de dados
/// </summary>
/// <param name="requisicaoBaseDto"></param>
/// <param name="recurso"></param>
/// <param name="idEntidade"></param>
/// <param name="retornoDto"></param>
/// <param name="linha"></param>
/// <param name="metodo"></param>
internal void ResgistrarLog(BaseRequisicaoDto requisicaoBaseDto, LogRecursos recurso, Guid idEntidade, string mensagem, [CallerLineNumber] int linha = 0, [CallerMemberName] string metodo = "")
{
RequisicaoEntidadeDto <LogDto> requisicaoDto = new RequisicaoEntidadeDto <LogDto>()
{
IdUsuario = requisicaoBaseDto.IdUsuario,
Identificacao = requisicaoBaseDto.Identificacao,
EntidadeDto = new LogDto()
};
requisicaoDto.EntidadeDto.IdEntidade = idEntidade;
requisicaoDto.EntidadeDto.IdUsuario = requisicaoBaseDto.IdUsuario;
requisicaoDto.EntidadeDto.Recurso = recurso;
requisicaoDto.EntidadeDto.Id = Guid.NewGuid();
requisicaoDto.EntidadeDto.Inativo = false;
requisicaoDto.EntidadeDto.Mensagem = $"Classe: {classeOrigem}. \n " +
$"Método: {metodo} \n" +
$"Linha: {linha} \n" +
$"Mensagem: {mensagem}";
RetornoDto retornoIncluirDto = new RetornoDto();
if (!Incluir(requisicaoDto, ref retornoIncluirDto))
{
//TODO: Enviar email para avisar que não está logando
}
}
/// <summary>
/// Obtem uma listra filtrada de movimento de caixa
/// </summary>
/// <param name="filtros"></param>
/// <returns></returns>
public string IncluirMovimento(MovimentoCaixaDto movimentoDto, bool indicadorSaida)
{
RetornoDto retornoDto = new RetornoDto();
if (!SessaoUsuario.SessaoLogin.Administrador)
{
retornoDto.Mensagem = "Para incluir um movimento de caixa é necessário " +
$"logar com um usuário administrador.";
}
else
{
movimentoDto.Id = Guid.NewGuid();
//Requisição para obter a lista
RequisicaoEntidadeDto <MovimentoCaixaDto> requisicaoDto = new RequisicaoEntidadeDto <MovimentoCaixaDto>()
{
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
EntidadeDto = movimentoDto
};
if (indicadorSaida)
{
requisicaoDto.EntidadeDto.Valor = requisicaoDto.EntidadeDto.Valor * (-1);
}
//Consumir o serviço
MovimentoCaixaBll movimentoCaixaBll = new MovimentoCaixaBll(true);
movimentoCaixaBll.Incluir(requisicaoDto, ref retornoDto);
}
string retorno = new JavaScriptSerializer().Serialize(retornoDto);
return(retorno);
}
public void TestarInclusaoComFalha()
{
RequisicaoEntidadeDto <FornecedorDto> requisicaoDto = new RequisicaoEntidadeDto <FornecedorDto>()
{
EntidadeDto = RetornarNovoFornecedor()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
FornecedorBll fornecedorBll = new FornecedorBll(true);
requisicaoDto.EntidadeDto.Id = Guid.Empty;
// Incluir com id inválido
RetornoDto retornoDto = new RetornoDto();
fornecedorBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(false, retornoDto.Retorno);
Assert.AreEqual("O ID da entidade é obrigatório!", retornoDto.Mensagem);
requisicaoDto.EntidadeDto.Id = Guid.NewGuid();
// Incluir com código malicioso
requisicaoDto.EntidadeDto.NomeFantasia = "";
retornoDto = new RetornoDto();
fornecedorBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(false, retornoDto.Retorno);
Assert.AreEqual("O ID da entidade é obrigatório!", retornoDto.Mensagem);
}
/// <summary>
/// Inclui ou atualiza os dados de um endereço de cliente
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="clienteEnderecoDto"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool IncluirEditar(BaseRequisicaoDto requisicaoDto, ClienteEnderecoDto clienteEnderecoDto, ref string mensagemErro)
{
if (clienteEnderecoDto == null)
{
mensagemErro = "Preencha o endereço que deseja incluir/editar.";
return(false);
}
ClienteEnderecoVo clienteEnderecoVo;
if (!ObterPorIdBd(clienteEnderecoDto.Id, out clienteEnderecoVo, ref mensagemErro) && mensagemErro != "Cadastro não encontrado")
{
mensagemErro = "Problemas para encontrar o endereço do cliente: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirEditarClienteEndereco, clienteEnderecoDto.Id, mensagemErro);
return(false);
}
// Incluir se não existir
if (clienteEnderecoVo == null)
{
RequisicaoEntidadeDto <ClienteEnderecoDto> requisicaoIncluirDto = new RequisicaoEntidadeDto <ClienteEnderecoDto>()
{
EntidadeDto = clienteEnderecoDto,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Incluir(requisicaoIncluirDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
else
{
// verificar se precisa editar
if ((string.IsNullOrWhiteSpace(clienteEnderecoDto.ComplementoEndereco) ? "" : clienteEnderecoDto.ComplementoEndereco.Trim()) != (string.IsNullOrWhiteSpace(clienteEnderecoVo.ComplementoEndereco) ? "" : clienteEnderecoVo.ComplementoEndereco.Trim()) ||
(string.IsNullOrWhiteSpace(clienteEnderecoDto.NumeroEndereco) ? "" : clienteEnderecoDto.NumeroEndereco.Trim()) != (string.IsNullOrWhiteSpace(clienteEnderecoVo.NumeroEndereco) ? "" : clienteEnderecoVo.NumeroEndereco.Trim()) ||
clienteEnderecoDto.IdCep != clienteEnderecoVo.IdCep)
{
RequisicaoEntidadeDto <ClienteEnderecoDto> requisicaoEditarDto = new RequisicaoEntidadeDto <ClienteEnderecoDto>()
{
EntidadeDto = clienteEnderecoDto,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Editar(requisicaoEditarDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
}
return(true);
}
public void CrudUsuario()
{
RequisicaoEntidadeDto <UsuarioDto> requisicaoDto = new RequisicaoEntidadeDto <UsuarioDto>()
{
EntidadeDto = RetornarNovoUsuario()
};
string senhaCrip = "";
UtilitarioBll.CriptografarSenha(requisicaoDto.EntidadeDto.Senha, ref senhaCrip);
requisicaoDto.EntidadeDto.Senha = senhaCrip;
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
UsuarioBll usuarioBll = new UsuarioBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
usuarioBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.Nome = "Usuario atualizado " + DateTime.Now;
usuarioBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <UsuarioDto> retornoObterDto = new RetornoObterDto <UsuarioDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
usuarioBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "NOME",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <UsuarioDto> retornoObterListaDto = new RetornoObterListaDto <UsuarioDto>();
usuarioBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
usuarioBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public ActionResult Editar(FuncionarioModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para editar um funcionario é necessário " +
$"logar com um funcionario administrador.";
return(View("SemPermissao"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converte para DTO
FuncionarioDto funcionarioDto = new FuncionarioDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref funcionarioDto, ref mensagemErro))
{
ViewBag.Mensagem = mensagemErro;
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <FuncionarioDto> requisicaoDto = new RequisicaoEntidadeDto <FuncionarioDto>()
{
EntidadeDto = funcionarioDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
FuncionarioBll funcionarioBll = new FuncionarioBll(true);
funcionarioBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do funcionario
return(RedirectToAction("Index"));
}
/// <summary>
/// Inclui um item de pedido no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <PedidoItemDto> requisicaoDto, ref RetornoDto retornoDto)
{
RequisicaoListaEntidadesDto <PedidoItemDto> requisicaoListaEntidadesDto = new RequisicaoListaEntidadesDto <PedidoItemDto>()
{
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
requisicaoListaEntidadesDto.ListaEntidadesDto.Add(requisicaoDto.EntidadeDto);
return(IncluirLista(requisicaoListaEntidadesDto, ref retornoDto));
}
/// <summary>
/// Edita um conta
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Editar(RequisicaoEntidadeDto <ContaReceberDto> requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Editar(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
ContaReceberVo contaReceberVo = new ContaReceberVo();
if (!ObterPorIdBd(requisicaoDto.EntidadeDto.Id, out contaReceberVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas para encontrar a conta: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarContaReceber, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref contaReceberVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas ao converter a conta para Vo: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarContaReceber, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!EditarBd(contaReceberVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar os novos dados da conta: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarContaReceber, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarContaReceber, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public void CrudClienteComErro()
{
RequisicaoEntidadeDto <ClienteDto> requisicaoDto = new RequisicaoEntidadeDto <ClienteDto>()
{
EntidadeDto = RetornarNovoCliente()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
ClienteBll clienteBll = new ClienteBll(true);
// Incluir
requisicaoDto.EntidadeDto.Nome = "";
RetornoDto retornoDto = new RetornoDto();
clienteBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(false, retornoDto.Retorno);
Assert.AreEqual("O nome do cliente é obrigatório! Por favor, informe o nome do cliente " +
"no campo indicado para continuar. ", retornoDto.Mensagem);
requisicaoDto.EntidadeDto.Nome = "Te";
retornoDto = new RetornoDto();
clienteBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(false, retornoDto.Retorno);
Assert.AreEqual("O nome do cliente deve ter, ao menos, 3 caracteres! Por favor, informe um nome " +
"válido para continuar. ", retornoDto.Mensagem);
requisicaoDto.EntidadeDto.Nome = "Testes";
retornoDto = new RetornoDto();
clienteBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.Nome = "";
clienteBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(false, retornoDto.Retorno);
Assert.AreEqual("O nome do cliente é obrigatório! Por favor, informe o nome do cliente " +
"no campo indicado para continuar. ", retornoDto.Mensagem);
// Obter
RetornoObterDto <ClienteDto> retornoObterDto = new RetornoObterDto <ClienteDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = Guid.Empty,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
clienteBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(false, retornoObterDto.Retorno);
// Excluir
clienteBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(false, retornoObterDto.Retorno);
}
public ActionResult Incluir(CepModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converter para DTO
CepDto cepDto = new CepDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref cepDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
cepDto.Id = Guid.NewGuid();
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <CepDto> requisicaoDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Incluir(requisicaoDto, ref retorno);
//Verificar o retorno
if (retorno.Retorno == false)
{
//Se houver erro, exibir na tela de inclusão
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "INCLUIDO";
//Retornar para index
return(RedirectToAction("Index"));
}
public void CrudMovimentoCaixa()
{
RequisicaoEntidadeDto <MovimentoCaixaDto> requisicaoDto = new RequisicaoEntidadeDto <MovimentoCaixaDto>()
{
EntidadeDto = RetornarNovoMovimentoCaixa()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
MovimentoCaixaBll movimentoCaixaBll = new MovimentoCaixaBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
movimentoCaixaBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.Justificativa = "Teste atualizado " + DateTime.Now;
movimentoCaixaBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <MovimentoCaixaDto> retornoObterDto = new RetornoObterDto <MovimentoCaixaDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
movimentoCaixaBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "JUSTIFICATIVA",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <MovimentoCaixaDto> retornoObterListaDto = new RetornoObterListaDto <MovimentoCaixaDto>();
movimentoCaixaBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
movimentoCaixaBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public void CrudTaxaEntrega()
{
RequisicaoEntidadeDto <TaxaEntregaDto> requisicaoDto = new RequisicaoEntidadeDto <TaxaEntregaDto>()
{
EntidadeDto = RetornarNovoTaxaEntrega()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
taxaEntregaBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.BairroCidade = "Outro bairro";
taxaEntregaBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <TaxaEntregaDto> retornoObterDto = new RetornoObterDto <TaxaEntregaDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
taxaEntregaBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "BAIRRO",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <TaxaEntregaDto> retornoObterListaDto = new RetornoObterListaDto <TaxaEntregaDto>();
taxaEntregaBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
taxaEntregaBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public void CrudProduto()
{
RequisicaoEntidadeDto <ProdutoDto> requisicaoDto = new RequisicaoEntidadeDto <ProdutoDto>()
{
EntidadeDto = RetornarNovoProduto()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
ProdutoBll produtoBll = new ProdutoBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
produtoBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.Descricao = "Produto atualizado " + DateTime.Now;
produtoBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <ProdutoDto> retornoObterDto = new RetornoObterDto <ProdutoDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
produtoBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "DESCRICAO",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <ProdutoDto> retornoObterListaDto = new RetornoObterListaDto <ProdutoDto>();
produtoBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
produtoBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public void CrudFornecedor()
{
RequisicaoEntidadeDto <FornecedorDto> requisicaoDto = new RequisicaoEntidadeDto <FornecedorDto>()
{
EntidadeDto = RetornarNovoFornecedor()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
FornecedorBll fornecedorBll = new FornecedorBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
fornecedorBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.NomeFantasia = "Fornecedor atualizado " + DateTime.Now;
fornecedorBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <FornecedorDto> retornoObterDto = new RetornoObterDto <FornecedorDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
fornecedorBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "NOMEFANTASIA",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <FornecedorDto> retornoObterListaDto = new RetornoObterListaDto <FornecedorDto>();
fornecedorBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
fornecedorBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public ActionResult Editar(CepModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converte para DTO
CepDto cepDto = new CepDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref cepDto, ref mensagemErro))
{
ViewBag.MensagemErro = mensagemErro;
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <CepDto> requisicaoDto = new RequisicaoEntidadeDto <CepDto>()
{
EntidadeDto = cepDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do cep
return(RedirectToAction("Index"));
}
/// <summary>
/// Inclui uma conta no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <ContaReceberDto> requisicaoDto, ref RetornoDto retornoDto)
{
// Valida a requisição
if (!base.Incluir(requisicaoDto, ref retornoDto))
{
return(false);
}
ContaReceberVo contaReceberVo = new ContaReceberVo();
string mensagemErro = "";
// Converte para VO a ser incluída no banco de dados
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref contaReceberVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a conta para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirContaReceber, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(contaReceberVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a conta para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirContaReceber, Guid.Empty, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirContaReceber, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public void CrudSuporte()
{
RequisicaoEntidadeDto <SuporteDto> requisicaoDto = new RequisicaoEntidadeDto <SuporteDto>()
{
EntidadeDto = RetornarNovoSuporte()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
SuporteBll suporteBll = new SuporteBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
suporteBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <SuporteDto> retornoObterDto = new RetornoObterDto <SuporteDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
suporteBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Obter lista
RequisicaoObterListaDto requisicaoObterListaDto = new RequisicaoObterListaDto()
{
CampoOrdem = "DATADECRESCENTE",
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
NumeroItensPorPagina = 2,
Pagina = 1
};
RetornoObterListaDto <SuporteDto> retornoObterListaDto = new RetornoObterListaDto <SuporteDto>();
suporteBll.ObterListaFiltrada(requisicaoObterListaDto, ref retornoObterListaDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
suporteBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
public void CrudPedidoSimples()
{
RequisicaoEntidadeDto <PedidoDto> requisicaoDto = new RequisicaoEntidadeDto <PedidoDto>()
{
EntidadeDto = RetornarNovoPedidoSimples()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
PedidoBll pedidoBll = new PedidoBll(true);
// Incluir pedido
RetornoDto retornoDto = new RetornoDto();
pedidoBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
RetornoObterDto <PedidoDto> retornoObterDto = new RetornoObterDto <PedidoDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
// Obter pedido
pedidoBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
requisicaoDto.EntidadeDto = retornoObterDto.Entidade;
requisicaoDto.EntidadeDto.ListaItens[0].PrecoProduto = 28;
requisicaoDto.EntidadeDto.ListaItens.RemoveAt(1);
requisicaoDto.EntidadeDto.Total = 28;
requisicaoDto.EntidadeDto.RecebidoDebito = 28;
requisicaoDto.EntidadeDto.RecebidoDinheiro = 0;
// Editar pedido
retornoDto = new RetornoDto();
pedidoBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Excluir pedido
retornoDto = new RetornoDto();
pedidoBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
}
public static ProdutoDto IncluirProdutoTeste()
{
RequisicaoEntidadeDto <ProdutoDto> requisicaoDto = new RequisicaoEntidadeDto <ProdutoDto>()
{
EntidadeDto = RetornarNovoProduto()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
ProdutoBll produtoBll = new ProdutoBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
produtoBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
return(requisicaoDto.EntidadeDto);
}
///// <summary>
///// Inclui um log no banco de dados
///// </summary>
///// <param name="requisicaoDto"></param>
///// <param name="retornoDto"></param>
///// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <LogDto> requisicaoDto, ref RetornoDto retornoDto)
{
// Valida a requisição
if (!base.Incluir(requisicaoDto, ref retornoDto))
{
// Logado dentro do método base.Incluir
return(false);
}
LogVo logVo = new LogVo();
string mensagemErro = "";
// Converte para VO a ser incluída no banco de dados
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref logVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o log para VO: " + mensagemErro;
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(logVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o log para VO: " + mensagemErro;
return(false);
}
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
return(false);
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public void CrudCliente()
{
RequisicaoEntidadeDto <ClienteDto> requisicaoDto = new RequisicaoEntidadeDto <ClienteDto>()
{
EntidadeDto = RetornarNovoCliente()
};
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
ClienteBll clienteBll = new ClienteBll(true);
// Incluir
RetornoDto retornoDto = new RetornoDto();
clienteBll.Incluir(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Editar
requisicaoDto.EntidadeDto.Nome = "Cliente atualizado " + DateTime.Now;
clienteBll.Editar(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
// Obter
RetornoObterDto <ClienteDto> retornoObterDto = new RetornoObterDto <ClienteDto>();
RequisicaoObterDto requisicaoObterDto = new RequisicaoObterDto()
{
Id = requisicaoDto.EntidadeDto.Id,
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao
};
clienteBll.Obter(requisicaoObterDto, ref retornoObterDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
// Excluir
clienteBll.Excluir(requisicaoObterDto, ref retornoDto);
Assert.AreEqual(true, retornoObterDto.Retorno);
}
/// <summary>
/// Inclui uma mensagem de suporte
/// </summary>
/// <param name="filtros"></param>
/// <returns></returns>
public string IncluirMensagemSuporte(SuporteDto suporteDto)
{
RetornoDto retornoDto = new RetornoDto();
if (suporteDto == null)
{
retornoDto.Mensagem = "Não foram recebidos os dados da mensagem";
retornoDto.Retorno = false;
}
suporteDto.Id = Guid.NewGuid();
//Requisição para incluir a mensagem
RequisicaoEntidadeDto <SuporteDto> requisicaoDto = new RequisicaoEntidadeDto <SuporteDto>()
{
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
EntidadeDto = suporteDto
};
//Consumir o serviço
SuporteBll suporteBll = new SuporteBll(true);
suporteBll.Incluir(requisicaoDto, ref retornoDto);
RetornoGuidDto retornoGuidDto = new RetornoGuidDto()
{
Id = suporteDto.Id,
Retorno = retornoDto.Retorno,
Mensagem = retornoDto.Mensagem
};
string retorno = new JavaScriptSerializer().Serialize(retornoGuidDto);
return(retorno);
}
/// <summary>
/// Inclui um cep no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <CepDto> requisicaoDto, ref RetornoDto retornoDto)
{
// Valida a requisição
if (!base.Incluir(requisicaoDto, ref retornoDto))
{
return(false);
}
// Converte para VO a ser incluída no banco de dados
string mensagemErro = "";
CepVo cepVo = new CepVo();
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref cepVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o cep para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Verifica se o cep já existe
CepVo cepExistente = null;
if (!VerificarCepExistente(requisicaoDto.EntidadeDto, ref cepExistente, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
return(false);
}
// Se estiver excluído, restaurar o cadastro antigo
if (cepExistente != null && cepExistente.Excluido == true)
{
cepExistente.Logradouro = cepVo.Logradouro;
cepExistente.Cidade = cepVo.Cidade;
cepExistente.Bairro = cepVo.Bairro;
cepExistente.Cep = cepVo.Cep;
cepExistente.Excluido = false;
if (!EditarBd(cepExistente, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar os dados do Cep: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
// Se não estiver excluído, não permitir incluir duplicado
else if (cepExistente != null && cepExistente.Excluido == false)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Esse cadastro (CEP) já existe, não é possível incluir cadastros duplicados.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
else
{
// Prepara a inclusão no banco de dados
if (!IncluirBd(cepVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o cep para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Inclui um endereço de cliente no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <ClienteEnderecoDto> requisicaoDto, ref RetornoDto retornoDto)
{
// Valida a requisição
if (!base.Incluir(requisicaoDto, ref retornoDto))
{
return(false);
}
// Se houver endereço preenchido e ele não existir ainda
if (requisicaoDto.EntidadeDto.Endereco.Id == Guid.Empty &&
!string.IsNullOrWhiteSpace(requisicaoDto.EntidadeDto.Endereco.Cep))
{
CepBll cepBll = new CepBll(this.pizzaByteContexto, false);
RequisicaoEntidadeDto <CepDto> requisicaoCepDto = new RequisicaoEntidadeDto <CepDto>()
{
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
EntidadeDto = requisicaoDto.EntidadeDto.Endereco
};
requisicaoCepDto.EntidadeDto.Id = Guid.NewGuid();
// Incluir o endereço
if (!cepBll.Incluir(requisicaoCepDto, ref retornoDto))
{
// Logado na classe de CEP
return(false);
}
}
ClienteEnderecoVo clienteEnderecoVo = new ClienteEnderecoVo();
string mensagemErro = "";
// Converte para VO a ser incluída no banco de dados
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref clienteEnderecoVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o endereço do cliente para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirClienteEndereco, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(clienteEnderecoVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao incluir o endereço do cliente no banco de dados: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirClienteEndereco, Guid.Empty, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao salvar o endereço do cliente: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirClienteEndereco, Guid.Empty, mensagemErro);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Edita um endereço de cliente
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Editar(RequisicaoEntidadeDto <ClienteEnderecoDto> requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Editar(requisicaoDto, ref retornoDto))
{
return(false);
}
ClienteEnderecoVo clienteEnderecoVo = new ClienteEnderecoVo();
string mensagemErro = "";
// Obtém o endereço
if (!ObterPorIdBd(requisicaoDto.EntidadeDto.Id, out clienteEnderecoVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas para encontrar o endereço do cliente: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarClienteEndereco, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
// Se houver endereço preenchido e ele não existir ainda
if (requisicaoDto.EntidadeDto.Endereco.Id == Guid.Empty &&
!string.IsNullOrWhiteSpace(requisicaoDto.EntidadeDto.Endereco.Cep))
{
requisicaoDto.EntidadeDto.Endereco.Id = Guid.NewGuid();
CepBll cepBll = new CepBll(this.pizzaByteContexto, false);
RequisicaoEntidadeDto <CepDto> requisicaoCepDto = new RequisicaoEntidadeDto <CepDto>()
{
IdUsuario = requisicaoDto.IdUsuario,
Identificacao = requisicaoDto.Identificacao,
EntidadeDto = requisicaoDto.EntidadeDto.Endereco
};
// Incluir o endereço
if (!cepBll.Incluir(requisicaoCepDto, ref retornoDto))
{
// Logado na BLL de CEP
return(false);
}
}
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref clienteEnderecoVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas ao converter o endereço do cliente para Vo: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarClienteEndereco, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!EditarBd(clienteEnderecoVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao editar os novos dados do clienteEndereco: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarClienteEndereco, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao salvar os novos dados: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarClienteEndereco, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public ActionResult Editar(UsuarioModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para editar um usuário é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
string senhaCriptografada = "";
if (!string.IsNullOrWhiteSpace(model.Senha))
{
UtilitarioBll.CriptografarSenha(model.Senha, ref senhaCriptografada);
}
if (string.IsNullOrWhiteSpace(model.SenhaAntiga))
{
ModelState.AddModelError("", "Para alterar os dados do usuário informa a senha atual.");
return(View(model));
}
string senhaAntigaCriptografada = "";
UtilitarioBll.CriptografarSenha(model.SenhaAntiga, ref senhaAntigaCriptografada);
//Converte para DTO
UsuarioDto usuarioDto = new UsuarioDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref usuarioDto, ref mensagemErro))
{
ViewBag.MensagemErro = mensagemErro;
return(View("Erro"));
}
usuarioDto.SenhaAntiga = senhaAntigaCriptografada;
if (string.IsNullOrWhiteSpace(senhaCriptografada))
{
usuarioDto.Senha = senhaAntigaCriptografada;
}
else
{
usuarioDto.Senha = senhaCriptografada;
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <UsuarioDto> requisicaoDto = new RequisicaoEntidadeDto <UsuarioDto>()
{
EntidadeDto = usuarioDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
UsuarioBll usuarioBll = new UsuarioBll(true);
usuarioBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do usuario
return(RedirectToAction("Index"));
}
/// <summary>
/// Edita um cep
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Editar(RequisicaoEntidadeDto <CepDto> requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Editar(requisicaoDto, ref retornoDto))
{
return(false);
}
// Apenas usuários ADM podem editar cepes
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para editar os cepes é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
// Não deixar incluir um cep repetido
CepVo cepVo = new CepVo();
if (!VerificarCepExistente(requisicaoDto.EntidadeDto, ref cepVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao validar o Cpf: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (cepVo != null && cepVo.Excluido == true)
{
if (!ExcluirDefinitivoBd(cepVo.Id, ref mensagemErro))
{
mensagemErro = $"Houve um erro ao deletar o cep duplicado.";
return(false);
}
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao excluir o cep duplicado: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
else if (cepVo != null && cepVo.Excluido == false)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Esse cadastro (CEP) já existe, não é possível incluir cadastros duplicados";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!ObterPorIdBd(requisicaoDto.EntidadeDto.Id, out cepVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas para encontrar o cep: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref cepVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas ao converter o cep para Vo: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!EditarBd(cepVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao editar os novos dados do cep: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao salvar os novos dados: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarCep, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
