Communication between modules and looping through values to create several modules

Question

Goal

I have five expectations:

1. Solution using modules
2. Communication between modules
3. Dynamic creation of modules
4. local storage using shinyStore
5. Export result in dataframe

What has worked so far

This is a continuation of the following question.

I have a Shiny app that currently has two modules, but I have had issues with both of them communicating. The first module Selects any number of species within a Species pool (SpeciesSelect), this module is in the file R/SpeciesSelect.R within my working directory with the following code.

SpeciesSelect_UI <- function(id, SpeciesList){
  ns <- NS(id)
  tagList(
    shiny::selectizeInput(inputId = ns("SpeciesNames"), label = "SpeciesName", 
                  choices = SpeciesList,
                  multiple = T)
  )
}

SpeciesSelect_Server <- function(id){
  moduleServer(id, function(input, output, session) {
    # return the reactive here
    return(reactive({input$SpeciesNames}))
  })
}

And the second module (SpeciesCount) would use those species in order to select how you sample them, and in some cases to count them when the method is equal to pinpoint. This is stored in R/SpeciesCount.R and the code is as follows:

SpeciesCount_UI <- function(id, Species){
  ns <- NS(id)
  tagList(
    shinyMobile::f7Card(
      f7Flex(
        textOutput(ns("SpeciesAgain")),
        uiOutput(ns("Sampling_type_ui")),
        uiOutput(ns("SpeciesCount"))
      )
    )
  )
}

SpeciesCount_Server <- function(id, Species){
  moduleServer(id, function(input, output, session) {
    output$SpeciesAgain <- renderText({Species})
    ns <- session$ns
    
    output$Sampling_type_ui <- renderUI({
      #req(input$SpeciesName)
      req(Species)
      f7Select(inputId = ns("Sampling_type"), 
               label = "Sampling type", 
               choices = c("5m circle", "15m circle", "Pin-point"))
      
    })
    
    output$SpeciesCount <- renderUI({
      if (req(input$Sampling_type) == "Pin-point") {
        shinyMobile::f7Stepper(inputId = ns("Species1"), label = "Species count", min = 1, max = 1000, step = 1, value = 1)
      }
    })
  })
}

Each of the modules is working well on its own as shown in the following example:

library(shiny)
library(shinyMobile)
library(shinyStore)

source("R/SpeciesCount.R")
source("R/SpeciesSelect.R")

SpeciesList <- c("Species1", "Species2", "Species3", "Species4", "Species5")

ui = f7Page(
  title = "Show navbar",
  f7SingleLayout(
    navbar = f7Navbar("Hide/Show navbar"),
    f7Button(inputId = "toggle", "Toggle navbar", color = "red"),
    SpeciesSelect_UI(id = "SpeciesList", SpeciesList = SpeciesList),
    lapply(seq_along(SpeciesList), function(i) {
      SpeciesCount_UI(id = i, Species = SpeciesList[i])
    })
  )
)
server = function(input, output, session) {  
  
  lapply(seq_along(SpeciesList), function(i) {
    SpeciesCount_Server(id = i, Species = SpeciesList[i])
  })
  
  observeEvent(input$toggle, {
    updateF7Navbar()
  })
}

shinyApp(ui, server)

I have 4 issues that are not working well, first, the communication between modules, and then looping through the results of the first module to get several of the second module, the localStorage issue, and finally exporting it to a dataframe

Communication between modules and dynamic UI generation

In order to isolate both issues, for the communication problem, I selected only one species and took out the lapply function to see if I can get the SpeciesCount to recognise the output of the SpeciesSelect_Server and incorporate it into the SpeciesCount module, here is the code I ended up with:

library(shiny)
library(shinyMobile)
library(shinyStore)

source("R/SpeciesCount.R")
source("R/SpeciesSelect.R")

LIST <- c("Species1", "Species2", "Species3", "Species4", "Species5")

