R/DataApi.r
In OpenSILEX/opensilexClientToolsR: R Package Client for OpenSilex API
# OpenSilex API
#
# No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
#
# OpenAPI spec version: 1.0.0-rc+2
#
# Generated by: https://github.com/swagger-api/swagger-codegen.git
#' @title Data operations
#' @description opensilexClientToolsR.Data
#'
#' @field path Stores url path of the request.
#' @field apiClient Handles the client-server communication.
#' @field userAgent Set the user agent of the request.
#'
#' @importFrom R6 R6Class
#'
#' @section Methods:
#' \describe{
#'
#' add_list_data Add data
#'
#'
#' count_data Count data
#'
#'
#' create_provenance Add a provenance
#'
#'
#' delete_data Delete data
#'
#'
#' delete_data_on_search Delete data on criteria
#'
#'
#' delete_provenance Delete a provenance that doesn't describe data
#'
#'
#' export_data Export data
#'
#'
#' get_data Get data
#'
#'
#' get_data_file Get a data file
#'
#'
#' get_data_file_description Get a data file description
#'
#'
#' get_data_file_descriptions_by_search Search data files
#'
#'
#' get_datafiles_provenances Get provenances linked to datafiles
#'
#'
#' get_pictures_thumbnails Get a picture thumbnail
#'
#'
#' get_provenance Get a provenance
#'
#'
#' get_provenances_by_ur_is Get a list of provenances by their URIs
#'
#'
#' get_used_provenances Get provenances linked to data
#'
#'
#' get_used_variables Get variables linked to data
#'
#'
#' import_csv_data Import a CSV file for the given provenanceURI
#'
#'
#' post_data_file Add a data file
#'
#'
#' post_data_file_paths Describe datafiles and give their relative paths in the configured storage system. In the case of already stored datafiles.
#'
#'
#' search_data_list Search data
#'
#'
#' search_provenance Get provenances
#'
#'
#' update Update data
#'
#'
#' update_confidence Update confidence index
#'
#'
#' update_provenance Update a provenance
#'
#'
#' validate_csv Import a CSV file for the given provenanceURI.
#'
#' }
#'
#' @export
DataApi <- R6::R6Class(
'DataApi',
public = list(
userAgent = "Swagger-Codegen/1.0.0/r",
apiClient = NULL,
initialize = function(apiClient){
if (!missing(apiClient)) {
self$apiClient <- apiClient
}
else {
self$apiClient <- ApiClient$new()
}
},
add_list_data = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
count_data = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
urlPath <- "/core/data/count"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- Integer$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
create_provenance = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_data = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/data/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_data_on_search = function(experiment,target,variable,provenance,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiment`)) {
queryParams['experiment'] <- experiment
}
if (!missing(`target`)) {
queryParams['target'] <- target
}
if (!missing(`variable`)) {
queryParams['variable'] <- variable
}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_provenance = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/provenances/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
export_data = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,mode,with_raw_data,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`mode`)) {
queryParams['mode'] <- mode
}
if (!missing(`with_raw_data`)) {
queryParams['with_raw_data'] <- with_raw_data
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/data/export"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/data/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/datafiles/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file_description = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/datafiles/{uri}/description"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataFileGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file_descriptions_by_search = function(rdf_type,start_date,end_date,timezone,experiments,targets,devices,provenances,metadata,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`rdf_type`)) {
queryParams['rdf_type'] <- rdf_type
}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/datafiles"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataFileGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_datafiles_provenances = function(experiments,targets,devices,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
urlPath <- "/core/datafiles/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_pictures_thumbnails = function(uri,scaled_width,scaled_height,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`scaled_width`)) {
queryParams['scaled_width'] <- scaled_width
}
if (!missing(`scaled_height`)) {
queryParams['scaled_height'] <- scaled_height
}
urlPath <- "/core/datafiles/{uri}/thumbnail"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_provenance = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/provenances/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_provenances_by_ur_is = function(uris,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`uris`)) {
queryParams['uris'] <- uris
}
urlPath <- "/core/provenances/by_uris"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_used_provenances = function(experiments,targets,variables,devices,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
urlPath <- "/core/data/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_used_variables = function(experiments,targets,provenances,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
urlPath <- "/core/data/variables"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
import_csv_data = function(provenance,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
body <- list(
"file" = httr::upload_file(file)
)
urlPath <- "/core/data/import"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataCSVValidationDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
post_data_file = function(description,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
body <- list(
"description" = description,
"file" = httr::upload_file(file)
)
urlPath <- "/core/datafiles"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
post_data_file_paths = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/datafiles/description"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
search_data_list = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
search_provenance = function(name,description,activity,activity_type,agent,agent_type,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`name`)) {
queryParams['name'] <- name
}
if (!missing(`description`)) {
queryParams['description'] <- description
}
if (!missing(`activity`)) {
queryParams['activity'] <- activity
}
if (!missing(`activity_type`)) {
queryParams['activity_type'] <- activity_type
}
if (!missing(`agent`)) {
queryParams['agent'] <- agent
}
if (!missing(`agent_type`)) {
queryParams['agent_type'] <- agent_type
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update_confidence = function(uri,body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data/{uri}/confidence"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update_provenance = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
validate_csv = function(provenance,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
body <- list(
"file" = httr::upload_file(file)
)
urlPath <- "/core/data/import_validation"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataCSVValidationDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
}
)
)
OpenSILEX/opensilexClientToolsR documentation built on Jan. 28, 2022, 5:03 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
# OpenSilex API
#
# No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
#
# OpenAPI spec version: 1.0.0-rc+2
#
# Generated by: https://github.com/swagger-api/swagger-codegen.git
#' @title Data operations
#' @description opensilexClientToolsR.Data
#'
#' @field path Stores url path of the request.
#' @field apiClient Handles the client-server communication.
#' @field userAgent Set the user agent of the request.
#'
#' @importFrom R6 R6Class
#'
#' @section Methods:
#' \describe{
#'
#' add_list_data Add data
#'
#'
#' count_data Count data
#'
#'
#' create_provenance Add a provenance
#'
#'
#' delete_data Delete data
#'
#'
#' delete_data_on_search Delete data on criteria
#'
#'
#' delete_provenance Delete a provenance that doesn't describe data
#'
#'
#' export_data Export data
#'
#'
#' get_data Get data
#'
#'
#' get_data_file Get a data file
#'
#'
#' get_data_file_description Get a data file description
#'
#'
#' get_data_file_descriptions_by_search Search data files
#'
#'
#' get_datafiles_provenances Get provenances linked to datafiles
#'
#'
#' get_pictures_thumbnails Get a picture thumbnail
#'
#'
#' get_provenance Get a provenance
#'
#'
#' get_provenances_by_ur_is Get a list of provenances by their URIs
#'
#'
#' get_used_provenances Get provenances linked to data
#'
#'
#' get_used_variables Get variables linked to data
#'
#'
#' import_csv_data Import a CSV file for the given provenanceURI
#'
#'
#' post_data_file Add a data file
#'
#'
#' post_data_file_paths Describe datafiles and give their relative paths in the configured storage system. In the case of already stored datafiles.
#'
#'
#' search_data_list Search data
#'
#'
#' search_provenance Get provenances
#'
#'
#' update Update data
#'
#'
#' update_confidence Update confidence index
#'
#'
#' update_provenance Update a provenance
#'
#'
#' validate_csv Import a CSV file for the given provenanceURI.
#'
#' }
#'
#' @export
DataApi <- R6::R6Class(
'DataApi',
public = list(
userAgent = "Swagger-Codegen/1.0.0/r",
apiClient = NULL,
initialize = function(apiClient){
if (!missing(apiClient)) {
self$apiClient <- apiClient
}
else {
self$apiClient <- ApiClient$new()
}
},
add_list_data = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
count_data = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
urlPath <- "/core/data/count"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- Integer$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
create_provenance = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_data = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/data/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_data_on_search = function(experiment,target,variable,provenance,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiment`)) {
queryParams['experiment'] <- experiment
}
if (!missing(`target`)) {
queryParams['target'] <- target
}
if (!missing(`variable`)) {
queryParams['variable'] <- variable
}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
delete_provenance = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/provenances/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "DELETE",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "DELETE"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
export_data = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,mode,with_raw_data,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`mode`)) {
queryParams['mode'] <- mode
}
if (!missing(`with_raw_data`)) {
queryParams['with_raw_data'] <- with_raw_data
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/data/export"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/data/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/datafiles/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file_description = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/datafiles/{uri}/description"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataFileGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_data_file_descriptions_by_search = function(rdf_type,start_date,end_date,timezone,experiments,targets,devices,provenances,metadata,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`rdf_type`)) {
queryParams['rdf_type'] <- rdf_type
}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/datafiles"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataFileGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_datafiles_provenances = function(experiments,targets,devices,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
urlPath <- "/core/datafiles/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_pictures_thumbnails = function(uri,scaled_width,scaled_height,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`scaled_width`)) {
queryParams['scaled_width'] <- scaled_width
}
if (!missing(`scaled_height`)) {
queryParams['scaled_height'] <- scaled_height
}
urlPath <- "/core/datafiles/{uri}/thumbnail"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
# void response, no need to return anything
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_provenance = function(uri,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
urlPath <- "/core/provenances/{uri}"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_provenances_by_ur_is = function(uris,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`uris`)) {
queryParams['uris'] <- uris
}
urlPath <- "/core/provenances/by_uris"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_used_provenances = function(experiments,targets,variables,devices,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
urlPath <- "/core/data/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
get_used_variables = function(experiments,targets,provenances,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
urlPath <- "/core/data/variables"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
import_csv_data = function(provenance,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
body <- list(
"file" = httr::upload_file(file)
)
urlPath <- "/core/data/import"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataCSVValidationDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
post_data_file = function(description,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
body <- list(
"description" = description,
"file" = httr::upload_file(file)
)
urlPath <- "/core/datafiles"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
post_data_file_paths = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/datafiles/description"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
search_data_list = function(start_date,end_date,timezone,experiments,targets,variables,devices,min_confidence,max_confidence,provenances,metadata,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`start_date`)) {
queryParams['start_date'] <- start_date
}
if (!missing(`end_date`)) {
queryParams['end_date'] <- end_date
}
if (!missing(`timezone`)) {
queryParams['timezone'] <- timezone
}
if (!missing(`experiments`)) {
queryParams['experiments'] <- experiments
}
if (!missing(`targets`)) {
queryParams['targets'] <- targets
}
if (!missing(`variables`)) {
queryParams['variables'] <- variables
}
if (!missing(`devices`)) {
queryParams['devices'] <- devices
}
if (!missing(`min_confidence`)) {
queryParams['min_confidence'] <- min_confidence
}
if (!missing(`max_confidence`)) {
queryParams['max_confidence'] <- max_confidence
}
if (!missing(`provenances`)) {
queryParams['provenances'] <- provenances
}
if (!missing(`metadata`)) {
queryParams['metadata'] <- metadata
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
search_provenance = function(name,description,activity,activity_type,agent,agent_type,order_by,page,page_size,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`name`)) {
queryParams['name'] <- name
}
if (!missing(`description`)) {
queryParams['description'] <- description
}
if (!missing(`activity`)) {
queryParams['activity'] <- activity
}
if (!missing(`activity_type`)) {
queryParams['activity_type'] <- activity_type
}
if (!missing(`agent`)) {
queryParams['agent'] <- agent
}
if (!missing(`agent_type`)) {
queryParams['agent_type'] <- agent_type
}
if (!missing(`order_by`)) {
queryParams['order_by'] <- order_by
}
if (!missing(`page`)) {
queryParams['page'] <- page
}
if (!missing(`page_size`)) {
queryParams['page_size'] <- page_size
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "GET",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "GET"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ProvenanceGetDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update_confidence = function(uri,body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/data/{uri}/confidence"
if (!missing(`uri`)) {
urlPath <- gsub(paste0("\\{", "uri", "\\}"), `uri`, urlPath)
}
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
update_provenance = function(body,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`body`)) {
if(is.list(`body`)){
bodyList <- lapply(`body`, function(x){x$toJSONString()})
bodyListPaste <- paste(bodyList, collapse=', ' )
body <- paste('[',bodyListPaste,']')
}else{
body <- paste(`body`$toJSONString())
}
} else {
body <- NULL
}
urlPath <- "/core/provenances"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "PUT",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "PUT"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- ObjectUriResponse$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
},
validate_csv = function(provenance,file,...){
args <- list(...)
queryParams <- list()
headerParams <- character()
self$apiClient$basePath = sub("/$", "",get("BASE_PATH",opensilexWSClientR:::configWS))
if(self$apiClient$basePath == ""){
stop("Wrong you must first connect with connectToOpenSILEX")
}
#if (!missing(`authorization`)) {
# headerParams['Authorization'] <- authorization
#}
#if (!missing(`accept_language`)) {
# headerParams['Accept-Language'] <- accept_language
#}
if (!missing(`provenance`)) {
queryParams['provenance'] <- provenance
}
body <- list(
"file" = httr::upload_file(file)
)
urlPath <- "/core/data/import_validation"
resp <- self$apiClient$callApi(url = paste0(self$apiClient$basePath, urlPath),
method = "POST",
queryParams = queryParams,
headerParams = headerParams,
body = body,
...)
method = "POST"
if (httr::status_code(resp) >= 200 && httr::status_code(resp) <= 299) {
if(method == "GET"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
data <- json$result
returnedOjects = list()
for(i in 1:nrow(data)){
row <- data[i,]
returnObject <- DataCSVValidationDTO$new()
returnObject$fromJSONObject(row)
returnedOjects = c(returnedOjects,returnObject)
}
return(Response$new(json$metadata,returnedOjects, resp, TRUE))
}
if(method == "POST" || method == "PUT"){
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json$metadata$datafiles, resp, TRUE))
}
} else if (httr::status_code(resp) >= 400 && httr::status_code(resp) <= 499) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
} else if (httr::status_code(resp) >= 500 && httr::status_code(resp) <= 599) {
json <- jsonlite::fromJSON(httr::content(resp, "text", encoding = "UTF-8"))
return(Response$new(json$metadata, json, resp, FALSE))
}
}
)
)
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.