forked from darwin-eu-dev/TreatmentPatterns
-
Notifications
You must be signed in to change notification settings - Fork 1
/
usingTreatmentPatternsShinyModules.Rmd
211 lines (176 loc) · 7.05 KB
/
usingTreatmentPatternsShinyModules.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
---
title: "Using TreatmentPatterns' Shiny Modules"
always_allow_html: yes
output:
html_document:
toc: yes
toc_depth: '3'
df_print: paged
html_vignette:
toc: yes
toc_depth: 3
vignette: >
%\VignetteIndexEntry{UsingTreatmentPatternsShinyModules}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
pdf_document:
toc: yes
---
`TreatmentPatterns` provides several [shiny modules](https://mastering-shiny.org/scaling-modules.html). Shiny modules allow to quickly build a shiny app, based on pre-written code. In `TreatmentPatterns` there are 3 modules availible: **1**) `InputHandler`, **2**) `InteractivePlots`, and **3**) `CharacterizationPlots`. These modules are represented as `R6` classes.
## Generic interface
Each module as 3 methods that represent the main interface on how to utilize them: **1**) `uiBody`, **2**) `uiMenu`, **3**) `server`.
### uiBody
The `uiBody()` method calls for the body of the module, which can be used inside a layout like `fluidPage()` from the `shiny` package or `dashboardPage()` from the `shinydashboard` package.
### uiMenu
The `uiMenu()` method calls for a menu link which points toward the page generated by `uiBody()`. This is typically used with `shinydashboard`'s `dashboardPage()`.
### server
The `server()` method calls the back-end of the module, which handles all the internal computations, data filtering, and file management.
## InputHandler
The `InputHandler` module has some key methods that can be used to setup your TreatmentPatterns shiny application quickly. First we need to create an object of the class `InputHandler` which we do like so:
```{r InputHandler, warning=FALSE, message=FALSE}
library(TreatmentPatterns)
inputHandler <- InputHandler$new("app")
```
Now that our `InputHandler` is initialized and ready to go, we have access to the `uiBody()` and `uiMenu()` methods to build our UI with. In this example the `uiMenu()` is wrapped inside `sidebarMenu()` and `dashboardSidebar()`. The `uiBody()` method is wrapped inside `tabItems()` and `dashboardBody()`.
```{r InputHandler_UI}
library(shiny)
library(shinydashboard)
inputHandler <- InputHandler$new("app")
ui <- dashboardPage(
header = dashboardHeader(title = "myApp"),
sidebar = dashboardSidebar(sidebarMenu(
# InputHandler menu item
inputHandler$uiMenu(),
# Database Selection
inputHandler$uiDatabaseSelector()
)),
body = dashboardBody(tabItems(
# InputHandler body
inputHandler$uiBody()
))
)
```
We also have access to the `setDataPath()` and `server()` methods. The `setDataPath()` method allows us to specify either a path to a zip-file, or pass the input from our server function.
When we set the `path` parameter instead, the input becomes static. Note, that this also renders the `uiBody()` and `uiMenu()` methods redundant.
```{r InputHandler_server_static}
server <- function(input, output, session) {
shiny::moduleServer("app", function(input, output, session) {
# Set static path
inputHandler$setDataPath(path = system.file(package = "TreatmentPatterns", "DummyOutput", "output.zip"))
# Run server back-end
inputHandler$server(input, output, session)
})
}
```
```{r InputHandler_app, eval=FALSE}
shinyApp(ui, server)
```
![](figures/InputHandler.png)
If we pass the input, the user can interactively upload a zip file.
```{r InputHandler_server_interactive}
# Data uploaded by user
server <- function(input, output, session) {
shiny::moduleServer("app", function(input, output, session) {
# Set input, for interactive file upload
inputHandler$setDataPath(input = input)
# InputHandler back-end
inputHandler$server(input, output, session)
})
}
```
## InteractivePlots
Lets first create an `InteractivePlots` module object.
```{r InteractivePlots}
sunburstPlot <- SunburstPlot$new("app")
sankeyDiagram <- SankeyDiagram$new("app")
```
We can now add our UI by calling the `uiMenu()` and `uiBody()` methods.
```{r InteractivePlots_UI}
ui <- dashboardPage(
header = dashboardHeader(title = "myApp"),
sidebar = dashboardSidebar(sidebarMenu(
# InputHandler menu item
inputHandler$uiMenu(),
# InteractivePlots menu item
sunburstPlot$uiMenu(),
sankeyDiagram$uiMenu(),
# Database Selection
inputHandler$uiDatabaseSelector()
)),
body = dashboardBody(tabItems(
# InputHandler body
inputHandler$uiBody(),
# InteractivePlots body
sunburstPlot$uiBody(),
sankeyDiagram$uiBody()
))
)
```
Finally we can add our server back-end to the server function. **Note that the `server()` method for `InteractivePlots` also takes the inputHandler module object as an input.**
```{r InteractivePlots_server}
server <- function(input, output, session) {
shiny::moduleServer("app", function(input, output, session) {
# Set input, for interactive file upload
inputHandler$setDataPath(path = system.file(package = "TreatmentPatterns", "DummyOutput", "output.zip"))
# InputHandler back-end
inputHandler$server(input, output, session)
# InteracitvePlots back-end
sunburstPlot$server(input, output, session, inputHandler)
sankeyDiagram$server(input, output, session, inputHandler)
})
}
```
```{r InteractivePlots_app, eval=FALSE}
shinyApp(ui, server)
```
![](figures/InteractivePlots.png)
## CharacterizationPlots
Lets first create an `CharacterizationPlots` module object.
```{r CharacterizationPlots, eval=FALSE}
characterizationPlots <- CharacterizationPlots$new("app")
```
We can now add our UI by calling the `uiMenu()` and `uiBody()` methods.
```{r CharacterizationPlots_UI, eval=FALSE}
ui <- dashboardPage(
header = dashboardHeader(title = "myApp"),
sidebar = dashboardSidebar(sidebarMenu(
# InputHandler menu item
inputHandler$uiMenu(),
# InteractivePlots menu item
sunburstPlot$uiMenu(),
sankeyDiagram$uiMenu(),
# CharacterizationPlots menu item
characterizationPlots$uiMenu(),
# Database Selection
inputHandler$uiDatabaseSelector()
)),
body = dashboardBody(tabItems(
# InputHandler body
inputHandler$uiBody(),
# InteractivePlots body
sunburstPlot$uiBody(),
sankeyDiagram$uiBody(),
# CharacterizationPlots body
characterizationPlots$uiBody()
))
)
```
Finally we can add our server back-end to the server function. **Note that the `server()` method for `InteractivePlots` also takes the inputHandler module object as an input.**
```{r CharacterizationPlots_server, eval=FALSE}
server <- function(input, output, session) {
shiny::moduleServer("app", function(input, output, session) {
# Set input, for interactive file upload
inputHandler$setDataPath(path = system.file(package = "TreatmentPatterns", "DummyOutput", "output.zip"))
# InputHandler back-end
inputHandler$server(input, output, session)
# InteractivePlots back-end
interactivePlots$server(input, output, session, inputHandler)
# CharacterizationPlots back-end
characterizationPlots$server(input, output, session, inputHandler)
})
}
```
```{r CharacterizationPlots_app, eval=FALSE}
shinyApp(ui, server)
```
![](figures/CharacterizationPlots.png)