app.R

# Load R packages
library(shiny)
library(shinythemes)
library(httr)
library(jsonlite)
library(base64enc)
library(digest)
library(shinycssloaders)
library(dplyr)
library(htmlwidgets)

# Source utility functions
source("utils.R")

################################################################################
# AUTHENTICATION CONFIGURATION - Set your method here
################################################################################
USE_OAUTH2 <- FALSE  # Set to FALSE for JWT (default), TRUE for OAuth2

# OAuth2 credentials (only used if USE_OAUTH2 = TRUE)
if (USE_OAUTH2) {
  client_id     <- Sys.getenv("BENCHLING_CLIENT_ID")
  client_secret <- Sys.getenv("BENCHLING_CLIENT_SECRET")
  domain_fixed  <- Sys.getenv("BENCHLING_DOMAIN")

  if (client_id == "" || client_secret == "" || domain_fixed == "") {
    stop("OAuth2 enabled but credentials missing! Set BENCHLING_CLIENT_ID, BENCHLING_CLIENT_SECRET, and BENCHLING_DOMAIN in .Renviron")
  }
}
################################################################################

# Define UI
ui <- fluidPage(theme = shinytheme("cerulean"),

  navbarPage(
    "R Shiny - IC50 Calc",

    tabPanel("Import Dataset",

             sidebarPanel(
               tags$h3("Input:"),
               textInput("DatasetKey", "Analysis Key:", ""),
               actionButton("submitbutton", "Get Dataset", class = "btn btn-primary"),
               actionButton("sendresultAnalysis", "Send Analysis", class = "btn btn-primary")
             ),

             mainPanel(
               tags$label(h4("Tenant Subdomain")),
               verbatimTextOutput("subdomain"),
               verbatimTextOutput("analysis") %>% withSpinner(color="#0dc5c1"),
               tableOutput('tabledata')
             )
    ),

    tabPanel("Regression Algorithm",
             mainPanel(
               tags$h2("4-Parameter Log-Logistic Model (LL.4)"),
               tags$p("IC50 calculations use dose-response curve fitting with the drc package.")
             )
    )
  )
)