ui = f7Page(
  title = "Show navbar",
  f7SingleLayout(
    navbar = f7Navbar("Hide/Show navbar"),
    f7Button(inputId = "toggle", "Toggle navbar", color = "red"),
    SpeciesSelect_UI(id = "SpeciesList", SpeciesList = LIST),
    SpeciesCount_UI(id = "SpeciesCount", Species = SpeciesSelected())
  )
)
server = function(input, output, session) {
  
  SpeciesSelected <- SpeciesSelect_Server(id = "SpeciesList")
  
  
  
  SpeciesCount_Server(id = "SpeciesCount", Species = SpeciesSelected())
  
  
  observeEvent(input$toggle, {
    updateF7Navbar()
  })
}

shinyApp(ui, server)

But the results of the SpeciesSelect module are not generating any UI in the SpeciesCount module

Adding the LocalStorage issue

This app is going to be used in the field, that means, that at time we might get connectivity issues, I have issues at storing the values of the Species Select Module, then for sure I will have issues with the next module this is the shiny app I am using

library(shiny)
library(shinyMobile)
library(shinyStore)

source("R/SpeciesCount.R")
source("R/SpeciesSelect.R")

SpeciesList <- c("Species1", "Species2", "Species3", "Species4", "Species5")

ui = f7Page(
  title = "Show navbar",
  f7SingleLayout(
    navbar = f7Navbar("Hide/Show navbar"),
    f7Button(inputId = "toggle", "Toggle navbar", color = "red"),
    SpeciesSelect_UI(id = "SpeciesList", SpeciesList = SpeciesList),
    lapply(seq_along(SpeciesList), function(i) {
      SpeciesCount_UI(id = i, Species = SpeciesList[i])
    })
  )
)
server = function(input, output, session) {  
  
  lapply(seq_along(SpeciesList), function(i) {
    SpeciesCount_Server(id = i, Species = SpeciesList[i])
  })
  
  observeEvent(input$toggle, {
    updateF7Navbar()
  })
}

shinyApp(ui, server)

And I modified the species select for that also

SpeciesSelect_UI <- function(id, SpeciesList){
  ns <- NS(id)
  tagList(
    shiny::selectizeInput(inputId = ns("SpeciesNames"), label = "SpeciesName", 
                  choices = SpeciesList,
                  multiple = T)
  )
}

SpeciesSelect_Server <- function(id){
  moduleServer(id, function(input, output, session) {
    ns <- session$ns
    # return the reactive here
    observeEvent(input$save, {
      updateStore(session, name = ns("SpeciesNames"), input$SpeciesNames)
    }, ignoreInit = TRUE)
    
    observeEvent(input$clear, {
      # clear current user inputs:
      updateTextInput(session, inputId = ns("SpeciesNames"), value = "")
      
      # clear shinyStore:
      updateStore(session, name = ns("SpeciesNames"), value = "")
    }, ignoreInit = TRUE)
    
    return(reactive({ns(input$SpeciesNames)}))
  })
}

But nothing gets stored. Maybe creating a module for shiny store is needed?

Export as a dataframe

This one is tied two point 2:

So lets say I am in the following input set:

The idea would be to generate a reactive that has the following that frame, that I can then export as a CSV file. I think I can handle the export, but I am unsure on how to generate the data.frame from the dynamic UI:

data.frame(Species = c("Species1", "Species2", "Species3"), Method = c("Pin-point","5m circle", "15m circle"), abundance = c(5, 1, 1))

Answer 1

Your first module is probably already silently returning the reactive but for clarity you can make it explicit. In you first module, return a reactive:

SpeciesSelect_Server <- function(id){
  moduleServer(id, function(input, output, session) {
    # return the reactive here
    return(reactive({input$SpeciesNames}))
  })
}

Now call the module AND assign its output a name where you'd like to use it (in another module or in your app server), like this:

selected_species <- SpeciesSelect_Server(id = "SpeciesList")

Now selected_species can be called, observed, etc with:

selected_species()