Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/DavidPatShuiFong/DTedit
Editable DataTables for shiny apps
https://github.com/DavidPatShuiFong/DTedit
Last synced: 3 months ago
JSON representation
Editable DataTables for shiny apps
- Host: GitHub
- URL: https://github.com/DavidPatShuiFong/DTedit
- Owner: DavidPatShuiFong
- Fork: true (jbryer/DTedit)
- Created: 2019-02-01T07:57:21.000Z (almost 6 years ago)
- Default Branch: master
- Last Pushed: 2022-11-04T13:15:07.000Z (about 2 years ago)
- Last Synced: 2024-05-14T08:32:49.477Z (6 months ago)
- Language: R
- Homepage:
- Size: 5.13 MB
- Stars: 21
- Watchers: 4
- Forks: 11
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- awesome-shiny-extensions - dteditmod - A fork of DTedit with a modular implementation and more [documentation](https://rpubs.com/DavidFong/DTedit). (UI Components / Table)
README
[![Travis build status](https://travis-ci.com/DavidPatShuiFong/DTedit.svg?branch=develop)](https://travis-ci.com/DavidPatShuiFong/DTedit?branch=master)
[![Codecov test coverage](https://codecov.io/gh/DavidPatShuiFong/DTedit/branch/develop/graph/badge.svg)](https://codecov.io/gh/DavidPatShuiFong/DTedit?branch=master)## Editable DataTables for shiny apps.
**Author:** Jason Bryer, Ph.D.
**Email:** [email protected]**Author:** David Fong, FRACGP
**Email:** [email protected]Use the `devtools` package to install the development version of `DTedit`:
```r
devtools::install_github('jbryer/DTedit')
```To install a release branch, e.g. `2.3.0`, of `DavidPatShuiFong/DTedit' :
```r
devtools::install_github('DavidPatShuiFong/[email protected]')
```The `dtedit_demo` will run a sample `shiny` app with to editable data tables.
```r
DTedit::dtedit_demo()
```![DTedit Screen Shot](inst/screens/dtedit_books_edit.png)
#### Getting Started with `DTedit`
You can download a simple shiny app using `DTedit` here: [inst/template/app.R](inst/template/app.R)
There are three steps to using `DTedit` in your shiny application.
1. Define callback function for inserting, updating, and deleting data.
```r
my.insert.callback <- function(data, row) {
# 'data' contains the dataframe *after* the row has been inserted/added
# 'row' is the row number where data has been inserted
mydata <<- rbind(mydata, data[row,])
# in this case, 'mydata' should just be the same as 'data'
return(mydata)
}my.update.callback <- function(data, olddata, row) {
# 'data' contains the dataframe *after* the row has been updated
# 'row' is the row number where data has been updated
# 'olddata' is the previous version of the data
mydata[row,] <<- data[row,]
# in this case, 'mydata' should just be the same as 'data'
return(mydata)
}my.delete.callback <- function(data, row) {
# 'data' contains the dataframe *before* the row has been deleted
# 'row' is the row number where data is to be deleted
mydata <<- mydata[-row,]
# in this case, 'mydata' should just be the same as data[-c(row),]
return(mydata)
}
```Typically these functions would interact with a database. As written here, the data would be lost between shiny sessions.
While `olddata` will contain values as contained in the original `data.frame`,
the values returned in `data` are limited to values that can be returned by the
`shiny` widgets underlying the `input.types`. For example, the `textInput` can
return an empty string, but cannot return `NA`.2. Create the `dtedit` object within your `server` function.
```r
DTedit::dtedit(
input, output,
name = 'mycontacts',
thedata = mydata,
edit.cols = c('name', 'email', 'useR', 'notes'),
edit.label.cols = c('Name', 'Email Address', 'Are they an R user?', 'Additional notes'),
input.types = c(notes='textAreaInput'),
view.cols = c('name', 'email', 'useR'),
callback.update = my.update.callback,
callback.insert = my.insert.callback,
callback.delete = my.delete.callback
)
```The `input` and `output` are passed from the `server` function. The `name` parameter will define the name of the object available to the `uiOutput`. The `thedata` is a `data.frame` for the initial view of the data table. This can be an empty (i.e. no rows) `data.frame`. The structure of the `data.frame` will define the inputs (e.g. `factor`s will be drop down, `Date` will use `dateInput`, `numeric`s will use `numericInput`, etc.). There are many other parameters to custom the behavior of `dtedit`, see `?dtedit` for the full list.
3. Use `uiOutput` in your UI to display the editable data table.
The `name` you will pass to `uiOutput` is the name you passed to the `dtedit` created on the server side.
```r
uiOutput('mycontacts')
```#### `dteditmod` (modularized version of `dtedit`)
You can download a simple modularized shiny app using `DTedit` here: [inst/template/app_mod.R](inst/template/app_mod.R)
There are three steps to using `DTedit` in your modularized shiny application.
1. Define callback functions, as for `dtedit`.
2. `callModule` in the server function, with `dteditmod` as the shiny module server function.
```r
return_values <- callModule(
DTedit::dteditmod,
id = 'mycontacts',
thedata = mydata,
edit.cols = c('name', 'email', 'useR', 'notes'),
edit.label.cols = c('Name', 'Email Address', 'Are they an R user?', 'Additional notes'),
input.types = c(notes='textAreaInput'),
view.cols = c('name', 'email', 'useR'),
callback.update = my.update.callback,
callback.insert = my.insert.callback,
callback.delete = my.delete.callback
)
```The `id` parameter will define the name of the object available to the `dteditmodUI`. `thedata` is a `data.frame` for the initial view of the data table. This can be an empty (i.e. no rows) `data.frame`.
3. Use `DTedit::dteditmodUI` in your UI to display the editable data table.
The `id` you will pass to `dteditmodUI` is the id you passed to the `callModule` created on the server side.
```r
ns <- shiny::NS(id)
...
dteditmodUI(ns('mycontacts'))
```#### Vignette
See vignette with `browseVignettes("DTedit")` or [on RPubs](https://rpubs.com/DavidFong/DTedit).
#### More examples
A very simple example : [inst/examples/example.R](inst/examples/example.R).
This example can be seen with `example("dtedit")`Example with two datatables : [inst/shiny_demo/app.R](inst/shiny_demo/app.R).
This demonstration can be seen with `DTedit::dtedit_demo()`.
This, and other demonstrations, can be called with `shinyAppDir` arguments.
e.g. `DTedit::dtedit_demo(options = list(display.mode = "showcase"))`
Note that *all* `.R` files in the `shiny_demo` directory are displayed in showcase mode, not just the `.R` file used in the actual demonstration!Example with reactive dataframe : [inst/examples/reactivedataframe/app.R](inst/examples/reactivedataframe/app.R).
This demonstration can be seen with `DTedit::dtedit_reactive_demo()`Example with reactive input choices : [inst/examples/selectInputReactive/app.R](inst/examples/selectInputReactive/app.R).
This demonstration can be seen with `DTedit::dtedit_selectInputReactive_demo()`A very simple modularized example : [inst/examples/example_mod.R](inst/examples/example_mod.R).
A slightly modified version of this example can be seen with `DTedit::dtedit_test("simple_modular")`.A modularized example with reactive dataframes : [inst/examples/reactivedataframe_modular/app.R](inst/examples/reactivedataframe_modular/app.R).
This example can be seen with `example("dteditmodUI")`A modularized version with multiple datatables and reactive input choices : [inst/shiny_demo/app_mod.R](inst/shiny_demo/app_mod.R).
This demonstration can be seen with `DTedit::dteditmod_demo()`A modularized version with fileInput, binary blobs and action buttons : [inst/examples/fileinput_modular/app.R](inst/examples/fileinput_modular/app.R).
This demonstration can be seen with `DTedit::dteditmod_fileInput_demo()`