From ddb107ddcc1c48c7b322aa8fee54d50c29d593ab Mon Sep 17 00:00:00 2001
From: andres <afquinteromoreano@gmail.com>
Date: Tue, 2 Jan 2024 14:22:45 -0500
Subject: [PATCH] Adds vignette for Google Auth with Shiny

---
 .Rbuildignore                             |   2 +
 .gitignore                                |   1 +
 DESCRIPTION                               |   5 +
 _pkgdown.yml                              |   1 -
 vignettes/.gitignore                      |   2 +
 vignettes/en_securing_shiny_google.Rmd    | 108 ++++++++++++++++++++++
 vignettes/es_asegura_shiny_con_google.Rmd | 108 ++++++++++++++++++++++
 7 files changed, 226 insertions(+), 1 deletion(-)
 create mode 100644 vignettes/.gitignore
 create mode 100644 vignettes/en_securing_shiny_google.Rmd
 create mode 100644 vignettes/es_asegura_shiny_con_google.Rmd

diff --git a/.Rbuildignore b/.Rbuildignore
index afa5e21..f2e0ac6 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -2,3 +2,5 @@
 ^_pkgdown\.yml$
 ^docs$
 ^pkgdown$
+^.github$
+^example$
diff --git a/.gitignore b/.gitignore
index e0f5575..d72378a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,3 +50,4 @@ rsconnect/
 
 example/.Renviron
 docs
+inst/doc
diff --git a/DESCRIPTION b/DESCRIPTION
index f5427b1..1ca12e2 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -11,6 +11,8 @@ Description: The ultimate R package for swift and seamless Single Sign-On (SSO)
     like Google and Microsoft, tapLock streamlines authentication, enhancing both
     user experience and application security. Elevate your R-based projects with
     tapLock for a simplified, unified, and secure authentication process.
+URL: https://github.com/ixpantia/tapLock
+BugReports: https://github.com/ixpantia/tapLock/issues
 License: MIT + file LICENSE
 Encoding: UTF-8
 Roxygen: list(markdown = TRUE)
@@ -27,4 +29,7 @@ Imports:
     future,
     stats
 Suggests:
+    knitr,
+    rmarkdown,
     shiny
+VignetteBuilder: knitr
diff --git a/_pkgdown.yml b/_pkgdown.yml
index d71acfb..b7517c2 100644
--- a/_pkgdown.yml
+++ b/_pkgdown.yml
@@ -1,4 +1,3 @@
 url: ~
 template:
   bootstrap: 5