# Define server function
server <- function(input, output) {

  # Extract base domain (full domain including suffix)
  base_domain <- reactive({
    if (USE_OAUTH2) {
      # OAuth2: use domain from credentials
      domain_fixed
    } else {
      # JWT: extract from analysis key
      split_key <- strsplit(input$DatasetKey, ".", fixed = TRUE)
      payload <- jsonlite::fromJSON(rawToChar(base64decode(split_key[[1]][2])))
      domain_raw <- payload$aud

      # Determine if this is a full domain or just a subdomain
      if (grepl("\\.", domain_raw)) {
        # Contains a dot - it's a full domain, use as-is
        domain_raw
      } else {
        # No dot - it's just a subdomain, append .benchling.com
        paste0(domain_raw, ".benchling.com")
      }
    }
  })

  # Extract subdomain (first part only, for display)
  subdomain <- reactive({
    sub("\\..*", "", base_domain())
  })

  # Get dataset from Benchling
  datasetInput <- reactive({

    # Extract analysis ID from key
    key_parts <- strsplit(input$DatasetKey, ":", fixed = TRUE)[[1]]
    analysis_id <- key_parts[1]

    # Get access token based on auth method
    if (USE_OAUTH2) {
      # OAuth2: Generate token from app credentials
      token_url <- paste0("https://", domain_fixed, "/api/v2/token")
      token_request <- httr::POST(
        url = token_url,
        body = paste0("client_id=", client_id,
                      "&client_secret=", client_secret,
                      "&grant_type=client_credentials"),
        httr::accept('application/json'),
        httr::content_type('application/x-www-form-urlencoded')
      )

      if (token_request$status_code != 200) {
        stop("OAuth2 authentication failed!")
      }

      request_body <- jsonlite::fromJSON(rawToChar(token_request$content))
      access_token <- request_body$access_token
    } else {
      # JWT: Use token from analysis key
      access_token <- key_parts[2]
    }

    # Get analysis
    endpoint <- "/api/v2-beta/analyses/"
    URL <- paste("https://", isolate(base_domain()), endpoint, analysis_id, sep = "")

    analysis_req <- GET(URL, add_headers(
      Accept = 'application/json',
      Authorization = paste("Bearer", access_token)
    ))
    dat <- jsonlite::fromJSON(rawToChar(analysis_req$content))

    datasetId <- c(dat$dataFrameIds)[1]
    folder_id <- c(dat$folderId)

    # Store for later use
    assign("access_token", access_token, envir = .GlobalEnv)
    assign("folder_id", folder_id, envir = .GlobalEnv)
    assign("analysis_id", analysis_id, envir = .GlobalEnv)

    # Get dataset
    endpoint <- "/api/v2-beta/data-frames/"
    URL <- paste("https://", isolate(base_domain()), endpoint, datasetId, sep = "")

    Dataset_req <- GET(URL, add_headers(
      Accept = 'application/json',
      Authorization = paste("Bearer", access_token)
    ))
    dat <- jsonlite::fromJSON(rawToChar(Dataset_req$content))

    DatasetUrl <- c(dat$manifest$url)
    df <- read.csv(DatasetUrl)

    df
  })

  # Process analysis and upload results
  analysis <- reactive({

    df <- datasetInput()

    # Find concentration column
    conc_col <- grep("^Concentration$|Cell\\.Mortality\\.Concentration",
                     names(df), ignore.case = TRUE, value = TRUE)[1]

    # Find mortality columns (matches "Mortality.24h" or "Cell.Mortality.Mortality.24h")
    mort_24h_col <- grep("Mortality\\.24h",
                         names(df), ignore.case = TRUE, value = TRUE)[1]
    mort_48h_col <- grep("Mortality\\.48h",
                         names(df), ignore.case = TRUE, value = TRUE)[1]

    # Calculate IC50 for 24h using utility function
    result_24 <- calculate_ic50(df, conc_col, mort_24h_col)
    IC50_24 <- result_24$ic50
    slope_24 <- result_24$slope

    # Calculate IC50 for 48h using utility function
    result_48 <- calculate_ic50(df, conc_col, mort_48h_col)
    IC50_48 <- result_48$ic50
    slope_48 <- result_48$slope

    # Create plotly graphs using utility function
    imageName_24 <- "mortality_24h.html"
    File_24 <- tempfile(fileext = ".html")

    plot_24 <- create_ic50_plot(df, conc_col, mort_24h_col, IC50_24, slope_24,
                                title = "IC50 24h Dose-Response")
    saveWidget(widget = plot_24, file = File_24, selfcontained = TRUE)

    imageName_48 <- "mortality_48h.html"
    File_48 <- tempfile(fileext = ".html")

    plot_48 <- create_ic50_plot(df, conc_col, mort_48h_col, IC50_48, slope_48,
                                title = "IC50 48h Dose-Response")
    saveWidget(widget = plot_48, file = File_48, selfcontained = TRUE)

    # Upload files to Benchling
    upload_file <- function(filepath, filename, folder_id, access_token, base_domain) {
      endpoint <- "/api/v2-beta/files"
      URL <- paste("https://", base_domain, endpoint, sep = "")

      my_data <- readBin(filepath, "raw", 10e6)

      filePostBody <- list(name = filename, folderId = folder_id, filename = filename)
      filePostResponse <- httr::POST(
        url = URL,
        body = toJSON(filePostBody, pretty = TRUE, auto_unbox = TRUE),
        httr::accept('application/json'),
        httr::add_headers('Authorization' = paste("Bearer", access_token)),
        httr::content_type('application/json')
      )

      dat <- jsonlite::fromJSON(rawToChar(filePostResponse$content))
      fileID <- dat$id
      s3_Put_Url <- filePostResponse$headers$`content-location`

      s3FileUpload <- httr::PUT(
        url = s3_Put_Url,
        body = my_data,
        httr::add_headers('x-amz-server-side-encryption' = 'AES256')
      )

      if (s3FileUpload$status_code == 200) {
        endpoint <- "/api/v2-beta/files/"
        URL <- paste("https://", base_domain, endpoint, fileID, sep = "")

        s3FileUploadStatus <- list(uploadStatus = 'SUCCEEDED')

        PatchFile <- httr::PATCH(
          url = URL,
          body = toJSON(s3FileUploadStatus, pretty = TRUE, auto_unbox = TRUE),
          httr::accept('application/json'),
          httr::add_headers('Authorization' = paste("Bearer", access_token)),
          httr::content_type('application/json')
        )
      }

      fileID
    }

    fileID_24 <- upload_file(File_24, imageName_24, folder_id, access_token, isolate(base_domain()))
    fileID_48 <- upload_file(File_48, imageName_48, folder_id, access_token, isolate(base_domain()))

    # Create and upload CSV results
    cell_name <- unique(df$Cell.Name)[1]
    Cell <- rep(cell_name, 2)
    Hours <- c(24, 48)
    Function <- c('LL.4', 'LL.4')
    IC50 <- c(IC50_24, IC50_48)

    Csv_df <- data.frame(Cell, Hours, Function, IC50)

    Csv_file <- tempfile(fileext = ".csv")
    write.csv(Csv_df, Csv_file, row.names = FALSE)

    # Upload CSV as dataframe
    endpoint <- "/api/v2-beta/data-frames"
    URL <- paste("https://", isolate(base_domain()), endpoint, sep = "")

    my_data <- readBin(Csv_file, "raw", 10e6)

    DatasetBody <- list(manifest = list(list(fileName = "mortality.csv")), name = 'MortalityIC50')

    DatasetPostResponse <- httr::POST(
      url = URL,
      body = toJSON(DatasetBody, pretty = TRUE, auto_unbox = TRUE),
      httr::accept('application/json'),
      httr::add_headers('Authorization' = paste("Bearer", access_token)),
      httr::content_type('application/json')
    )

    dat <- jsonlite::fromJSON(rawToChar(DatasetPostResponse$content))
    DatasetID_Result <- dat$id
    s3_Put_Url <- dat$manifest$url

    s3FileUpload <- httr::PUT(
      url = s3_Put_Url,
      body = my_data,
      httr::add_headers('x-amz-server-side-encryption' = 'AES256')
    )

    if (s3FileUpload$status_code == 200) {
      endpoint <- "/api/v2-beta/data-frames/"
      URL <- paste("https://", isolate(base_domain()), endpoint, DatasetID_Result, sep = "")

      DatasetStatusBody <- list(uploadStatus = "IN_PROGRESS")

      PatchFile <- httr::PATCH(
        url = URL,
        body = toJSON(DatasetStatusBody, pretty = TRUE, auto_unbox = TRUE),
        httr::accept('application/json'),
        httr::add_headers('Authorization' = paste("Bearer", access_token)),
        httr::content_type('application/json')
      )
    }

    # Patch analysis with outputs
    endpoint <- "/api/v2-beta/analyses/"
    URL <- paste("https://", isolate(base_domain()), endpoint, analysis_id, sep = "")

    Analysisfiles <- list(fileIds = list(fileID_24, fileID_48), dataFrameIds = list(DatasetID_Result))

    PatchAnalysis <- httr::PATCH(
      url = URL,
      body = toJSON(Analysisfiles, pretty = TRUE, auto_unbox = TRUE),
      httr::accept('application/json'),
      httr::add_headers('Authorization' = paste("Bearer", access_token)),
      httr::content_type('application/json')
    )

    dat <- jsonlite::fromJSON(rawToChar(PatchAnalysis$content))
    paste("Analysis complete! Status:", dat$status)
  })

  # Outputs
  output$subdomain <- renderText({
    if (input$submitbutton > 0) {
      isolate(subdomain())
    } else {
      "Enter Analysis Key"
    }
  })

  output$tabledata <- renderTable({
    if (input$submitbutton > 0) {
      datasetInput()
    }
  })

  output$analysis <- renderText({
    if (input$sendresultAnalysis > 0) {
      isolate(analysis())
    } else {
      "Click 'Send Analysis' to process"
    }
  })
}

shinyApp(ui = ui, server = server)