/// <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
}
}
public static RetornoDto ExecutaQuery(string commandText)
{
RetornoDto RetMsg = new RetornoDto();
try
{
string constring = ConfigurationManager.AppSettings["constr"].ToString();
using (SQLiteConnection con = new SQLiteConnection("Data Source =" + constring + ";" + "Version = 3;"))
{
using (SQLiteCommand cmd = new SQLiteCommand(commandText, con))
{
con.Open();
int rowsAffected = cmd.ExecuteNonQuery();
con.Close();
}
}
RetMsg.OK = "S";
RetMsg.Mensagem = "Sucesso";
}
catch (Exception ex)
{
RetMsg.OK = "N";
RetMsg.Mensagem = ex.Message;
}
return(RetMsg);
}
/// <summary>
/// Obtem uma listra filtrada de entregas
/// </summary>
/// <param name="filtros"></param>
/// <returns></returns>
public string ConferirEntrega(Guid idEntrega, float valorRetorno)
{
RetornoDto retornoDto = new RetornoDto();
if (!SessaoUsuario.SessaoLogin.Administrador)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Para alterar os dados de uma entrega é necessário " +
$"logar com um usuário administrador.";
}
else
{
//Requisição para conferir
RequisicaoConferirEntregaDto requisicaoDto = new RequisicaoConferirEntregaDto()
{
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
ValorRetornado = valorRetorno,
Id = idEntrega
};
//Consumir o serviço
PedidoEntregaBll entregaBll = new PedidoEntregaBll(true);
entregaBll.ConferirEntrega(requisicaoDto, ref retornoDto);
}
string retorno = new JavaScriptSerializer().Serialize(retornoDto);
return(retorno);
}
/// <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);
}
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>
/// 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);
}
/// <summary>
/// Exclui um cep 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 (salvar)
{
// Salva as alterações
if (!pizzaByteContexto.Salvar(ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCep, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
}
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirCep, requisicaoDto.Id, "CEP excluído.");
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Exclui não será implementado para o item, pois a exclusão é feita em conjunto
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public override bool Excluir(RequisicaoObterDto requisicaoDto, ref RetornoDto retornoDto)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Método não implementado para esta entidade";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirPedidoItem, Guid.Empty, retornoDto.Mensagem);
return(false);
}
public void ObterIncluirEditarListaTaxas()
{
BaseRequisicaoDto requisicaoDto = new BaseRequisicaoDto();
Assert.IsTrue(Utilidades.RetornarAutenticacaoRequisicaoPreenchida(requisicaoDto));
TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(true);
// Obter a lista
RetornoObterListaDto <TaxaEntregaDto> retornoDto = new RetornoObterListaDto <TaxaEntregaDto>();
taxaEntregaBll.ObterListaBairrosComTaxa(requisicaoDto, ref retornoDto);
Assert.AreEqual(true, retornoDto.Retorno);
RequisicaoListaEntidadesDto <TaxaEntregaDto> requisicaoIncluirDto = new RequisicaoListaEntidadesDto <TaxaEntregaDto>()
{
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario,
ListaEntidadesDto = retornoDto.ListaEntidades
};
RetornoDto retornoIncluirDto = new RetornoDto();
taxaEntregaBll.IncluirEditarLista(requisicaoIncluirDto, ref retornoIncluirDto);
Assert.AreEqual(true, retornoDto.Retorno);
}
/// <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>
/// 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 ActionResult ExcluirCep(ExclusaoModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
{
Id = model.Id,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
CepBll cepBll = new CepBll(true);
cepBll.Excluir(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View("Excluir", model));
}
TempData["Retorno"] = "EXCLUIDO";
//Voltar para a index de cep
return(RedirectToAction("Index"));
}
/// <summary>
/// Exclui uma mensagem de suporte
/// </summary>
/// <param name="filtros"></param>
/// <returns></returns>
public string ExcluirMensagem(Guid idMensagem)
{
RetornoDto retornoDto = new RetornoDto();
if (idMensagem == Guid.Empty)
{
retornoDto.Mensagem = "O id da mensagem não foi informado.";
retornoDto.Retorno = false;
}
//Requisição para excluir
RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
{
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
Id = idMensagem
};
//Consumir o serviço
SuporteBll suporteBll = new SuporteBll(true);
suporteBll.Excluir(requisicaoDto, ref retornoDto);
string retorno = new JavaScriptSerializer().Serialize(retornoDto);
return(retorno);
}
/// <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 ConfigurarTaxas(List <TaxaEntregaModel> 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));
}
string mensagemErro = "";
List <TaxaEntregaDto> listaDtos = new List <TaxaEntregaDto>();
//Converter para DTO
foreach (var taxa in model)
{
TaxaEntregaDto produtoDto = new TaxaEntregaDto();
if (!taxa.ConverterModelParaDto(ref produtoDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
listaDtos.Add(produtoDto);
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoListaEntidadesDto <TaxaEntregaDto> requisicaoDto = new RequisicaoListaEntidadesDto <TaxaEntregaDto>()
{
ListaEntidadesDto = listaDtos,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
TaxaEntregaBll produtoBll = new TaxaEntregaBll(true);
produtoBll.IncluirEditarLista(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 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"));
}
public RetornoDto Inserir(long?marcaid, string nome, string descricao)
{
long?vMax = ObterID();
RetornoDto RetMsg = new RetornoDto();
string commando = "INSERT INTO patrimonio(marcaid, nome, descricao, ntombo) VALUES ('" + marcaid + "', '" + nome + "', '" + descricao + "', '" + vMax + "');";
return(ExecutaQuery(commando));
}
public ActionResult RestaurarBackup(ArquivoModel 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 restaurar um backup é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
//Validar a model recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converter para DTO
RequisicaoArquivoDto requisicaoDto = new RequisicaoArquivoDto
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref requisicaoDto, ref mensagemErro))
{
ModelState.AddModelError("", $"Erro ao converter para Dto: {mensagemErro}");
return(View(model));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
//Consumir o serviço
RecursosBdBll recursosBll = new RecursosBdBll();
recursosBll.RestaurarBackup(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"] = "BACKUPRESTAURADO";
//Retornar para inicio
return(RedirectToAction("Inicio", "Usuario"));
}
/// <summary>
/// Exclui as contas vindas de pedidos
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
internal bool ExcluirContasPedido(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.ExcluirContasReceberPedido, requisicaoDto.Id, 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.ExcluirContasReceberPedido, requisicaoDto.Id, retornoDto.Mensagem);
return(false);
}
listaContas = query.Where(p => p.IdPedido == requisicaoDto.Id).ToList();
foreach (var conta in listaContas)
{
if (!ExcluirBd(conta.Id, ref mensagemErro))
{
retornoDto.Mensagem = $"Houve um problema ao excluir as contas: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ExcluirContasReceberPedido, conta.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.EditarListaContasReceberPedido, requisicaoDto.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 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 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);
}
/// <summary>
/// Restaura o banco de dados a partir do backup
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool RestaurarBackup(RequisicaoArquivoDto 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.RestaurarBackup, Guid.Empty, mensagemErro);
return(false);
}
try
{
PizzaByteContexto context = new PizzaByteContexto();
Byte[] bytes = Convert.FromBase64String(requisicaoDto.ArquivoBase64);
string comandosSql = Encoding.UTF8.GetString(bytes);
string backupDescriptografado = "";
if (!UtilitarioBll.DescriptografarString(comandosSql, ref backupDescriptografado))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao criptografar o backup";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.RestaurarBackup, Guid.Empty, retornoDto.Mensagem);
return(false);
}
using (SqlConnection conn = new SqlConnection(context.Database.Connection.ConnectionString))
{
Server server = new Server(new ServerConnection(conn));
if (server.ConnectionContext.ExecuteNonQuery(backupDescriptografado) < 0)
{
retornoDto.Mensagem = "Falha ao restaurar o backup: ";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.RestaurarBackup, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
retornoDto.Retorno = true;
return(true);
}
catch (Exception ex)
{
retornoDto.Mensagem = "Falha ao restaurar o backup: " + ex.Message;
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.RestaurarBackup, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
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 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 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"));
}
public ActionResult CancelarPedido(ExclusaoModel 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 estornar um pedido é necessário " +
$"logar com um usuário administrador.";
return(View("SemPermissao"));
}
if (string.IsNullOrWhiteSpace(model.Justificativa))
{
ModelState.AddModelError("", "Preencha uma justificativa para o estorno do pedido.");
return(View("Cancelar", model));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoCancelarPedidoDto requisicaoDto = new RequisicaoCancelarPedidoDto()
{
Id = model.Id,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario,
Justificativa = model.Justificativa
};
//Consumir o serviço
PedidoBll pedidoBll = new PedidoBll(true);
pedidoBll.CancelarPedido(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View("Cancelar", model));
}
TempData["Retorno"] = "ESTORNADO";
//Voltar para a index de pedido
return(RedirectToAction("Index"));
}
public ActionResult ExcluirFuncionario(ExclusaoModel 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 excluir um funcionario é necessário " +
$"logar com um funcionario administrador.";
return(View("SemPermissao"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.Mensagem = "Este funcionario não tem permissão para excluir outros funcionarios.";
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoObterDto requisicaoDto = new RequisicaoObterDto()
{
Id = model.Id,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
FuncionarioBll funcionarioBll = new FuncionarioBll(true);
funcionarioBll.Excluir(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View("Excluir", model));
}
TempData["Retorno"] = "EXCLUIDO";
//Voltar para a index de funcionario
return(RedirectToAction("Index"));
}
