public IHttpActionResult GetAllByReserva(string id)
        {
            try
            {
                apiResp = new ApiResponse();
                var mng = new LlaveQRManager();

                var num = 0;
                var idR = 0;
                if (Int32.TryParse(id, out num))
                {
                    idR = num;
                }
                else
                {
                    throw new BussinessException(22);
                }

                var QR = new LlaveQR
                {
                    IdReserva = idR
                };

                apiResp.Data = mng.RetrieveAllByReserva(QR);
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }
            return(Ok(apiResp));
        }
        public async Task <IHttpActionResult> EnviarQR(LlaveQR llave)
        {
            try
            {
                var mng = new LlaveQRManager();

                LlaveQR c = null;
                c = mng.RetrieveById(llave);

                if (c != null)
                {
                    await EnviarCorreoManager.GetInstance().ExecuteCorreoCodigoQR(llave.IdUsuario, llave);

                    apiResp         = new ApiResponse();
                    apiResp.Message = "Llave enviada, Por favor verifique el correo electrónico";
                }
                else
                {
                    throw new BussinessException(52);
                }
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }

            return(Ok(apiResp));
        }
Esempio n. 3
0
        public Entity BuildObject(Dictionary <string, object> row)
        {
            var QR = new LlaveQR
            {
                CodigoQR    = GetStringValue(row, DB_COL_CODIGO_QR),
                ImagenQR    = GetStringValue(row, DB_COL_IMAGEN_QR),
                EstadoQR    = GetStringValue(row, DB_COL_ESTADO_QR),
                ValorEstado = GetStringValue(row, DB_COL_VALOR_ESTADO),
                IdUsuario   = GetStringValue(row, DB_COL_ID_USUARIO),
                IdReserva   = GetIntValue(row, DB_COL_ID_RESERVA),
            };

            return(QR);
        }
        public async Task <IHttpActionResult> PostAsync(LlaveQR llave)
        {
            try
            {
                var mng = new LlaveQRManager();

                await mng.Create(llave);

                apiResp         = new ApiResponse();
                apiResp.Message = "Llave generada correctamente";
                return(Ok(apiResp));
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }
        }
        public IHttpActionResult Delete(LlaveQR llave)
        {
            try
            {
                var mng = new LlaveQRManager();

                mng.Delete(llave);

                apiResp         = new ApiResponse();
                apiResp.Message = "Llave Eliminada correctamente";
                return(Ok(apiResp));
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }
        }
        public LlaveQR RetrieveById(LlaveQR llave)
        {
            LlaveQR p = null;

            try
            {
                p = crudLlaveQR.Retrieve <LlaveQR>(llave);
                if (p == null)
                {
                    throw new BussinessException(4);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }

            return(p);
        }
        public string CheckOut(Reserva res)
        {
            string salida = "";

            var crudReserva = new ReservaCrudFactory();

            var llave = new LlaveQR()
            {
                CodigoQR = res.idQR
            };

            try
            {
                llave = crudLlaveQR.Retrieve <LlaveQR>(llave);
                if (llave == null)
                {
                    // La llave QR no existe
                    throw new BussinessException(20);
                }

                var reserva = new Reserva()
                {
                    Codigo = llave.IdReserva
                };

                res = crudReserva.Retrieve <Reserva>(reserva);

                llave.EstadoQR = "3";
                crudLlaveQR.Update(llave);

                res.Estado = "0";
                crudReserva.Update(res);

                salida = "Check out realizado con éxito";
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }

            return(salida);
        }
        public async Task Create(LlaveQR llave)
        {
            try
            {
                var QR = new LlaveQR();
                do
                {
                    llave.CodigoQR = RandomString(8);
                    QR             = crudLlaveQR.Retrieve <LlaveQR>(llave);
                } while (QR != null);

                llave.ImagenQR = getImagenQR(llave.CodigoQR);
                crudLlaveQR.Create(llave);
                await EnviarCorreoManager.GetInstance().ExecuteCorreoCodigoQR(llave.IdUsuario, llave);
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }
        }
        public async Task <IHttpActionResult> PostYEnviarCorreo(LlaveQR llave)
        {
            try
            {
                var mng     = new LlaveQRManager();
                var usuario = new Usuario
                {
                    Correo = llave.IdUsuario
                };
                await mng.CreateYEnviar(llave, usuario);

                apiResp         = new ApiResponse();
                apiResp.Message = "Llave generada correctamente";
                return(Ok(apiResp));
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }
        }
        public IHttpActionResult Get(string id)
        {
            try
            {
                var mng = new LlaveQRManager();

                var QR = new LlaveQR
                {
                    CodigoQR = id
                };

                QR           = mng.RetrieveById(QR);
                apiResp      = new ApiResponse();
                apiResp.Data = QR;
                return(Ok(apiResp));
            }
            catch (BussinessException bex)
            {
                return(InternalServerError(new Exception(bex.AppMessage.Message)));
            }
        }
        public async Task CreateYEnviar(LlaveQR llave, Usuario usuario)
        {
            try
            {
                UsuarioManager mngU = new UsuarioManager();
                Usuario        u    = null;
                try
                {
                    u = mngU.RetrieveAll().FindAll(FindCorreo).First <Usuario>();
                }
                catch (Exception ex)
                {
                    throw new BussinessException(12);
                }
                //validar si existe
                if (u != null)
                {
                    //validar estado del usuario
                    switch (u.ValorEstado)
                    {
                    case "3":
                        //El usuario existe pero aún no ha verificado su cuenta
                        throw new BussinessException(8);

                    case "2":
                        //El usuario existe pero su contraseña ha expirado
                        throw new BussinessException(9);

                    case "0":
                        //El usuario existe pero se encuentra inactivo
                        throw new BussinessException(9);
                    }

                    var mngRoles   = new Rol_UsuarioManager();
                    var rolUsuario = new Rol_Usuario
                    {
                        IdUsuario = u.Identificacion,
                        IdRol     = "CLT"
                    };
                    var roles = mngRoles.RetrieveAllById(rolUsuario);
                    //validar que el usuario sea un cliente

                    foreach (Rol_Usuario rol in roles)
                    {
                        if (rol.IdRol.Equals("CLT") == false)
                        {
                            throw new Exception("El usuario no es válido");
                        }
                    }


                    var QR = new LlaveQR();
                    do
                    {
                        llave.CodigoQR = RandomString(8);
                        QR             = crudLlaveQR.Retrieve <LlaveQR>(llave);
                    } while (QR != null);

                    llave.ImagenQR = getImagenQR(llave.CodigoQR);

                    crudLlaveQR.Create(llave);
                    await EnviarCorreoManager.GetInstance().ExecuteCorreoCodigoQR(u.Correo, llave);
                }
                else
                {
                    //no existe ese usuario
                    throw new BussinessException(12);
                }

                bool FindCorreo(Usuario usu)
                {
                    if (usu.Correo == usuario.Correo)
                    {
                        return(true);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }
        }
 public void Delete(LlaveQR llave)
 {
     crudLlaveQR.Delete(llave);
 }
 public void Update(LlaveQR llave)
 {
     crudLlaveQR.Update(llave);
 }
        public string CheckIn(Reserva res)
        {
            string salida       = "";
            int    idHabitacion = res.IdHabitacion;
            string idHotel      = res.IdHotel;
            int    codigoRes    = res.Codigo;

            var crudReserva = new ReservaCrudFactory();

            var llave = new LlaveQR()
            {
                CodigoQR = res.idQR
            };

            try
            {
                llave = crudLlaveQR.Retrieve <LlaveQR>(llave);
                if (llave == null)
                {
                    // La llave QR no existe
                    throw new BussinessException(20);
                }

                var reserva = new Reserva()
                {
                    Codigo = llave.IdReserva
                };

                res = crudReserva.Retrieve <Reserva>(reserva);
                res.IdHabitacion = idHabitacion;

                if (res.IdHotel.Equals(idHotel) && llave.IdReserva == codigoRes)
                {
                    switch (llave.EstadoQR)
                    {
                    case "2":
                        // La llave QR se encuentra inactiva
                        throw new BussinessException(57);

                    case "3":
                        // La llave QR ya expiró
                        throw new BussinessException(58);
                    }

                    switch (res.Estado)
                    {
                    case "0":
                        // La reserva ya terminó!
                        throw new BussinessException(18);

                    case "1":
                        salida = "Adelante!";
                        break;

                    case "2":
                        if (res.FechaInicio.Date.CompareTo(DateTime.Now.Date) <= 0)
                        {
                            salida     = "Check in exitoso!";
                            res.Estado = "1";
                            crudReserva.Update(res);
                        }
                        else
                        {
                            // La fecha no es válida!
                            throw new BussinessException(19);
                        }

                        break;

                    case "3":
                        // La reserva está cancelada!
                        throw new BussinessException(18);
                    }
                }
                else
                {
                    // El código no pertenece a esta reservación
                    throw new BussinessException(23);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }

            return(salida);
        }
 public List <LlaveQR> RetrieveAllByReserva(LlaveQR llave)
 {
     return(crudLlaveQR.RetrieveAllByReserva <LlaveQR>(llave));
 }
Esempio n. 16
0
        public async Task Create(Reserva reserva)
        {
            try
            {
                FacturaCrudFactory crudFactura = new FacturaCrudFactory();
                LlaveQRManager     mngLlave    = new LlaveQRManager();
                UsuarioManager     mngUsuario  = new UsuarioManager();
                HotelCrudFactory   crudHotel   = new HotelCrudFactory();


                var     resReserva = crudReserva.Retrieve <Reserva>(reserva);
                Factura factura    = new Factura();


                while (resReserva != null)
                {
                    var guid        = Guid.NewGuid();
                    var justNumbers = new String(guid.ToString().Where(Char.IsDigit).ToArray());
                    reserva.Codigo = int.Parse(justNumbers.Substring(0, 9));
                    resReserva     = crudReserva.Retrieve <Reserva>(reserva);
                }
                ;

                var resFactura = new Factura();
                do
                {
                    var guid        = Guid.NewGuid();
                    var justNumbers = new String(guid.ToString().Where(Char.IsDigit).ToArray());

                    factura.NumFacturacion = int.Parse(justNumbers.Substring(0, 9));
                    resFactura             = crudFactura.Retrieve <Factura>(factura);
                } while (resFactura != null);



                int[] cH   = reserva.CantHabitaciones;
                int   cont = 0;
                var   r    = new Reserva
                {
                    Codigo         = reserva.Codigo,
                    FechaInicio    = reserva.FechaInicio,
                    FechaFin       = reserva.FechaFin,
                    Precio         = reserva.Precio,
                    Promocion      = reserva.Promocion,
                    IdUsuario      = reserva.IdUsuario,
                    IdHotel        = reserva.IdHotel,
                    CantPersonas   = reserva.CantPersonas,
                    NumFacturacion = factura.NumFacturacion
                };


                crudReserva.Create(r);


                cont = 0;

                foreach (string tipoHab in reserva.TipoHabitaciones)
                {
                    var r3 = new Reserva
                    {
                        TipoHab     = tipoHab,
                        CantHab     = cH[cont],
                        Codigo      = reserva.Codigo,
                        IdHotel     = reserva.IdHotel,
                        FechaInicio = reserva.FechaInicio,
                        FechaFin    = reserva.FechaFin
                    };
                    crudReserva.AsignarHabitacionReserva(r3);
                    cont++;
                }


                Usuario usuarioEncontrado = null;

                var u = new Usuario
                {
                    Identificacion = reserva.IdUsuario
                };

                usuarioEncontrado = mngUsuario.RetrieveById(u);


                LlaveQR llave = new LlaveQR();
                llave.EstadoQR  = "1";
                llave.IdReserva = reserva.Codigo;
                llave.IdUsuario = usuarioEncontrado.Correo;

                await mngLlave.CreateYEnviar(llave, usuarioEncontrado);

                var rQR = new LlaveQR
                {
                    IdReserva = reserva.Codigo
                };

                var respuesta = mngLlave.RetrieveAllByReserva(rQR);


                var llaveReserva = new Reserva
                {
                    Codigo  = reserva.Codigo,
                    LlaveQR = respuesta[0].ImagenQR
                };

                crudReserva.AsignarQRReservaReserva(llaveReserva);


                //string numeroFactura, string descripcion, ArrayList detalles, Hotel hotel, Usuario cliente



                var detalleFactura = new LineaDetalleFactura
                {
                    Nombre   = "Reservación",
                    Precio   = (float)reserva.Precio,
                    Cantidad = 1,
                    SubTotal = (float)reserva.Precio,
                    Impuesto = 0,
                    Total    = (float)reserva.Precio
                };

                ArrayList detalle = new ArrayList();
                detalle.Add(detalleFactura);


                var h = new Hotel
                {
                    CedulaJuridica = reserva.IdHotel
                };

                Hotel hotel = crudHotel.Retrieve <Hotel>(h);


                string numFactura = Convert.ToString(factura.NumFacturacion);

                await PdfManager.Create(numFactura,
                                        "el pago de una reservación en AdTrip", detalle, hotel,
                                        (Usuario)usuarioEncontrado);
            }
            catch (Exception ex)
            {
                ExceptionManager.GetInstance().Process(ex);
            }
        }