-
diff --git a/vignettes/.gitignore b/vignettes/.gitignore
new file mode 100644
index 0000000..097b241
--- /dev/null
+++ b/vignettes/.gitignore
@@ -0,0 +1,2 @@
+*.html
+*.R
diff --git a/vignettes/en_securing_shiny_google.Rmd b/vignettes/en_securing_shiny_google.Rmd
new file mode 100644
index 0000000..8d80449
--- /dev/null
+++ b/vignettes/en_securing_shiny_google.Rmd
@@ -0,0 +1,108 @@
+---
+title: "(English) Securing Shiny with Google Auth"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{(English) Securing Shiny with Google Auth}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include = FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>"
+)
+```
+
+## Introduction
+
+This vignette provides a step-by-step tutorial on how to secure a Shiny application using Google authentication through the tapLock R package. tapLock simplifies the integration of OpenID Connect and OAuth 2.0 into Shiny applications, ensuring robust security with minimal coding effort.
+
+## Prerequisites
+
+Before proceeding, ensure you have the following:
+- A basic understanding of R and Shiny.
+- A Shiny application ready for deployment.
+- Access to Google Developer Console for OAuth credentials.
+- (Optional) A server with HTTPS enabled.
+
+## Step 1: Install tapLock
+
+Install tapLock from GitHub using the `pak` package:
+
+```r
+pak::pak("ixpantia/taplock")
+```
+
+## Step 2: Create Google OAuth Credentials
+
+1. Go to the [Google Developer Console](https://console.developers.google.com/).
+2. Create a new project or select an existing one.
+3. Navigate to 'Credentials' and create 'OAuth client ID' credentials.
+4. Set the **`Authorized JavaScript origins`** to your Shiny application URL.
+5. Set the **`Authorized redirect URIs`** to your Shiny application URL with
+   the suffix `/login`.
+6. Note down the `client_id` and `client_secret`.
+
+## Step 3: Configure Authentication in R
+
+Load tapLock and set up the authentication configuration:
+
+```r
+library(taplock)
+
+auth_config <- new_openid_config(
+  provider = "google",
+  client_id = Sys.getenv("GOOGLE_CLIENT_ID"),
+  client_secret = Sys.getenv("GOOGLE_CLIENT_SECRET"),
+  app_url = Sys.getenv("SHINY_APP_URL")
+)
+```
+
+Replace `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`, and `SHINY_APP_URL` with your actual credentials and application URL in your environment variables.
+
+## Step 4: Modify Shiny Application
+
+Modify your Shiny app to use `sso_shiny_app`:
+
+```r
+library(shiny)
+library(tapLock)
+
+# Authentication configuration
+auth_config <- new_openid_config(
+  provider = "google",
+  client_id = Sys.getenv("GOOGLE_CLIENT_ID"),
+  client_secret = Sys.getenv("GOOGLE_CLIENT_SECRET"),
+  app_url = Sys.getenv("SHINY_APP_URL")
+)
+
+# UI
+ui <- fluidPage(
+  tags$h1("Welcome to the Secure Shiny App"),
+  textOutput("userInfo")
+)
+
+# Server
+server <- function(input, output, session) {
+  output$userInfo <- renderText({
+    user_email <- get_token_field(token(), "email")
+    glue::glue("Logged in as: {user_email}")
+  })
+}
+
+# Secure Shiny app with tapLock
+sso_shiny_app(auth_config, ui, server)
+```
+
+## Step 5: Deploy the Application
+
+Deploy your Shiny application as you normally would. The tapLock package handles the authentication process.
+We recommend deploying your application with a solution like Shiny Server
+(Open Source or Pro) or with [Faucet](https://github.com/andyquinterom/faucet).
+Solutions like Posit Connect already include authentication and do not require
+tapLock.
+
+## Conclusion
+
+By following these steps, you have successfully secured your Shiny application with Google authentication using tapLock. This ensures that only authenticated users can access your application, enhancing its security and privacy.
diff --git a/vignettes/es_asegura_shiny_con_google.Rmd b/vignettes/es_asegura_shiny_con_google.Rmd
new file mode 100644
index 0000000..d0e3a85
--- /dev/null
+++ b/vignettes/es_asegura_shiny_con_google.Rmd
@@ -0,0 +1,108 @@
+---
+title: "(Español) Asegurando Shiny con Google Auth"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{(Español) Asegurando Shiny con Google Auth}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include = FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>"
+)
+```
+
+## Introducción
+
+Esta viñeta proporciona un tutorial paso a paso sobre cómo asegurar una aplicación Shiny utilizando la autenticación de Google a través del paquete R tapLock. tapLock simplifica la integración de OpenID Connect y OAuth 2.0 en aplicaciones Shiny, asegurando una robusta seguridad con un esfuerzo mínimo de codificación.
+
+## Prerrequisitos
+
+Antes de proceder, asegúrate de tener lo siguiente:
+- Un conocimiento básico de R y Shiny.
+- Una aplicación Shiny lista para ser desplegada.
+- Acceso a Google Developer Console para las credenciales OAuth.
+- (Opcional) Un servidor con HTTPS habilitado.
+
+## Paso 1: Instalar tapLock
+
+Instala tapLock desde GitHub usando el paquete `pak`:
+
+```r
+pak::pak("ixpantia/taplock")
+```
+
+## Paso 2: Crear Credenciales OAuth de Google
+
+1. Ve a [Google Developer Console](https://console.developers.google.com/).
+2. Crea un nuevo proyecto o selecciona uno existente.
+3. Navega a 'Credenciales' y crea credenciales 'OAuth client ID'.
+4. Establece los **`Authorized JavaScript origins`** en la URL de tu aplicación Shiny.
+5. Establece los **`Authorized redirect URIs`** en la URL de tu aplicación Shiny con
+   el sufijo `/login`.
+6. Anota el `client_id` y el `client_secret`.
+
+## Paso 3: Configurar Autenticación en R
+
+Carga tapLock y configura la autenticación:
+
+```r
+library(taplock)
+
+auth_config <- new_openid_config(
+  provider = "google",
+  client_id = Sys.getenv("GOOGLE_CLIENT_ID"),
+  client_secret = Sys.getenv("GOOGLE_CLIENT_SECRET"),
+  app_url = Sys.getenv("SHINY_APP_URL")
+)
+```
+
+Reemplaza `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`, y `SHINY_APP_URL` con tus credenciales reales y la URL de tu aplicación en tus variables de entorno.
+
+## Paso 4: Modificar Aplicación Shiny
+
+Modifica tu aplicación Shiny para usar `sso_shiny_app`:
+
+```r
+library(shiny)
+library(tapLock)
+
+# Configuración de autenticación
+auth_config <- new_openid_config(
+  provider = "google",
+  client_id = Sys.getenv("GOOGLE_CLIENT_ID"),
+  client_secret = Sys.getenv("GOOGLE_CLIENT_SECRET"),
+  app_url = Sys.getenv("SHINY_APP_URL")
+)
+
+# UI
+ui <- fluidPage(
+  tags$h1("Bienvenido a la Aplicación Shiny Segura"),
+  textOutput("userInfo")
+)
+
+# Server
+server <- function(input, output, session) {
+  output$userInfo <- renderText({
+    user_email <- get_token_field(token(), "email")
+    glue::glue("Conectado como: {user_email}")
+  })
+}
+
+# Asegurar aplicación Shiny con tapLock
+sso_shiny_app(auth_config, ui, server)
+```
+
+## Paso 5: Desplegar la Aplicación
+
+Despliega tu aplicación Shiny como lo harías normalmente. El paquete tapLock maneja el proceso de autenticación.
+Recomendamos desplegar tu aplicación con una solución como Shiny Server
+(Open Source o Pro) o con [Faucet](https://github.com/andyquinterom/faucet).
+Soluciones como Posit Connect ya incluyen autenticación y no requieren
+tapLock.
+
+## Conclusión
+
+Siguiendo estos pasos, has asegurado con éxito tu aplicación Shiny con autenticación de Google utilizando tapLock. Esto asegura que solo los usuarios autenticados puedan acceder a tu aplicación, mejorando su seguridad y privacidad.