/// <summary>
/// Preenche uma requição com a identificação e id do usuário
/// </summary>
/// <param name="requisicaoDto"></param>
/// <returns></returns>
public static bool RetornarAutenticacaoRequisicaoPreenchida(BaseRequisicaoDto requisicaoDto)
{
UsuarioBll usuarioBll = new UsuarioBll(true);
string senhaCriptografada = "";
UtilitarioBll.CriptografarSenha(DateTime.Now.AddDays(-2).Date.ToString("dd/MM/yyyy").Replace("/", ""), ref senhaCriptografada);
RequisicaoFazerLoginDto requisicaoLoginDto = new RequisicaoFazerLoginDto()
{
Email = "Suporte",
Senha = senhaCriptografada
};
RetornoFazerLoginDto retornoDto = new RetornoFazerLoginDto();
if (!usuarioBll.FazerLogin(requisicaoLoginDto, ref retornoDto))
{
return(false);
}
requisicaoDto.Identificacao = retornoDto.Identificacao;
requisicaoDto.IdUsuario = retornoDto.IdUsuario;
return(true);
}
/// <summary>
/// Exclui os itens de um pedido
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool ExcluirItensPedido(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirListaItensPedido, Guid.Empty, mensagemErro);
return(false);
}
List <PedidoItemVo> listaExclusao;
IQueryable <PedidoItemVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar os itens: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirListaItensPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Obter os itens do pedido
query = query.Where(p => p.IdPedido == requisicaoDto.Id);
listaExclusao = query.ToList();
// Se algum item não veioda requisição
foreach (var item in listaExclusao)
{
// Prepara a exclusão no banco de dados
if (!ExcluirBd(item.Id, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao excluir o item do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirListaItensPedido, 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.ExcluirListaItensPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
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);
}
/// <summary>
/// Edita as contas vindas de pedidos
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool EstornarContasPedido(RequisicaoCancelarPedidoDto requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EstornarContasReceberPedido, Guid.Empty, mensagemErro);
return(false);
}
List <ContaReceberVo> listaContas;
IQueryable <ContaReceberVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar as contas: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EstornarContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
listaContas = query.Where(p => p.IdPedido == requisicaoDto.Id).ToList();
foreach (var conta in listaContas)
{
conta.Status = StatusConta.Estornada;
if (!EditarBd(conta, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao editar as contas: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EstornarContasReceberPedido, 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.EditarListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public ActionResult Login(LoginModel model)
{
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
string senhaCriptografada = "";
UtilitarioBll.CriptografarSenha(model.SenhaLogin, ref senhaCriptografada);
model.SenhaLogin = senhaCriptografada;
//Converter para DTO
string mensagemErro = "";
RequisicaoFazerLoginDto requisicaoFazerLoginDto = new RequisicaoFazerLoginDto();
if (!model.ConverterModelParaDto(ref requisicaoFazerLoginDto, ref mensagemErro))
{
ModelState.AddModelError("", mensagemErro);
return(View(model));
}
//Preparar requisição e retorno
RetornoFazerLoginDto retorno = new RetornoFazerLoginDto();
//Consumir o serviço
UsuarioBll usuarioBll = new UsuarioBll(true);
usuarioBll.FazerLogin(requisicaoFazerLoginDto, 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));
}
//Guardar na sessão
SessaoUsuario.SessaoLogin.Identificacao = retorno.Identificacao;
SessaoUsuario.SessaoLogin.IdUsuario = retorno.IdUsuario;
SessaoUsuario.SessaoLogin.NomeUsuario = retorno.NomeUsuario;
SessaoUsuario.SessaoLogin.Administrador = retorno.UsuarioAdministrador;
//Retornar para index do site
if (string.IsNullOrWhiteSpace(model.EnderecoRetorno))
{
return(Redirect("Inicio"));
}
else
{
return(Redirect(model.EnderecoRetorno));
}
}
/// <summary>
/// Obtém uma taxa de entrega pelo bairro, se não existir, retorna nulo
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterTaxaPorBairro(RequisicaoObterTaxaPorBairroDto requisicaoDto, ref RetornoObterDto <TaxaEntregaDto> retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTaxaPorBairro, Guid.Empty, mensagemErro);
return(false);
}
// Obter a query primária
IQueryable <TaxaEntregaVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar as taxas de entrega: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTaxaPorBairro, Guid.Empty, retornoDto.Mensagem);
return(false);
}
string bairro = string.IsNullOrWhiteSpace(requisicaoDto.BairroCidade) ? "" : requisicaoDto.BairroCidade.Trim();
query = query.Where(p => p.BairroCidade == bairro);
TaxaEntregaVo taxaEntregaVo = query.FirstOrDefault();
if (taxaEntregaVo != null)
{
TaxaEntregaDto taxaEntregaDto = new TaxaEntregaDto();
if (!ConverterVoParaDto(taxaEntregaVo, ref taxaEntregaDto, ref mensagemErro))
{
retornoDto.Mensagem = mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTaxaPorBairro, Guid.Empty, retornoDto.Mensagem);
return(false);
}
retornoDto.Entidade = taxaEntregaDto;
}
else
{
retornoDto.Entidade = null;
}
retornoDto.Retorno = true;
return(true);
}
/// <summary>
/// Obtém um usuário pelo ID (não traz a senha no objeto)
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <UsuarioDto> retornoDto)
{
if (!base.Obter(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para consultar os usuários é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
UsuarioVo usuarioVo;
if (!ObterPorIdBd(requisicaoDto.Id, out usuarioVo, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao obter o usuario: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
UsuarioDto usuarioDto = new UsuarioDto();
if (!ConverterVoParaDto(usuarioVo, ref usuarioDto, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao converter o usuário: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterUsuario, usuarioVo.Id, retornoDto.Mensagem);
return(false);
}
retornoDto.Entidade = usuarioDto;
retornoDto.Entidade.Senha = "";
retornoDto.Mensagem = "Ok";
retornoDto.Retorno = true;
return(true);
}
/// <summary>
/// Exclui um cliente do banco de dados a partir do ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Excluir(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para excluir clientes é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCliente, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Excluir os endereços
ClienteEnderecoBll clienteEnderecoBll = new ClienteEnderecoBll(pizzaByteContexto, false);
if (!clienteEnderecoBll.ExcluirPorIdCliente(requisicaoDto, ref retornoDto))
{
retornoDto.Retorno = false;
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCliente, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCliente, requisicaoDto.Id, "Cliente excluído.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Exclui um produto do banco de dados a partir do ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Excluir(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para excluir produtos é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
if (requisicaoDto.Id == UtilitarioBll.RetornaIdProdutoPromocao())
{
retornoDto.Mensagem = "Erro ao obter o produto: Cadastro não encontrado";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, retornoDto.Mensagem + " (Produto promoção)");
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirProduto, requisicaoDto.Id, "Produto excluído.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Obtem o total de entrega por profissional
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterTotalEntregaPorProfissional(RequisicaoDataDto requisicaoDto, ref RetornoObterTotalEntregaPorProfissionalDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTotalEntregaPorProfissional, Guid.Empty, mensagemErro);
return(false);
}
List <SqlParameter> listaFiltros = new List <SqlParameter>();
listaFiltros.Add(new SqlParameter("dataCaixa", requisicaoDto.Data.Date));
string query = "SELECT CAST(ISNULL(SUM(TaxaEntrega), 0) AS float) AS TotalEntregas," +
" f.Nome AS NomeProfissional" +
" FROM PizzaByte.PedidosEntregas AS e" +
" INNER JOIN PizzaByte.Pedidos AS p ON e.IdPedido = p.Id" +
" INNER JOIN PizzaByte.Funcionarios AS f ON e.IdFuncionario = f.Id AND f.Inativo = 0" +
" AND f.Excluido = 0" +
" WHERE CAST(e.DataInclusao AS Date) = @dataCaixa AND e.Inativo = 0 AND e.Excluido = 0" +
" AND e.IdFuncionario IS NOT NULL" +
" GROUP BY f.Nome" +
" ORDER BY f.Nome";
try
{
PizzaByteContexto contexto = new PizzaByteContexto();
retornoDto.ListaTotais = contexto.Database.SqlQuery <TotalPorProfissional>(query, listaFiltros.ToArray()).ToList();
retornoDto.Retorno = true;
retornoDto.Mensagem = "Ok";
return(true);
}
catch (Exception ex)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao obter os dados: " + ex.Message;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterTotalEntregaPorProfissional, Guid.Empty, mensagemErro);
return(false);
}
}
/// <summary>
/// Obtém um produto pelo ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <ProdutoDto> retornoDto)
{
if (!base.Obter(requisicaoDto, ref retornoDto))
{
return(false);
}
if (requisicaoDto.Id == UtilitarioBll.RetornaIdProdutoPromocao())
{
retornoDto.Mensagem = "Erro ao obter o produto: Cadastro não encontrado";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem + " (Produto promoção)");
return(false);
}
string mensagemErro = "";
ProdutoVo produtoVo;
if (!ObterPorIdBd(requisicaoDto.Id, out produtoVo, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao obter o produto: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
ProdutoDto produtoDto = new ProdutoDto();
if (!ConverterVoParaDto(produtoVo, ref produtoDto, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao converter o produto: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterProduto, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
retornoDto.Entidade = produtoDto;
retornoDto.Mensagem = "Ok";
retornoDto.Retorno = true;
return(true);
}
/// <summary>
/// Obtem os dados necessários para popular a tela de caixa
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterFormasPagamentoDia(RequisicaoDataDto requisicaoDto, ref RetornoObterResumoCaixaDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterInformacoesDashboard, Guid.Empty, mensagemErro);
return(false);
}
List <SqlParameter> listaFiltros = new List <SqlParameter>();
string query = "SELECT CAST(ISNULL(SUM(RecebidoDinheiro), 0) AS float) AS RecebidoDinheiro," +
" CAST(ISNULL(SUM(RecebidoCredito), 0) AS float) AS RecebidoCredito," +
" CAST(ISNULL(SUM(RecebidoDebito), 0) AS float) AS RecebidoDebito," +
" CAST(ISNULL(SUM(Troco), 0) AS float) AS Troco," +
" CAST(ISNULL(SUM(TaxaEntrega), 0) AS float) AS TaxaEntrega" +
" FROM PizzaByte.Pedidos" +
" WHERE CAST(DataInclusao AS Date) = @dataCaixa AND Inativo = 0 AND Excluido = 0";
listaFiltros.Add(new SqlParameter("dataCaixa", requisicaoDto.Data.Date));
try
{
PizzaByteContexto contexto = new PizzaByteContexto();
retornoDto = contexto.Database.SqlQuery <RetornoObterResumoCaixaDto>(query, listaFiltros.ToArray()).FirstOrDefault();
retornoDto.TotalVendas = (retornoDto.RecebidoDinheiro - retornoDto.Troco) + retornoDto.RecebidoCredito + retornoDto.RecebidoDebito;
retornoDto.Retorno = true;
retornoDto.Mensagem = "Ok";
return(true);
}
catch (Exception ex)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao obter os dados: " + ex.Message;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterInformacoesDashboard, Guid.Empty, mensagemErro);
return(false);
}
}
/// <summary>
/// Obtém os detalhes do pedido de uma entrega
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterPedidoResumido(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <PedidoResumidoDto> retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedidoResumido, requisicaoDto.Id, mensagemErro);
return(false);
}
PedidoVo pedidoVo;
if (!ObterPorIdBd(requisicaoDto.Id, out pedidoVo, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao obter o pedido: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
retornoDto.Entidade = new PedidoResumidoDto()
{
PedidoIfood = pedidoVo.PedidoIfood,
RecebidoCredito = pedidoVo.RecebidoCredito,
RecebidoDebito = pedidoVo.RecebidoDebito,
RecebidoDinheiro = pedidoVo.RecebidoDinheiro,
TaxaEntrega = pedidoVo.TaxaEntrega,
Troco = pedidoVo.Troco,
Total = pedidoVo.Total,
Tipo = pedidoVo.Tipo,
Id = pedidoVo.Id
};
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Traz uma lista ID, Nome dos usuários para popular combos
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="listaUsuarios"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
public bool ObterListaParaSelecao(BaseRequisicaoDto requisicaoDto, ref RetornoObterDicionarioDto <Guid, string> retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaUsuariosParaSelecao, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Obter a query primária
IQueryable <UsuarioVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = $"Erro ao obter a query: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaUsuario, Guid.Empty, retornoDto.Mensagem);
return(false);
}
try
{
retornoDto.ListaEntidades = query.Where(p => p.Excluido == false).OrderBy(p => p.Nome).Select(p => new { p.Id, p.Nome }).AsEnumerable().ToDictionary(p => p.Id, p => p.Nome);
return(true);
}
catch (Exception ex)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = $"Erro ao obter a query: {ex.Message}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaUsuario, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
/// <summary>
/// Exclui uma conta do banco de dados a partir do ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Excluir(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para excluir a conta é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirContaReceber, requisicaoDto.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.ExcluirContaReceber, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirContaReceber, requisicaoDto.Id, "Conta a receber excluída.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Inclui/edita as contas vindas de pedidos
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool IncluirContasPedido(RequisicaoListaEntidadesDto <ContaReceberDto> requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirListaContasReceberPedido, Guid.Empty, mensagemErro);
return(false);
}
if (requisicaoDto.ListaEntidadesDto.Count <= 0)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Informe as contas que deseja incluir.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
//Confirmar o id do pedido e um novo id para cada item
requisicaoDto.ListaEntidadesDto.ForEach(p => p.IdPedido = requisicaoDto.IdComum);
requisicaoDto.ListaEntidadesDto.ForEach(p => p.Id = (p.Id == null || p.Id == Guid.Empty) ? Guid.NewGuid() : p.Id);
// Para cada item
foreach (var item in requisicaoDto.ListaEntidadesDto)
{
if (!item.ValidarEntidade(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirListaContasReceberPedido, Guid.Empty, mensagemErro);
return(false);
}
ContaReceberVo itemVo = new ContaReceberVo();
if (!ConverterDtoParaVo(item, ref itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a conta do pedido para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar a conta do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirListaContasReceberPedido, 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.IncluirListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Obtém uma conta pelo ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Obter(RequisicaoObterDto requisicaoDto, ref RetornoObterDto <ContaPagarDto> retornoDto)
{
if (!base.Obter(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
ContaPagarVo contaPagarVo;
if (!ObterPorIdBd(requisicaoDto.Id, out contaPagarVo, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao obter a conta: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterContaPagar, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
ContaPagarDto contaPagarDto = new ContaPagarDto();
if (!ConverterVoParaDto(contaPagarVo, ref contaPagarDto, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao converter a conta: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterContaPagar, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
if (contaPagarDto.IdFornecedor != null && contaPagarDto.IdFornecedor != Guid.Empty)
{
requisicaoDto.Id = contaPagarDto.IdFornecedor.Value;
RetornoObterDto <FornecedorDto> retornoFornecedorDto = new RetornoObterDto <FornecedorDto>();
FornecedorBll fornecedorBll = new FornecedorBll(pizzaByteContexto, false);
if (!fornecedorBll.Obter(requisicaoDto, ref retornoFornecedorDto))
{
retornoDto.Mensagem = retornoFornecedorDto.Mensagem;
retornoDto.Retorno = false;
return(false);
}
if (retornoFornecedorDto.Mensagem == "Erro ao obter o fornecedor: Cadastro não encontrado")
{
contaPagarDto.NomeFornecedor = "Cadastro não encontro";
}
else
{
contaPagarDto.NomeFornecedor = retornoFornecedorDto.Entidade.NomeFantasia + " (CNPJ: " + UtilitarioBll.RetornarCnpjFormatado(retornoFornecedorDto.Entidade.Cnpj) + ")";
}
}
retornoDto.Entidade = contaPagarDto;
retornoDto.Mensagem = "Ok";
retornoDto.Retorno = true;
return(true);
}
/// <summary>
/// Cancela um pedido e sua entrega, se houver
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool CancelarPedido(RequisicaoCancelarPedidoDto requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, mensagemErro);
return(false);
}
PedidoVo pedidoVo = new PedidoVo();
if (!ObterPorIdBd(requisicaoDto.Id, out pedidoVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas para encontrar o pedido: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Mudar o inativo que se refere ao cancelado para true
pedidoVo.Inativo = true;
pedidoVo.JustificativaCancelamento = string.IsNullOrWhiteSpace(requisicaoDto.Justificativa) ? "" : requisicaoDto.Justificativa.Trim();
if (!EditarBd(pedidoVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao cancelar o pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Cancelar a entrega se houver
if (pedidoVo.Tipo == TipoPedido.Entrega)
{
PedidoEntregaBll pedidoEntregaBll = new PedidoEntregaBll(pizzaByteContexto, false);
if (!pedidoEntregaBll.CancelarEntrega(requisicaoDto, ref retornoDto))
{
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
// Cancelar contas
ContaReceberBll contaReceberBll = new ContaReceberBll(pizzaByteContexto, false);
if (!contaReceberBll.EstornarContasPedido(requisicaoDto, ref retornoDto))
{
return(false);
}
// Cancelar itens
PedidoItemBll pedidoItemBll = new PedidoItemBll(pizzaByteContexto, false);
if (!pedidoItemBll.EstornarLista(requisicaoDto, ref retornoDto))
{
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao salvar o cancelamento: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.CancelarPedido, requisicaoDto.Id, "Pedido cancelado.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Edita as contas vindas de pedidos
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool EditarContasPedido(RequisicaoListaEntidadesDto <ContaReceberDto> requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, Guid.Empty, mensagemErro);
return(false);
}
List <ContaReceberVo> listaContas;
IQueryable <ContaReceberVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar as contas: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
listaContas = query.Where(p => p.IdPedido == requisicaoDto.IdComum).ToList();
foreach (var conta in listaContas)
{
if (!ExcluirDefinitivoBd(conta.Id, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao excluir as contas: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
//Confirmar o id do pedido e um novo id para cada item
requisicaoDto.ListaEntidadesDto.ForEach(p => p.IdPedido = requisicaoDto.IdComum);
requisicaoDto.ListaEntidadesDto.ForEach(p => p.Id = (p.Id == null || p.Id == Guid.Empty) ? Guid.NewGuid() : p.Id);
// Para cada item
foreach (var item in requisicaoDto.ListaEntidadesDto)
{
if (!item.ValidarEntidade(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, Guid.Empty, mensagemErro);
return(false);
}
ContaReceberVo itemVo = new ContaReceberVo();
if (!ConverterDtoParaVo(item, ref itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a conta do pedido para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar a conta do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaContasReceberPedido, 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.EditarListaContasReceberPedido, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Exclui um pedido do banco de dados a partir do ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para excluir pedidos é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
if (!base.Excluir(requisicaoDto, ref retornoDto))
{
return(false);
}
//Excluir itens
PedidoItemBll pedidoItemBll = new PedidoItemBll(pizzaByteContexto, false);
if (!pedidoItemBll.ExcluirItensPedido(requisicaoDto, ref retornoDto))
{
return(false);
}
//Excluir entregas, se houver
PedidoEntregaBll pedidoEntregaBll = new PedidoEntregaBll(pizzaByteContexto, false);
if (!pedidoEntregaBll.ExcluirPorIdPedido(requisicaoDto, ref retornoDto))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Excluir as contas
ContaReceberBll contaReceberBll = new ContaReceberBll(pizzaByteContexto, false);
if (!contaReceberBll.ExcluirContasPedido(requisicaoDto, ref retornoDto))
{
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedido, requisicaoDto.Id, "Pedido excluído.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Obtém uma lista de pedidoItems com filtros aplicados, podendo ser paginada
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool ObterListaFiltrada(RequisicaoObterListaDto requisicaoDto, ref RetornoObterListaDto <PedidoItemDto> retornoDto)
{
if (!base.ObterListaFiltrada(requisicaoDto, ref retornoDto))
{
return(false);
}
string mensagemErro = "";
IQueryable <PedidoItemVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar os itens: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Aplicar os filtros
foreach (var filtro in requisicaoDto.ListaFiltros)
{
switch (filtro.Key)
{
case "DESCRICAOPRODUTO":
query = query.Where(p => p.DescricaoProduto.Contains(filtro.Value));
break;
case "PRECOMAIOR":
float precoMaior;
if (!float.TryParse(filtro.Value, out precoMaior))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de preço (maior que).";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.PrecoProduto >= precoMaior);
break;
case "PRECOMENOR":
float precoMenor;
if (!float.TryParse(filtro.Value, out precoMenor))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de preço (menor que).";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.PrecoProduto <= precoMenor);
break;
case "PRECO":
float preco;
if (!float.TryParse(filtro.Value, out preco))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de preço.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.PrecoProduto == preco);
break;
case "TIPOPRODUTO":
int tipo;
if (!int.TryParse(filtro.Value, out tipo))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de tipo do produto.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.TipoProduto == (TipoProduto)tipo);
break;
case "IDPEDIDO":
Guid idPedido;
if (!Guid.TryParse(filtro.Value, out idPedido))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de id do pedido.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.IdPedido == idPedido);
break;
case "IDPRODUTO":
Guid idProduto;
if (!Guid.TryParse(filtro.Value, out idProduto))
{
retornoDto.Mensagem = $"Problema ao converter o filtro de id do produto.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.IdProduto == idProduto);
break;
case "INATIVO":
bool filtroInativo;
if (!bool.TryParse(filtro.Value, out filtroInativo))
{
retornoDto.Mensagem = $"Fala ao converter o filtro de 'inativo'.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.Inativo == filtroInativo);
break;
default:
retornoDto.Mensagem = $"O filtro {filtro.Key} não está definido para esta pesquisa.";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
requisicaoDto.CampoOrdem = string.IsNullOrWhiteSpace(requisicaoDto.CampoOrdem) ? "" : requisicaoDto.CampoOrdem.ToUpper().Trim();
switch (requisicaoDto.CampoOrdem)
{
case "DESCRICAOPRODUTO":
query = query.OrderBy(p => p.DescricaoProduto).ThenByDescending(p => p.PrecoProduto);
break;
case "PRECOCRESCENTE":
query = query.OrderBy(p => p.PrecoProduto).ThenBy(p => p.DescricaoProduto);
break;
case "PRECODESCRESCENTE":
query = query.OrderByDescending(p => p.PrecoProduto).ThenBy(p => p.DescricaoProduto);
break;
default:
query = query.OrderBy(p => p.DescricaoProduto).ThenByDescending(p => p.PrecoProduto);
break;
}
double totalItens = query.Count();
if (totalItens == 0)
{
retornoDto.Mensagem = "Nenhum resultado encontrado.";
retornoDto.Retorno = true;
return(true);
}
if (!requisicaoDto.NaoPaginarPesquisa)
{
double paginas = totalItens <= requisicaoDto.NumeroItensPorPagina ? 1 : totalItens / requisicaoDto.NumeroItensPorPagina;
retornoDto.NumeroPaginas = (int)Math.Ceiling(paginas);
int pular = (requisicaoDto.Pagina - 1) * requisicaoDto.NumeroItensPorPagina;
query = query.Skip(pular).Take(requisicaoDto.NumeroItensPorPagina);
}
List <PedidoItemVo> listaVo = query.ToList();
foreach (var pedidoItem in listaVo)
{
PedidoItemDto pedidoItemDto = new PedidoItemDto();
if (!ConverterVoParaDto(pedidoItem, ref pedidoItemDto, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao converter para DTO: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaPedidoItem, pedidoItem.Id, retornoDto.Mensagem);
return(false);
}
if (pedidoItem.IdProduto == UtilitarioBll.RetornaIdProdutoPromocao())
{
retornoDto.ListaEntidades.Insert(0, pedidoItemDto);
}
else
{
retornoDto.ListaEntidades.Add(pedidoItemDto);
}
}
retornoDto.Mensagem = "Ok";
retornoDto.Retorno = true;
return(true);
}
/// <summary>
/// Edita uma lista de itens de um pedido no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool EditarLista(RequisicaoListaEntidadesDto <PedidoItemDto> requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, Guid.Empty, mensagemErro);
return(false);
}
if (requisicaoDto.ListaEntidadesDto.Count <= 0)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Informe ao menos um item para editar.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
List <PedidoItemVo> listaExclusao;
IQueryable <PedidoItemVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar os itens: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Obter os itens do pedido
query = query.Where(p => p.IdPedido == requisicaoDto.IdComum);
listaExclusao = query.ToList();
//Confirmar o id do pedido e um novo id para cada item
requisicaoDto.ListaEntidadesDto.ForEach(p => p.IdPedido = requisicaoDto.IdComum);
requisicaoDto.ListaEntidadesDto.ForEach(p => p.Id = (p.Id == null || p.Id == Guid.Empty) ? Guid.NewGuid() : p.Id);
// Para cada item
foreach (var item in requisicaoDto.ListaEntidadesDto)
{
if (!item.ValidarEntidade(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaPedidoItem, Guid.Empty, mensagemErro);
return(false);
}
PedidoItemVo itemVo = listaExclusao.Where(p => p.Id == item.Id).FirstOrDefault();
if (itemVo == null)
{
// Se não existir, incluir
itemVo = new PedidoItemVo();
if (!ConverterDtoParaVo(item, ref itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter o item do pedido para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar o item do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarListaPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
else
{
listaExclusao.Remove(itemVo);
// Se existir e mudar algum dado, editar
if (item.PrecoProduto != itemVo.PrecoProduto || item.Quantidade != itemVo.Quantidade)
{
itemVo.Quantidade = item.Quantidade;
itemVo.PrecoProduto = item.PrecoProduto;
// Prepara a edição no banco de dados
if (!EditarBd(itemVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao salvar o item do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
}
}
// Se algum item não veioda requisição
foreach (var item in listaExclusao)
{
// Prepara a exclusão no banco de dados
if (!ExcluirBd(item.Id, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao excluir o item do pedido: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoItem, 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.EditarPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
public ActionResult Incluir(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 incluir um usuário é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Checar se a senha foi preenchida
if (string.IsNullOrWhiteSpace(model.Senha))
{
ModelState.AddModelError("Senha", "A senha é obrigatória para incluir o usuário");
return(View(model));
}
//Converter para DTO
UsuarioDto usuarioDto = new UsuarioDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref usuarioDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
string senhaCriptografada = "";
if (!string.IsNullOrWhiteSpace(model.Senha))
{
UtilitarioBll.CriptografarSenha(model.Senha, ref senhaCriptografada);
}
usuarioDto.Senha = senhaCriptografada;
usuarioDto.Id = Guid.NewGuid();
//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.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"));
}
/// <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);
}
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>
/// Altera o funcionário responsável pela entrega
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool AlterarFuncionarioEntrega(RequisicaoAlterarFuncionarioEntregaDto requisicaoDto, ref RetornoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, mensagemErro);
return(false);
}
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para alterar o funcionário das entregas é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, retornoDto.Mensagem);
}
// Validar o id da entrega
if (requisicaoDto.Id == Guid.Empty || requisicaoDto.Id == null)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "O id da entrega não foi preenchido.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, mensagemErro);
return(false);
}
// Validar o id do funcionário
if (requisicaoDto.IdFuncionario == Guid.Empty || requisicaoDto.IdFuncionario == null)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "O funcionário não foi informado.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, mensagemErro);
return(false);
}
PedidoEntregaVo entregaVo;
if (!ObterPorIdBd(requisicaoDto.Id, out entregaVo, ref mensagemErro))
{
retornoDto.Mensagem = "Erro ao obter o pedido: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Preencher os dados da conferência
entregaVo.IdFuncionario = requisicaoDto.IdFuncionario;
if (!EditarBd(entregaVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao editar os novos dados da entrega: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.AlterarFuncionarioEntrega, requisicaoDto.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.AlterarFuncionarioEntrega, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Obtem o endereço pelo CEP
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterPorCep(RequisicaoObterCepPorCepDto requisicaoDto, ref RetornoObterDto <CepDto> retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Mensagem = mensagemErro;
return(false);
}
if (string.IsNullOrWhiteSpace(requisicaoDto.Cep))
{
retornoDto.Mensagem = $"Informe um CEP para obter o endereço";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Obter a query primária
IQueryable <CepVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar os CEPs: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
requisicaoDto.Cep = requisicaoDto.Cep.Replace("-", "");
query = query.Where(p => p.Cep == requisicaoDto.Cep.Trim());
CepVo cepVo = query.FirstOrDefault();
if (cepVo == null)
{
retornoDto.Retorno = true;
retornoDto.Mensagem = "CEP não encontrado";
retornoDto.Entidade = null;
return(true);
}
else
{
CepDto cepDto = new CepDto();
if (!ConverterVoParaDto(cepVo, ref cepDto, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = $"Erro ao converter o CEP para DTO: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCepPorCep, Guid.Empty, retornoDto.Mensagem);
return(false);
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "Ok";
retornoDto.Entidade = cepDto;
return(true);
}
}
/// <summary>
/// Inclui uma movimentação de caixa no banco de dados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Incluir(RequisicaoEntidadeDto <MovimentoCaixaDto> 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 = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para inclur movimentos de caixa é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirMovimentoCaixa, Guid.Empty, retornoDto.Mensagem);
return(false);
}
MovimentoCaixaVo movimentoCaixaVo = new MovimentoCaixaVo();
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref movimentoCaixaVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a movimentação de caixa para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirMovimentoCaixa, Guid.Empty, retornoDto.Mensagem);
return(false);
}
// Prepara a inclusão no banco de dados
if (!IncluirBd(movimentoCaixaVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao converter a movimentação de caixa para VO: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirMovimentoCaixa, 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.IncluirMovimentoCaixa, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirMovimentoCaixa, movimentoCaixaVo.Id, retornoDto.Mensagem);
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Exclui os endereços de um cliente pelo seu ID
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ExcluirPorIdCliente(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
if (requisicaoDto.Id == Guid.Empty)
{
retornoDto.Mensagem = "Informe o ID do cliente para excluir seus endereços.";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, mensagemErro);
return(false);
}
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para excluir endereços de clientes é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
// Obter a query primária
IQueryable <ClienteEnderecoVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao listar os endereços de clientes: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, Guid.Empty, retornoDto.Mensagem);
return(false);
}
query = query.Where(p => p.IdCliente == requisicaoDto.Id);
List <ClienteEnderecoVo> enderecosEncontrados = query.ToList();
// Excluir os endereços encontrados
foreach (var enderecoVo in enderecosEncontrados)
{
if (!ExcluirBd(enderecoVo.Id, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao excluir o endereço do cliente: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, Guid.Empty, retornoDto.Mensagem);
return(false);
}
if (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Houve um problema ao excluir o endereço do cliente: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, mensagemErro);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirEnderecosPorIdCliente, requisicaoDto.Id, "endereço excluído.");
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Edita uma entrega
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Editar(RequisicaoEntidadeDto <PedidoEntregaDto> requisicaoDto, ref RetornoDto retornoDto)
{
if (!base.Editar(requisicaoDto, ref retornoDto))
{
return(false);
}
// Apenas usuários ADM podem editar pedidoEntregaes
string mensagemErro = "";
if (!UtilitarioBll.ValidarUsuarioAdm(requisicaoDto.Identificacao, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Este usuário não é administrador. Para editar as entregas é necessário " +
$"logar com um usuário administrador. {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoEntrega, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
PedidoEntregaVo pedidoEntregaVo = new PedidoEntregaVo();
if (!ObterPorIdBd(requisicaoDto.EntidadeDto.Id, out pedidoEntregaVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas para encontrar a entrega: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoEntrega, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!ConverterDtoParaVo(requisicaoDto.EntidadeDto, ref pedidoEntregaVo, ref mensagemErro))
{
retornoDto.Mensagem = "Problemas ao converter a entrega para Vo: " + mensagemErro;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoEntrega, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
if (!EditarBd(pedidoEntregaVo, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Falha ao editar os novos dados da entrega: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.EditarPedidoEntrega, 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.EditarPedidoEntrega, requisicaoDto.EntidadeDto.Id, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
