public List <DTOs.Pagamento> ListarPagamentosPeloIDreserva(int idreserva)
{
try
{
using (HSContext hs = new HSContext())
{
return((
from paga in hs.Tbpagamento
join tipo in hs.Tbtipopagamento on paga.Idtipopagamento equals tipo.Idtipopagamento
where paga.Idreserva == idreserva
select new DTOs.Pagamento()
{
idtipopagamento = paga.Idtipopagamento,
idreserva = paga.Idreserva,
valor = paga.Valor.ToString(),
chavepagamento = paga.Chavepagamento,
idpagamento = paga.Idpagamento,
tipopagamento = tipo.Tipopagamento,
datapagamento = paga.Datapagamento.Value.ToString("dd/MM/yyyy")
}
).ToList());
}
}
catch (Exception ex)
{
erros.Add("Os pagamentos não foram listados.");
erros.Add(ex.Message);
return(null);
}
}
public List <DTOs.produtosReserva> ListarProdutosPorReserva(int idreserva)
{
try
{
using (HSContext hs = new HSContext())
{
return((
from produtoreserva in hs.Tbprodutoreserva
join produto in hs.Tbproduto on produtoreserva.Idproduto equals produto.Idproduto
where produtoreserva.Idreserva == idreserva
select new DTOs.produtosReserva()
{
idprodutocheckout = produtoreserva.Idprodutocheckout,
descricao = produto.Descricao,
idproduto = produto.Idproduto,
idreserva = produtoreserva.Idreserva.Value,
quantidade = produtoreserva.Quantidade.Value,
valor = produtoreserva.Valor.ToString()
}
).ToList());
}
}
catch (Exception ex)
{
erros.Add("Não foi possível listar os produtos dessa reserva.");
erros.Add(ex.Message);
return(null);
}
}
public bool IncluirUsuario(DTOs.Usuario usuario)
{
try
{
byte[] theBytes = Encoding.ASCII.GetBytes(usuario.senha);
using (HSContext hs = new HSContext())
{
Tbusuario UsuarioAdd = new Tbusuario();
UsuarioAdd.Cpf = usuario.cpf;
UsuarioAdd.Datanascimento = DateTime.Parse(usuario.datanascimento);
UsuarioAdd.Email = usuario.email;
UsuarioAdd.Loginusuario = usuario.loginusuario;
UsuarioAdd.Nomeusuario = usuario.nomeusuario;
UsuarioAdd.Senha = theBytes;
hs.Tbusuario.Add(UsuarioAdd);
hs.SaveChanges();
}
}
catch (Exception ex)
{
erros.Add("O quarto não foi adicionado.");
erros.Add(ex.Message);
return(false);
}
return(true);
}
public bool CancelarReserva(DTOs.Reserva reserva)
{
List <DTOs.produtosReserva> produtos = reserva.produtos;
try
{
using (HSContext hs = new HSContext())
{
var cancelar = hs.Tbreserva.First(x => x.Idreserva == reserva.idreserva);
cancelar.Datacancelamento = DateTime.Now;
cancelar.Motivocancelamento = reserva.motivocancelamento;
hs.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
erros.Add("Reserva não foi cancelada.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
erros.Add(ex.InnerException.Message);
}
return(false);
}
}
public Tbusuariocartao IncluirCartaoUsuario(DTOs.CartaoUsuario cartao)
{
try
{
using (HSContext hs = new HSContext())
{
var idusuario = this.Decrypt(cartao.idusuariocripto);
Tbusuariocartao cartaoInserir = new Tbusuariocartao()
{
Cvv = cartao.cvv,
Datavencimento = cartao.datavencimento,
Numerocartao = cartao.numerocartao,
Idusuario = Int32.Parse(idusuario),
Nomecartao = cartao.nomecartao
};
hs.Tbusuariocartao.Add(cartaoInserir);
hs.SaveChanges();
return(cartaoInserir);
}
}
catch (Exception ex)
{
erros.Add("O quarto não foi adicionado.");
erros.Add(ex.Message);
return(null);
}
}
public DTOs.Reserva BuscarReservaComCheckoutPeloID(int idreserva)
{
try
{
using (HSContext hs = new HSContext())
{
return
((
from reserva in hs.Tbreserva
join quarto in hs.Tbquarto on reserva.Idquarto equals quarto.Idquarto
join usuario in hs.Tbusuario on reserva.Idusuario equals usuario.Idusuario
where reserva.Idreserva == idreserva
select new DTOs.Reserva()
{
idreserva = reserva.Idreserva,
checkout = reserva.Checkout.Value,
valorcheckout = hs.Tbprodutoreserva.Where(x => x.Idreserva == idreserva).Sum(x => x.Valor * x.Quantidade).ToString(),
cpf = usuario.Cpf,
nomecliente = usuario.Nomeusuario,
quarto = quarto.Quarto,
valor = reserva.Valor.ToString(),
dataentrada = reserva.Dataentrada.Value.ToString("dd/MM/yyyy"),
datasaida = reserva.Datasaida.Value.ToString("dd/MM/yyyy")
}
).First());
}
}
catch (Exception ex)
{
erros.Add("Ocorreu um erro ao pesquisar a reserva pelo ID.");
erros.Add(ex.Message);
return(null);
}
}
public List <DTOs.Reserva> ListarReservasAtivas()
{
try
{
using (HSContext hs = new HSContext())
{
return
((
from reserva in hs.Tbreserva
join quarto in hs.Tbquarto on reserva.Idquarto equals quarto.Idquarto
join usuario in hs.Tbusuario on reserva.Idusuario equals usuario.Idusuario
where !reserva.Datafinalizacao.HasValue
orderby reserva.Dataentrada
select new DTOs.Reserva()
{
idreserva = reserva.Idreserva,
nomecliente = usuario.Nomeusuario,
quarto = quarto.Quarto,
valor = reserva.Valor.ToString(),
dataentrada = reserva.Dataentrada.Value.ToString("dd/MM/yyyy"),
datasaida = reserva.Datasaida.Value.ToString("dd/MM/yyyy"),
cpf = usuario.Cpf,
checkout = reserva.Checkout.Value
}
).ToList());
}
}
catch (Exception ex)
{
erros.Add("Ocorreu um erro ao pesquisar as reservas ativas.");
erros.Add(ex.Message);
return(null);
}
}
public List <DTOs.CartaoUsuario> ListarCartoesUsuario(string idusuariocript)
{
try
{
using (HSContext hs = new HSContext())
{
var idusuario = this.Decrypt(idusuariocript);
return(hs.Tbusuariocartao.Where(x => x.Idusuario == Int32.Parse(idusuario))
.Select(x => new DTOs.CartaoUsuario()
{
cvv = x.Cvv,
datavencimento = x.Datavencimento.ToString(),
idusuario = x.Idusuario,
idusuariocartao = x.Idusuariocartao,
nomecartao = x.Nomecartao,
numerocartao = x.Numerocartao
}
).ToList());
}
}
catch (Exception ex)
{
erros.Add("O quarto não foi adicionado.");
erros.Add(ex.Message);
return(null);
}
}
public Tbcliente Entrar(string email, string senha)
{
try
{
byte[] theBytes = Encoding.ASCII.GetBytes(senha);
using (HSContext hs = new HSContext())
{
var retorno = hs.Tbcliente.FirstOrDefault(x => x.Email == email && x.Senha == theBytes);
if (retorno == null)
{
this.erros.Add("Usuario ou senha incorretos.");
return(null);
}
else
{
return(retorno);
}
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar o cliente.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
inner.Add(ex.InnerException.Message);
}
return(null);
}
}
public List <DTOs.Quarto> Listar(int idempresa)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbquarto.Include(x => x.IdtipoquartoNavigation)
.ThenInclude(x => x.IdempresaNavigation)
.Where(x => x.IdtipoquartoNavigation.IdempresaNavigation.Idempresa == idempresa)
.Select(x => new DTOs.Quarto()
{
tipoquarto = x.IdtipoquartoNavigation.Tipoquarto,
andar = x.Andar,
varanda = x.IdtipoquartoNavigation.Varanda,
quarto = x.Quarto,
idquarto = x.Idquarto,
arcondicionado = x.IdtipoquartoNavigation.Arcondicionado,
camacasal = x.IdtipoquartoNavigation.Camacasal,
camasolteiro = x.IdtipoquartoNavigation.Camasolteiro,
status = x.Status.Value,
valor = x.IdtipoquartoNavigation.Valor.ToString(),
}).ToList());
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar o quarto.");
erros.Add(ex.Message);
return(null);
}
}
public bool FinalizarReserva(DTOs.Reserva reserva)
{
List <DTOs.produtosReserva> produtos = reserva.produtos;
try
{
using (HSContext hs = new HSContext())
{
var finalizar = hs.Tbreserva.First(x => x.Idreserva == reserva.idreserva);
var valorcheckout = hs.Tbprodutoreserva.Where(x => x.Idreserva == reserva.idreserva).Sum(x => x.Valor * x.Quantidade);
var valorpagamento = hs.Tbpagamento.Where(x => x.Idreserva == reserva.idreserva).Sum(x => x.Valor);
var totalPagamentoComCheckout = valorcheckout + valorpagamento;
if (finalizar.Checkout == false)
{
erros.Add("Não foi possível finalizar a reserva.");
erros.Add("O checkout dessa reserva ainda não foi realizado.");
}
else
{
if (valorpagamento == 0)
{
erros.Add("Não foi possível finalizar a reserva.");
erros.Add("Não foi identificado nenhum pagamento para a reserva.");
}
else
{
if ((finalizar.Valor + valorcheckout) > valorpagamento)
{
erros.Add("Não foi possível finalizar a reserva.");
erros.Add("O pagamento da reserva não bateu com o total da reserva, verifique novamente o pagamento dessa reserva.");
}
else
{
finalizar.Datafinalizacao = DateTime.Now;
hs.SaveChanges();
}
}
}
return(true);
}
}
catch (Exception ex)
{
erros.Add("Reserva não finalizada.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
erros.Add(ex.InnerException.Message);
}
return(false);
}
}
public Tbproduto Buscar(int idProduto)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbproduto.First(x => x.Idproduto == idProduto));
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar produtos.");
erros.Add(ex.Message);
return(null);
}
}
public List <Cidades> ListarCidades(string cidade)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Cidades.Where(x => x.DsCidadeNome.Contains(cidade)).ToList());
}
}
catch (Exception ex)
{
erros.Add("Ocorreu um erro ao listar as cidades.");
erros.Add(ex.Message);
return(null);
}
}
public List <Tbquarto> ListarTodosQuartosParaAlugar()
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbquarto.Where(x => x.Status == 1).ToList());
}
}
catch (Exception ex)
{
erros.Add("Erro ao listar os quartos para alugar.");
erros.Add(ex.Message);
return(null);
}
}
public List <Tbquarto> AutoComplete(string nome)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbquarto.Where(x => x.Quarto.Contains(nome)).ToList());
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar o quarto.");
erros.Add(ex.Message);
return(null);
}
}
public DTOs.Usuario PegarDadosUsuario(string idusuariocripto)
{
try
{
var idusuario = this.Decrypt(idusuariocripto);
using (HSContext hs = new HSContext())
{
return(hs.Tbusuario.Where(x => x.Idusuario == Int32.Parse(idusuario))
.Select(x => new DTOs.Usuario()
{
email = x.Email,
datanascimento = x.Datanascimento.ToShortDateString(),
cpf = x.Cpf,
loginusuario = x.Loginusuario,
nomeusuario = x.Nomeusuario,
cartoes = hs.Tbusuariocartao.Where(cartao => cartao.Idusuario == x.Idusuario)
.Select(cartao => new DTOs.CartaoUsuario()
{
cvv = cartao.Cvv,
datavencimento = cartao.Datavencimento,
nomecartao = cartao.Nomecartao,
numerocartao = cartao.Numerocartao
}).ToList(),
reservas = hs.Tbreserva.Where(res => res.Idusuario == Int32.Parse(idusuario))
.Select(res => new DTOs.Reserva()
{
dataentrada = res.Dataentrada.Value.ToShortDateString(),
datasaida = res.Datasaida.Value.ToShortDateString(),
hotel = res.IdquartoNavigation.IdtipoquartoNavigation.IdempresaNavigation.Nomeempresa,
tipoquarto = res.IdquartoNavigation.IdtipoquartoNavigation.Tipoquarto,
valor = res.Valor.ToString()
}).ToList()
}).FirstOrDefault());
}
}
catch (Exception ex)
{
this.erros.Add("Aconteceu um erro ao listar os seus cartões de crédito");
this.erros.Add(ex.Message);
}
return(null);
}
public List <DTOs.Endereco> ListarBairros(string bairro)
{
List <DTOs.Endereco> final = new List <DTOs.Endereco>();
try
{
using (HSContext hs = new HSContext())
{
var enderecos =
hs.Bairros.Include(x => x.CdCidadeNavigation).ThenInclude(x => x.CdUfNavigation)
.Where(x => x.CdCidadeNavigation.DsCidadeNome.Contains(bairro))
.Select(x => new DTOs.Endereco()
{
bairro = x.CdCidadeNavigation.DsCidadeNome,
cidade = x.CdCidadeNavigation.CdUfNavigation.DsUfNome,
cdbairro = 0,
cdcidade = x.CdCidadeNavigation.CdCidade,
}).Distinct().OrderBy(x => x.cidade).ToList();
if (enderecos.Count() > 0)
{
final.AddRange(
enderecos
);
}
;
final.AddRange(hs.Bairros.Include(x => x.CdCidadeNavigation).Where(x => x.DsBairroNome.Contains(bairro) || x.CdCidadeNavigation.DsCidadeNome.Contains(bairro)).Select(x => new DTOs.Endereco()
{
bairro = x.DsBairroNome,
cdbairro = x.CdBairro,
cdcidade = x.CdCidade,
cidade = x.CdCidadeNavigation.DsCidadeNome
}).OrderBy(x => x.cdcidade).ThenBy(x => x.cdbairro).ToList());
return(final);
}
}
catch (Exception ex)
{
erros.Add("Ocorreu um erro ao listar as cidades.");
erros.Add(ex.Message);
return(null);
}
}
public List <DTOs.TipoPagamento> ListarTiposDePagamento()
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbtipopagamento.Select(x => new DTOs.TipoPagamento()
{
idtipopagamento = x.Idtipopagamento, tipopagamento = x.Tipopagamento
}).ToList());
}
}
catch (Exception ex)
{
erros.Add("Ocorreu um erro ao listar os tipos de pagamentos");
erros.Add(ex.Message);
return(null);
}
}
public bool RemoverPagamento(int idpagamento)
{
try
{
using (HSContext hs = new HSContext())
{
var pagamento = hs.Tbpagamento.First(x => x.Idpagamento == idpagamento);
hs.Tbpagamento.Remove(pagamento);
hs.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
erros.Add("A exclusão do pagamento não foi realiada.");
erros.Add(ex.Message);
return(false);
}
}
public bool CheckOut(int idreserva)
{
try
{
using (HSContext hs = new HSContext())
{
var reserva = hs.Tbreserva.First(x => x.Idreserva == idreserva);
reserva.Checkout = true;
hs.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
erros.Add("O checkout não foi realizado.");
erros.Add(ex.Message);
return(false);
}
}
public bool IncluirCliente(DTOs.Cliente cliente)
{
try
{
using (HSContext hs = new HSContext())
{
var existe = hs.Tbcliente.FirstOrDefault(x => x.Cpf == cliente.cpf.Replace(".", "").Replace("-", ""));
if (existe == null)
{
var data = DateTime.Parse(cliente.datanascimento);
Tbcliente clienteAdd = new Tbcliente();
clienteAdd.Nomecliente = cliente.nomeCliente.ToUpper();
clienteAdd.Cpf = cliente.cpf.Replace(".", "").Replace("-", "");
clienteAdd.Cep = cliente.cep.Replace("-", "");
clienteAdd.Complemento = cliente.complemento.ToUpper();
clienteAdd.Datanascimento = DateTime.Parse(cliente.datanascimento);
clienteAdd.Email = cliente.email.ToUpper();
clienteAdd.Numero = cliente.numero.ToUpper();
clienteAdd.Rgcliente = cliente.rgcliente.ToUpper();
clienteAdd.Telefonecelular = cliente.telefonecelular.Replace("-", "").Replace("(", "").Replace(")", "");
clienteAdd.Telefonefixo = cliente.telefonefixo.Replace("-", "").Replace("(", "").Replace(")", "");
hs.Tbcliente.Add(clienteAdd);
hs.SaveChanges();
}
else
{
erros.Add("O cliente não foi adicionado.");
erros.Add("Já existe um cliente cadastrado para o CPF digitado.");
}
}
}
catch (Exception ex)
{
erros.Add("O cliente não foi adicionado.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
inner.Add(ex.InnerException.Message);
}
return(false);
}
return(true);
}
public bool AlterarQuarto(DTOs.Quarto quarto)
{
try
{
using (HSContext hs = new HSContext())
{
var quartoAlterar = hs.Tbquarto.First(x => x.Idquarto == quarto.idquarto);
quartoAlterar.Quarto = quarto.quarto.ToUpper();
quartoAlterar.Idtipoquarto = quarto.idtipoquarto;
hs.SaveChanges();
}
}
catch (Exception ex)
{
erros.Add("O quarto não foi alterado.");
erros.Add(ex.Message);
return(false);
}
return(true);
}
public List <Tbcliente> AutoComplete(string nome)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbcliente.Where(x => x.Nomecliente.Contains(nome) || x.Cpf.Contains(nome)).ToList());
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar o cliente.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
inner.Add(ex.InnerException.Message);
}
return(null);
}
}
public bool AlterarProduto(DTOs.Produto produto)
{
try
{
using (HSContext hs = new HSContext())
{
var produtoAlterar = hs.Tbproduto.First(x => x.Idproduto == produto.idProduto);
produtoAlterar.Descricao = produto.descricao.ToUpper();
produtoAlterar.Valor = Decimal.Parse(produto.valor);
hs.SaveChanges();
}
}
catch (Exception ex)
{
erros.Add("O produto não foi alterado.");
erros.Add(ex.Message);
return(false);
}
return(true);
}
public Tbcliente Buscar(int idcliente)
{
try
{
using (HSContext hs = new HSContext())
{
return(hs.Tbcliente.First(x => x.Idcliente == idcliente));
}
}
catch (Exception ex)
{
erros.Add("Erro ao pesquisar o cliente.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
inner.Add(ex.InnerException.Message);
}
return(null);
}
}
public bool IncluirProduto(DTOs.Produto produto)
{
try
{
using (HSContext hs = new HSContext())
{
Tbproduto produtoAdd = new Tbproduto();
produtoAdd.Descricao = produto.descricao.ToUpper();
produtoAdd.Valor = decimal.Parse(produto.valor);
hs.Tbproduto.Add(produtoAdd);
hs.SaveChanges();
}
}
catch (Exception ex)
{
erros.Add("O produto não foi adicionado.");
erros.Add(ex.Message);
return(false);
}
return(true);
}
public bool RealizarPagamento(DTOs.Pagamento pagamento)
{
try
{
using (HSContext hs = new HSContext())
{
var reserva = hs.Tbreserva.First(x => x.Idreserva == pagamento.idreserva);
var totalPagamentos = hs.Tbpagamento.Where(x => x.Idreserva == pagamento.idreserva).Sum(x => x.Valor);
var totalDividaCheckout = hs.Tbprodutoreserva.Where(x => x.Idreserva == pagamento.idreserva).Sum(x => x.Valor * x.Quantidade);
var totalPagamentoComCheckout = reserva.Valor + totalDividaCheckout;
if (totalPagamentos + decimal.Parse(pagamento.valor) > totalPagamentoComCheckout)
{
erros.Add("Não pode ser adicionado esse pagamento, porque o valor fica superior ao devido pelo cliente.");
return(false);
}
else
{
Tbpagamento pagamentoAdd = new Tbpagamento();
pagamentoAdd.Idreserva = pagamento.idreserva;
pagamentoAdd.Datapagamento = DateTime.Now;
pagamentoAdd.Valor = Decimal.Parse(pagamento.valor);
pagamentoAdd.Chavepagamento = pagamento.chavepagamento;
pagamentoAdd.Idtipopagamento = pagamento.idtipopagamento;
hs.Tbpagamento.Add(pagamentoAdd);
hs.SaveChanges();
return(true);
}
}
}
catch (Exception ex)
{
erros.Add("O pagamento não foi inserido.");
erros.Add(ex.Message);
return(false);
}
}
public bool IncluirQuarto(DTOs.Quarto quarto)
{
try
{
using (HSContext hs = new HSContext())
{
Tbquarto quartoAdd = new Tbquarto();
quartoAdd.Quarto = quarto.quarto.ToUpper();
quartoAdd.Status = 1;
quartoAdd.Idtipoquarto = quarto.idtipoquarto;
hs.Tbquarto.Add(quartoAdd);
hs.SaveChanges();
}
}
catch (Exception ex)
{
erros.Add("O quarto não foi adicionado.");
erros.Add(ex.Message);
return(false);
}
return(true);
}
public DeckController(HSContext contextDeck, IHelperAPI ihelperAPi)
{
_context = contextDeck;
_ihelperApi = ihelperAPi;
}
public bool AdicionarProdutosReservaCheckout(DTOs.Reserva reserva)
{
List <DTOs.produtosReserva> produtos = reserva.produtos;
try
{
using (HSContext hs = new HSContext())
{
var produtosdaReserva = hs.Tbprodutoreserva.Where(x => x.Idreserva == reserva.idreserva).ToList();
var idprodutoscheckout = produtosdaReserva.Select(x => x.Idprodutocheckout).ToList();
var idprodutoscheckoutReserva = produtos.Select(x => x.idprodutocheckout).ToList();
var idsParaDeletar = idprodutoscheckout.Except(idprodutoscheckoutReserva.Where(x => x != 0)).ToList();
var produtosDeletados = hs.Tbprodutoreserva.Where(x => idsParaDeletar.Contains(x.Idprodutocheckout)).ToList();
var reservaAtual = hs.Tbreserva.First(x => x.Idreserva == reserva.idreserva);
reservaAtual.Checkout = true;
if (produtos.Count > 0)
{
foreach (var item in produtos)
{
if (item.idprodutocheckout == 0)
{
hs.Tbprodutoreserva
.Add(new Tbprodutoreserva()
{
Idproduto = item.idproduto,
Idreserva = item.idreserva,
Quantidade = item.quantidade,
Valor = decimal.Parse(item.valor.Replace(".", ","))
});
}
else
{
var produtoreserva = hs.Tbprodutoreserva.First(x => x.Idprodutocheckout == item.idprodutocheckout);
produtoreserva.Quantidade = item.quantidade;
produtoreserva.Valor = decimal.Parse(item.valor.Replace(".", ","));
}
}
foreach (var item in produtosDeletados)
{
hs.Tbprodutoreserva.Remove(item);
}
hs.SaveChanges();
return(true);
}
else
{
return(true);
}
}
}
catch (Exception ex)
{
erros.Add("Produtos do checkout não inseridos.");
erros.Add(ex.Message);
if (ex.InnerException != null)
{
erros.Add(ex.InnerException.Message);
}
return(false);
}
}
