who deploys most often (interactive table edition) (#32)

Author: toph-allen

extensions/who-deploys-most-often/_quarto.yml

@@ -1,60 +1,135 @@
 library(shiny)
 library(bslib)
+library(shinyjs)
+library(DT)
 library(dplyr)
 library(purrr)
 library(connectapi)
+library(pins)
+library(tidyr)
 
 shinyOptions(
-  cache = cachem::cache_disk("./app_cache/cache/", max_age = 60 * 60 * 12)
+  cache = cachem::cache_disk("./app_cache/cache/", max_age = 60 * 60 * 24)
 )
 
-ui <- page_fluid(
+ui <- page_fillable(
+  useShinyjs(),
+
   theme = bs_theme(version = 5),
 
   card(
     card_header("Who Deploys Most Often"),
     layout_sidebar(
       sidebar = sidebar(
-        title = "No Filters Yet",
-        open = FALSE
+        title = "Filter Data",
+        open = FALSE,
+        actionButton("clear_cache", "Clear Cache", icon = icon("refresh"))
       ),
-      card_body("Note: `n_bundles` currently uses synthetic data."),
+      card_body(textOutput("data_note"), fill = FALSE),
       card(
-        tableOutput("user_table")
+        DTOutput("user_table")
       )
     )
   )
 )
 
 server <- function(input, output, session) {
+  # Cache invalidation button ----
+  cache <- cachem::cache_disk("./app_cache/cache/")
+  observeEvent(input$clear_cache, {
+    print("Cache cleared!")
+    cache$reset()  # Clears all cached data
+    session$reload()  # Reload the app to ensure fresh data
+  })
+
+  # Data processing ----
+
   client <- connect()
 
   # Load data
   content <- reactive({
-    get_content(client) |>
-      # Fake data, to be replaced with real data later.
-      mutate(n_bundles = rpois(n(), 3))
+    get_content(client)
   }) |> bindCache("static_key")
 
-  user_table <- reactive({
-    content() |>
-      # The `owner` column is a nested list-column.
-      # We extract the requisite metadata up to be first-class atomic vector columns.
-      mutate(
-        username = map_chr(owner, "username"),
-        user_full_name = paste(map_chr(owner, "first_name"), map_chr(owner, "last_name"))
-      ) |>
-      group_by(username) |>
+  users <- reactive({
+    get_users(client)
+  }) |> bindCache("static_key")
+
+  # No need to cache, as it is only loaded when summarized_data is refreshed
+  # (and is already cached in a pin).
+  audit_logs <- reactive({
+    board <- board_connect()
+    PIN_NAME <- paste0(board$account, "/", "connect_metrics_cache_audit_logs")
+    pin_read(board, PIN_NAME)
+  })
+
+  summarized_data <- reactive({
+    audit_log_summary <- audit_logs() |>
+      filter(action %in% c("deploy_application", "add_application")) |>
+      group_by(user_guid, action) |>
       summarize(
-        user_full_name = first(user_full_name),
-        n_bundles = sum(n_bundles),
-        n_content_items = n(),
-        last_deploy = format(max(last_deployed_time, na.rm = TRUE), "%Y-%m-%d at %I:%M %p")
+        n = n(),
+        latest = max(time),
+        .groups = "drop"
       ) |>
-      arrange(desc(n_content_items))
+      pivot_wider(names_from = action, values_from = c(n, latest), values_fill = list(n = 0))
+
+    content_summary <- content() |>
+      mutate(user_guid = map_chr(owner, "guid")) |>
+      group_by(user_guid) |>
+      summarize(active_content = n())
+
+    # Merge all the data together by user guid.
+    users () |>
+      mutate(full_name = paste(first_name, last_name)) |>
+      select(user_guid = guid, username, full_name) |>
+      full_join(audit_log_summary, by = "user_guid") |>
+      full_join(content_summary, by = "user_guid") |>
+      select(
+        username,
+        full_name,
+        active_content,
+        n_new_content = n_add_application,
+        n_deploy = n_deploy_application,
+        latest_deploy = latest_deploy_application
+      ) |>
+      filter(!(is.na(active_content) & is.na(n_new_content) & is.na(n_deploy)))
+  }) |> bindCache("static_key")
+
+  # Cached on the same cadence as summarized_data to avoid loading audit logs
+  # when not required.
+  earliest_record <- reactive({
+    min(audit_logs()$time)
   }) |> bindCache("static_key")
 
-  output$user_table <- renderTable({user_table()})
+  output$data_note <- renderText(
+    paste(
+      "* Since",
+      earliest_record()
+    )
+  )
+
+  output$user_table <- renderDT({
+    print(names(summarized_data()))
+    datatable(
+      summarized_data(),
+      options = list(
+        order = list(list(3, "desc")),
+        paging = FALSE,
+        searching = FALSE
+      ),
+      filter = "top",
+      colnames = c(
+        "Username" = "username",
+        "User" = "full_name",
+        "Total Active Content" = "active_content",
+        "Number of Newly Created Content*" = "n_new_content",
+        "Number of Deploys*" = "n_deploy",
+        "Time of Latest Deploy" = "latest_deploy"
+      )
+    ) |>
+      formatDate(columns = "Time of Latest Deploy", method = "toLocaleString")
+  })
 }
 
 shinyApp(ui, server)

extensions/who-deploys-most-often/app.R

@@ -0,0 +1,4 @@
+name = "who-deploys-most-often"
+title = "Who Deploys Most Often (interactive table edition)"
+description = "A prototype extension showing who deploys most often."
+access_type = "acl"

extensions/who-deploys-most-often/connect-extension.toml

@@ -0,0 +1,17 @@
+#' ---
+#' title: "Script to get and pin a large segment of audit logs data"
+#' ---
+
+library(connectapi)
+library(pins)
+
+client <- connect()
+
+audit_logs <- get_audit_logs(client, limit = 1000000, asc_order = FALSE)
+
+board <- board_connect()
+PIN_NAME <- paste0(board$account, "/", "connect_metrics_cache_audit_logs")
+
+pin_write(board, audit_logs, name = PIN_NAME)
+
+# To read the data, run: `pin_read(board, PIN_NAME)`