/// <summary>
/// Método prático para registrar um log no banco de dados
/// </summary>
/// <param name="requisicaoBaseDto"></param>
/// <param name="recurso"></param>
/// <param name="idEntidade"></param>
/// <param name="retornoDto"></param>
/// <param name="linha"></param>
/// <param name="metodo"></param>
internal void ResgistrarLog(BaseRequisicaoDto requisicaoBaseDto, LogRecursos recurso, Guid idEntidade, string mensagem, [CallerLineNumber] int linha = 0, [CallerMemberName] string metodo = "")
{
RequisicaoEntidadeDto <LogDto> requisicaoDto = new RequisicaoEntidadeDto <LogDto>()
{
IdUsuario = requisicaoBaseDto.IdUsuario,
Identificacao = requisicaoBaseDto.Identificacao,
EntidadeDto = new LogDto()
};
requisicaoDto.EntidadeDto.IdEntidade = idEntidade;
requisicaoDto.EntidadeDto.IdUsuario = requisicaoBaseDto.IdUsuario;
requisicaoDto.EntidadeDto.Recurso = recurso;
requisicaoDto.EntidadeDto.Id = Guid.NewGuid();
requisicaoDto.EntidadeDto.Inativo = false;
requisicaoDto.EntidadeDto.Mensagem = $"Classe: {classeOrigem}. \n " +
$"Método: {metodo} \n" +
$"Linha: {linha} \n" +
$"Mensagem: {mensagem}";
RetornoDto retornoIncluirDto = new RetornoDto();
if (!Incluir(requisicaoDto, ref retornoIncluirDto))
{
//TODO: Enviar email para avisar que não está logando
}
}
/// <summary>
/// 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>
/// Obtem a cidade que o bairro pertence
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="bairro"></param>
/// <param name="cidade"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool ObterCidadePorBairro(BaseRequisicaoDto requisicaoDto, string bairro, ref string cidade, ref string mensagemErro)
{
if (string.IsNullOrWhiteSpace(bairro))
{
mensagemErro = "Informe o bairro para obter a cidade";
return(false);
}
// Obter a query primária
IQueryable <CepVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
mensagemErro = $"Houve um problema ao obter a cidade: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCidadePorBairro, Guid.Empty, mensagemErro);
return(false);
}
try
{
bairro = bairro.Trim();
CepVo endereco = query.Where(p => p.Bairro == bairro).FirstOrDefault();
cidade = endereco == null ? "" : endereco.Cidade.Trim();
return(true);
}
catch (Exception ex)
{
mensagemErro = $"Houve um problema ao obter a cidade: {ex.Message}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterCidadePorBairro, Guid.Empty, mensagemErro);
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>
/// Verifica se um CEP já existe na tabela
/// </summary>
/// <param name="cepVo"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
private bool VerificarExistente(BaseRequisicaoDto requisicaoDto, string cep, out CepVo cepVo, ref string mensagemErro)
{
cepVo = null;
if (string.IsNullOrWhiteSpace(cep))
{
mensagemErro = "Informe um CEP para verificar a existência no banco de dados";
return(false);
}
// Obter a query primária
IQueryable <CepVo> query;
if (!this.ObterQueryBd(out query, ref mensagemErro, true))
{
mensagemErro = $"Houve um problema ao listar os CEPs: {mensagemErro}";
return(false);
}
try
{
cep = cep.Replace("-", "");
query = query.Where(p => p.Cep == cep.Trim());
cepVo = query.FirstOrDefault();
return(true);
}
catch (Exception ex)
{
mensagemErro = ex.Message;
return(false);
}
}
/// <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>
/// Chama a tela com a listagem de ceps
/// </summary>
/// <returns></returns>
public ActionResult Backup()
{
// Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
RetornoObterArquivoDto retornoDto = new RetornoObterArquivoDto();
BaseRequisicaoDto requisicaoDto = new BaseRequisicaoDto()
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
RecursosBdBll recursosBdBll = new RecursosBdBll();
if (!recursosBdBll.FazerBackupSistema(requisicaoDto, ref retornoDto))
{
ViewBag.MensagemErro = retornoDto.Mensagem;
return(View("Erro"));
}
byte[] byteArray = Convert.FromBase64String(retornoDto.ArquivoBase64);
return(File(byteArray, System.Net.Mime.MediaTypeNames.Application.Octet, "Backup " + DateTime.Now.ToShortDateString() + ".sql"));
}
/// <summary>
/// Obtem a lista de bairros cadastrados
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="listaBairros"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool ObterListaBairros(BaseRequisicaoDto requisicaoDto, ref List <BairroCidadeDto> listaBairros, ref string mensagemErro)
{
IQueryable <CepVo> query;
// Obter a query primária
if (!this.ObterQueryBd(out query, ref mensagemErro))
{
mensagemErro = $"Houve um problema ao listar os bairros: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairro, Guid.Empty, mensagemErro);
return(false);
}
try
{
query = query.OrderBy(p => p.Bairro);
listaBairros = query.GroupBy(p => new { p.Cidade, p.Bairro }).Select(p => new BairroCidadeDto {
Cidade = p.Key.Cidade, Bairro = p.Key.Bairro
}).ToList();
return(true);
}
catch (Exception)
{
mensagemErro = $"Houve um problema ao listar os bairros: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairro, Guid.Empty, mensagemErro);
return(false);
}
}
/// <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);
}
/// <summary>
/// Chama a tela para incluir/alterar uma lista de taxas de entrega
/// </summary>
/// <returns></returns>
public ActionResult ConfigurarTaxas()
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
//Taxas a serem incluídas
List <TaxaEntregaModel> model = new List <TaxaEntregaModel>();
TaxaEntregaBll taxaEntregaBll = new TaxaEntregaBll(false);
BaseRequisicaoDto requisicaoDto = new BaseRequisicaoDto()
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
// Obter a lista com bairros e taxas
RetornoObterListaDto <TaxaEntregaDto> retornoDto = new RetornoObterListaDto <TaxaEntregaDto>();
if (!taxaEntregaBll.ObterListaBairrosComTaxa(requisicaoDto, ref retornoDto))
{
ViewBag.MensagemErro = retornoDto.Mensagem;
return(View("Erro"));
}
// Converter e add a lista da model
string mensagemErro = "";
foreach (var tax in retornoDto.ListaEntidades)
{
TaxaEntregaModel taxaModel = new TaxaEntregaModel();
if (!taxaModel.ConverterDtoParaModel(tax, ref mensagemErro))
{
ViewBag.MensagemErro = mensagemErro;
return(View("Erro"));
}
model.Add(taxaModel);
}
TempData["Retorno"] = "INCLUINDO";
//Chamar a view
return(View(model));
}
/// <summary>
/// Obtem os para exibir do dashboard
/// </summary>
/// <param name="filtros"></param>
/// <returns></returns>
public string ObterInformacoesDashboard(FiltrosProdutoModel filtros)
{
RetornoObterInformacoesDashboardDto retornoDto = new RetornoObterInformacoesDashboardDto();
BaseRequisicaoDto requisicaoDto = new BaseRequisicaoDto()
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
RelatoriosBll relatoriosBll = new RelatoriosBll();
relatoriosBll.ObterDadosDashboard(requisicaoDto, ref retornoDto);
string retorno = new JavaScriptSerializer().Serialize(retornoDto);
return(retorno);
}
/// <summary>
/// Preenche as listas de filtros dos logs
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static bool PreencherListasFiltrosLog(FiltrosLogModel model, ref string mensagemErro)
{
// Preencher todos os recursos disponíveis
LogRecursos[] elementos = Enum.GetValues(typeof(LogRecursos)) as LogRecursos[];
foreach (var recurso in elementos)
{
model.ListaRecursos.Add(new SelectListItem()
{
Text = recurso.ToString(),
Value = ((int)recurso).ToString()
});
}
model.ListaRecursos.RemoveAt(0);
model.ListaRecursos = model.ListaRecursos.OrderBy(p => p.Text).ToList();
UsuarioBll usuarioBll = new UsuarioBll(false);
RetornoObterDicionarioDto <Guid, string> retornoDto = new RetornoObterDicionarioDto <Guid, string>();
BaseRequisicaoDto requisicaoDto = new BaseRequisicaoDto()
{
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
// Obter a lista de usuários cadastrados
if (!usuarioBll.ObterListaParaSelecao(requisicaoDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
// Popular a lista da model com os usuários retornados
foreach (var usuario in retornoDto.ListaEntidades)
{
model.ListaUsuarios.Add(new SelectListItem()
{
Text = usuario.Value,
Value = usuario.Key.ToString()
});
}
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>
/// Obtém uma lista com todos os bairros e suas respectivas taxas
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool ObterListaBairrosComTaxa(BaseRequisicaoDto requisicaoDto, ref RetornoObterListaDto <TaxaEntregaDto> retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairrosComTaxas, Guid.Empty, mensagemErro);
return(false);
}
CepBll cepBll = new CepBll(false);
List <BairroCidadeDto> listaBairros = new List <BairroCidadeDto>();
// Obter os bairros cadastrados
if (!cepBll.ObterListaBairros(requisicaoDto, ref listaBairros, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
return(false);
}
// Obter a query primária
IQueryable <TaxaEntregaVo> query;
List <TaxaEntregaVo> listaTaxasCadastradas;
if (!this.ObterQueryBd(out query, ref mensagemErro, true))
{
retornoDto.Mensagem = $"Houve um problema ao listar as taxas de entrega: {mensagemErro}";
retornoDto.Retorno = false;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairrosComTaxas, Guid.Empty, retornoDto.Mensagem);
return(false);
}
try
{
query = query.OrderBy(p => p.BairroCidade);
listaTaxasCadastradas = query.ToList();
}
catch (Exception)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = $"Houve um problema ao listar os bairros: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairrosComTaxas, Guid.Empty, mensagemErro);
return(false);
}
// Para cada bairro
foreach (var bairro in listaBairros)
{
// Iniciar taxa
TaxaEntregaDto taxaDto = new TaxaEntregaDto()
{
BairroCidade = bairro.Bairro + "_" + bairro.Cidade.Trim(),
Cidade = bairro.Cidade,
Id = Guid.Empty,
ValorTaxa = 0
};
TaxaEntregaVo taxaVo = listaTaxasCadastradas.Where(p => p.BairroCidade.Trim() == (bairro.Bairro.Trim() + "_" + bairro.Cidade.Trim())).FirstOrDefault();
if (taxaVo != null)
{
if (!ConverterVoParaDto(taxaVo, ref taxaDto, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = $"Falha ao converter a taxa para DTO: {mensagemErro}";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.ObterListaBairrosComTaxas, Guid.Empty, mensagemErro);
return(false);
}
if (taxaVo.Excluido)
{
taxaDto.ValorTaxa = 0;
}
}
retornoDto.ListaEntidades.Add(taxaDto);
}
retornoDto.ListaEntidades = retornoDto.ListaEntidades.OrderBy(p => p.Cidade).ThenBy(p => p.BairroCidade).ToList();
retornoDto.Retorno = true;
retornoDto.Mensagem = "OK";
return(true);
}
/// <summary>
/// Inclui ou atualiza os dados de uma taxa de entrega
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="taxaEntregaDto"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool IncluirEditar(BaseRequisicaoDto requisicaoDto, TaxaEntregaDto taxaEntregaDto, ref string mensagemErro)
{
if (taxaEntregaDto == null)
{
mensagemErro = "Preencha os dados da taxa que deseja incluir/editar.";
return(false);
}
RequisicaoObterTaxaPorBairroDto requisicaoObterDto = new RequisicaoObterTaxaPorBairroDto()
{
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario,
BairroCidade = taxaEntregaDto.BairroCidade
};
RetornoObterDto <TaxaEntregaDto> retornoObterDto = new RetornoObterDto <TaxaEntregaDto>();
if (!ObterTaxaPorBairro(requisicaoObterDto, ref retornoObterDto))
{
mensagemErro = retornoObterDto.Mensagem;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirEditarTaxaEntrega, taxaEntregaDto.Id, mensagemErro);
return(false);
}
// Incluir se não existir
if (retornoObterDto.Entidade == null)
{
taxaEntregaDto.Id = Guid.NewGuid();
RequisicaoEntidadeDto <TaxaEntregaDto> requisicaoIncluirDto = new RequisicaoEntidadeDto <TaxaEntregaDto>()
{
EntidadeDto = taxaEntregaDto,
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 (taxaEntregaDto.ValorTaxa != retornoObterDto.Entidade.ValorTaxa)
{
retornoObterDto.Entidade.ValorTaxa = taxaEntregaDto.ValorTaxa;
RequisicaoEntidadeDto <TaxaEntregaDto> requisicaoEditarDto = new RequisicaoEntidadeDto <TaxaEntregaDto>()
{
EntidadeDto = retornoObterDto.Entidade,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Editar(requisicaoEditarDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
}
return(true);
}
/// <summary>
/// Executa o backup do sistema e retorna um arquivo .sql
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="retornoDto"></param>
/// <returns></returns>
public bool FazerBackupSistema(BaseRequisicaoDto requisicaoDto, ref RetornoObterArquivoDto retornoDto)
{
string mensagemErro = "";
if (!UtilitarioBll.ValidarIdentificacao(requisicaoDto.Identificacao, requisicaoDto.IdUsuario, ref mensagemErro))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.BaseIncluir, Guid.Empty, mensagemErro);
return(false);
}
PizzaByteContexto context = new PizzaByteContexto();
try
{
StringBuilder deletes = new StringBuilder(string.Empty);
StringBuilder inserts = new StringBuilder(string.Empty);
StringBuilder insertsFk = new StringBuilder(string.Empty);
ScriptingOptions scriptOptions = new ScriptingOptions();
SqlConnection conn = new SqlConnection(context.Database.Connection.ConnectionString);
Server srv1 = new Server(new ServerConnection(conn));
Database db1 = srv1.Databases[context.Database.Connection.Database];
deletes.AppendLine("Use " + context.Database.Connection.Database);
deletes.AppendLine("GO ");
deletes.AppendLine("BEGIN TRY ");
deletes.AppendLine("BEGIN TRANSACTION ");
List <string> tabelasComChaveEstrangeira = new List <string>();
Scripter scr = new Scripter(srv1);
foreach (Table table in db1.Tables)
{
for (int i = 0; i < table.ForeignKeys.Count; i++)
{
if (!tabelasComChaveEstrangeira.Contains(table.ForeignKeys[i].ReferencedTable))
{
if (table.ForeignKeys[i].ReferencedTable == "Pedidos")
{
tabelasComChaveEstrangeira.Insert(0, table.ForeignKeys[i].ReferencedTable);
}
else
{
tabelasComChaveEstrangeira.Add(table.ForeignKeys[i].ReferencedTable);
}
}
}
}
// Tabelas que não fazer a fk de outras tabelas
foreach (Table table in db1.Tables)
{
if (table.Name != "__MigrationHistory" && !tabelasComChaveEstrangeira.Contains(table.Name))
{
ScriptingOptions options = new ScriptingOptions();
options.DriAll = false;
options.ScriptSchema = false;
options.ScriptData = true;
scr.Options = options;
deletes.AppendLine("DELETE FROM [PizzaByte].[" + table.Name + "]");
// Add script to file content
foreach (string scriptLine in scr.EnumScript(new Urn[] { table.Urn }))
{
string line = scriptLine;
line = line.Replace("SET ANSI_NULLS ON", string.Empty);
line = line.Replace("SET QUOTED_IDENTIFIER ON", string.Empty);
line = line.Replace("SET ANSI_NULLS OFF", string.Empty);
line = line.Replace("SET QUOTED_IDENTIFIER OFF", string.Empty);
inserts.AppendLine(line.Trim());
}
}
}
deletes.AppendLine("DELETE FROM [PizzaByte].[Pedidos]");
// Depois as tabelas que são fk
foreach (Table table in db1.Tables)
{
if (table.Name != "__MigrationHistory" && tabelasComChaveEstrangeira.Contains(table.Name))
{
ScriptingOptions options = new ScriptingOptions();
options.DriAll = false;
options.ScriptSchema = false;
options.ScriptData = true;
scr.Options = options;
if (table.Name != "Pedidos")
{
deletes.AppendLine("DELETE FROM [PizzaByte].[" + table.Name + "]");
}
// Add script to file content
foreach (string scriptLine in scr.EnumScript(new Urn[] { table.Urn }))
{
string line = scriptLine;
line = line.Replace("SET ANSI_NULLS ON", string.Empty);
line = line.Replace("SET QUOTED_IDENTIFIER ON", string.Empty);
line = line.Replace("SET ANSI_NULLS OFF", string.Empty);
line = line.Replace("SET QUOTED_IDENTIFIER OFF", string.Empty);
insertsFk.AppendLine(line.Trim());
}
}
}
deletes.Append(insertsFk.ToString());
deletes.Append(inserts.ToString());
deletes.AppendLine("COMMIT TRAN ");
deletes.AppendLine("END TRY ");
deletes.AppendLine("BEGIN CATCH ");
deletes.AppendLine("ROLLBACK TRAN ");
deletes.AppendLine("END CATCH ");
string backupCriptografado = "";
if (!UtilitarioBll.CriptografarString(deletes.ToString(), ref backupCriptografado))
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao criptografar o backup";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.Backup, Guid.Empty, retornoDto.Mensagem);
return(false);
}
byte[] bytes = Encoding.UTF8.GetBytes(backupCriptografado);
string base64 = Convert.ToBase64String(bytes);
retornoDto.ArquivoBase64 = base64;
return(true);
}
catch (Exception ex)
{
retornoDto.Retorno = false;
retornoDto.Mensagem = "Erro ao executar o backup: " + ex.Message;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.Backup, Guid.Empty, retornoDto.Mensagem);
return(false);
}
}
/// <summary>
/// Inclui ou atualiza os dados de uma entrega
/// </summary>
/// <param name="requisicaoDto"></param>
/// <param name="entregaDto"></param>
/// <param name="mensagemErro"></param>
/// <returns></returns>
internal bool IncluirEditar(BaseRequisicaoDto requisicaoDto, PedidoEntregaDto entregaDto, ref string mensagemErro)
{
if (entregaDto == null)
{
mensagemErro = "Preencha a entrega que deseja incluir/editar.";
return(false);
}
PedidoEntregaVo entregaVo;
if (!ObterPorIdBd(entregaDto.Id, out entregaVo, ref mensagemErro) && mensagemErro != "Cadastro não encontrado")
{
mensagemErro = "Problemas para encontrar a entrega: " + mensagemErro;
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirEditarPedidoEntrega, entregaDto.Id, mensagemErro);
return(false);
}
// Incluir se não existir
if (entregaVo == null)
{
RequisicaoEntidadeDto <PedidoEntregaDto> requisicaoIncluirDto = new RequisicaoEntidadeDto <PedidoEntregaDto>()
{
EntidadeDto = entregaDto,
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 (entregaDto.IdEndereco != entregaVo.IdEndereco)
{
if (entregaVo.Conferido)
{
mensagemErro = "Não é possível alterar dados de entregas já conferidas";
logBll.ResgistrarLog(requisicaoDto, LogRecursos.IncluirEditarPedidoEntrega, entregaDto.Id, mensagemErro);
return(false);
}
RequisicaoEntidadeDto <PedidoEntregaDto> requisicaoEditarDto = new RequisicaoEntidadeDto <PedidoEntregaDto>()
{
EntidadeDto = entregaDto,
Identificacao = requisicaoDto.Identificacao,
IdUsuario = requisicaoDto.IdUsuario
};
RetornoDto retornoDto = new RetornoDto();
if (!Editar(requisicaoEditarDto, ref retornoDto))
{
mensagemErro = retornoDto.Mensagem;
return(false);
}
}
}
return(true);
}
