fc_API-REST.R
db97b68e7e43master

fc_API-REST.R
View Options

			# Set of functions common to the entire MINERVE-D3 to interact with the API-REST

			####### API-REST functions

			# - get_metadata_research

			# - download_data_in_slots
			# - download_slot

			# - download_timeseries_from_raster_node
			# - download_timeseries_from_raster_research

			# - download_request
			# - download_request_node
			# - download_request_research

			# - manage_download_raster
			# - download_raster

			# - download_altitude_of_pixel
			# - download_altitude_of_pixel_node
			# - download_altitude_of_pixel_research

			get_metadata_research <- function(config){

			# Function currently only available for API Research

			# get token
			config$INI$API <- "research"
			token <- get_token_server(config)

			header_opts <- paste("--header \"Authorization: Bearer",token,"\"")
			request_txt <- config$INI$get_metadata

			dir.create(config$dir$download_temp, showWarnings = FALSE, recursive = TRUE)

			r <- GET(request_txt, add_headers(Authorization = paste("Bearer",token)))
			suppressMessages(write.csv2(content(r, type="text/csv", encoding = "UTF-8"),file.path(config$dir$download_temp,"metadata.csv"),row.names = FALSE, fileEncoding = "UTF-8", quote=FALSE))
			metadata <- read.csv2(file.path(config$dir$download_temp,'metadata.csv'), header=F,encoding = "UTF-8")
			colnames(metadata) <- c("ID","Name","Type","Temp_res_before","Temp_res_after","Upper_left_X","Upper_left_Y","Width","Height","sp_res_X","sp_res_Y","data_format")

			return(metadata)
			}

			download_data_in_slots <- function(config,token,START_global,END_global,product_j,coords_i,data_type = "timeseries", tz_data) {

			# Snow_Analyzer :
			# product_j <- product[[j]]
			# ou
			# Divers/Raster_Gap_Analyzer :
			# product_j<- config$product_name[i]

			time_res_prod <- config$time_res[config$time_res$prod == as.numeric(product_j),]$time_res

			parallel_comp <- function(config,START_j,END_j,res_local,product_j_local,coords_local,data_type,n_run) {

			# Inspired by https://www.r-bloggers.com/how-to-go-parallel-in-r-basics-tips/

			worker_acquisition <- function(inc) {

			# inc <- 1

			source(file.path(config$dir$D3,"Code/fc_API-REST.R"))
			source(file.path(config$dir$D3,"Code/fc_common.R"))

			download_slot(config,START_j[[inc]],END_j[[inc]],res_local,inc,product_j_local,coords_local,data_type)
			}

			cl <- makeCluster(max(1,detectCores()-config$cores2exclude_acquisition))
			clusterEvalQ(cl,library(lubridate))
			clusterEvalQ(cl,library(curl)) # for data download
			clusterEvalQ(cl,library(httr)) # for data download (get)
			clusterEvalQ(cl,library(rjson)) # for function fromJSON
			clusterExport(cl,c("config","START_j","END_j","res_local","product_j_local","coords_local","data_type"))
			worker_status <- parLapply(cl,1:n_run,worker_acquisition)
			stopCluster(cl)
			}


			product_j_local <<- product_j
			data_type <<- "timeseries"
			coords_local <<- coords_i

			ptm <- proc.time()

			slot_duration <- time_res_prod*config$data_per_slot

			START_j <- list()
			END_j <- list()

			START_j[[1]] <- as.POSIXct(START_global)

			n_run <- 0
			res_local <<- c()

			if (as.POSIXct(START_j[[1]] + slot_duration) < END_global) {

			END_j[[1]] <- as.POSIXct(START_j[[1]] + slot_duration - time_res_prod)

			inc <<- 0


			while (END_j[[inc+1]] + slot_duration < END_global) {

			inc <<- inc + 1

			# if (inc != 1){
			START_j[[inc+1]] <- END_j[[inc]] + time_res_prod
			END_j[[inc+1]] <- START_j[[inc+1]] + slot_duration - time_res_prod
			# }
			}

			n_run <- inc+1
			}


			# Last part

			if (n_run != 0){
			START_j[[n_run+1]] <- END_j[[n_run]] + time_res_prod
			END_j[[n_run+1]] <- END_global
			} else {
			START_j[[1]] <- START_j[[1]]
			END_j[[1]] <- END_global
			}

			n_run <- n_run+1

			# Make START_j, END_j and n_run global
			START_j <<- START_j
			END_j <<- END_j
			n_run <<- n_run

			parallel_comp(config,START_j,END_j,res_local,product_j_local,coords_local,data_type,n_run)

			print_elapsed_time(ptm,paste0("Time for downloading product ",product_j))

			################# Merge all files ###################

			if (data_type == "timeseries"){

			setwd(config$dir$download_temp)

			for (inc in 1 : length(START_j)) {

			tryCatch({

			tmp_file <- paste0(product_j,"-",inc,".csv")

			data <- suppressWarnings(read.csv(tmp_file, header = FALSE, sep=';'))

			# temp
			data[["V1"]] <- as.POSIXct(data[,1], "%Y/%m/%d %H:%M",tz= tz_data)

			if (length(res_local) == 0){
			res_local <- data
			} else {
			res_local <- rbind(res_local,data)
			}

			}, error = function(err) { }

			)

			}

			# Export complete table to CSV
			write.table(res_local, file = paste0(config$dir$download_temp,"/",product_j,".csv"), row.names = FALSE, col.names= FALSE, sep = ";")
			}

			output <- res_local

			suppressWarnings(rm(START_j,END_j,product_j_local,data_type,inc,res_local,n_run,token_local,coords_local))


			return(list(output,token))
			}

			download_slot <- function(config,START_j_inc,END_j_inc,res_local,inc,product_j,coords_i,data_type) {

			# START_j_inc<- START_j[[inc]]
			# END_j_inc<- END_j[[inc]]

			options(scipen=999)

			sink_file <- paste0(config$dir$output,'/logs/log_',coords_i[1],"_",coords_i[2],'.txt')

			dir.create(paste0(config$dir$output,'/logs/'), showWarnings = FALSE, recursive = TRUE)
			sink(file = sink_file, type = "output", append = TRUE)

			tag <- round(runif(1)*10000)

			token <- get_token(config,tag)

			txt2print <- paste0("From ",as.character(as.POSIXct(START_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC"))," to ",as.character(as.POSIXct(END_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC")))

			config_j <- config

			if (hour(START_j_inc) != 0) {
			config_j$compute_time_down <- as.character(as.POSIXct(START_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC"))
			} else {
			config_j$compute_time_down <- paste0(as.character(as.POSIXct(START_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC"))," 00:00:00")
			}

			if (hour(END_j_inc) != 0) {
			config_j$compute_time_up <- as.character(as.POSIXct(END_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC"))
			} else {
			config_j$compute_time_up <- paste0(as.character(as.POSIXct(END_j_inc,format="%Y-%m-%d %H:%M:%S",tz=config$tz_code, origin="1970-01-01 00:00.00 UTC"))," 00:00:00")
			}


			error <- tryCatch({

			if (data_type == "timeseries"){

			if (config$INI$API == "node") {
			res_local_j <- download_timeseries_from_raster_Node(config_j, product_j,token,coords_i,0,paste0(product_j,"-",inc,".csv"),txt2print,tag)
			} else if (config$INI$API == "research") {
			res_local_j <- download_timeseries_from_raster_research(config_j, product_j,token,coords_i,0,paste0(product_j,"-",inc,".csv"),txt2print,tag)
			}

			res_local <- res_local_j[[1]]

			} else if (data_type == "raster") {

			res_local_j <- manage_download_raster('server', 'none', config_j$compute_time_down, config_j$compute_time_up, product_j,token, config)

			if (inc == 0){
			res_local <- raster(res_local_j[[1]])

			} else {
			res_local <- res_local + raster(res_local_j[[1]])
			}

			}

			token <- res_local_j[[2]]

			error <- 0
			},
			error = function(e) {
			error <- 1
			print.noquote(paste0(tag," : Failed dowload (probably empty slot) !"))
			return(error)
			}
			)

			sink()
			return(list(res_local,token))
			}

			download_timeseries_from_raster_Node <- function(config_j,product_j,token,coords_i,time_extension,tmp_file,txt2print,tag){

			# time_extension <- 0
			# tmp_file <- paste0(product_j,"-",inc,".csv")


			# Dates formatting
			Ta_start <- define_computetime(config_j$compute_time_down,0,-time_extension)
			Ta_end <- define_computetime(config_j$compute_time_up,0,time_extension)

			# Coords en dure pour l'instant
			X_val <- coords_i[1]
			Y_val <- coords_i[2]

			# Preparation of the request
			request_txt <- paste0(config_j$INI$timeseriesfromraster)

			DATESTART <- gsub("-","",as.character(as.Date(Ta_start)))
			DATESTART <- paste0(DATESTART,'%20')
			DATEEND <- gsub("-","",as.character(as.Date(Ta_end)))
			DATEEND <- paste0(DATEEND,'%20')
			HOURSTART = paste0(substr(Ta_start,12,13),"%3A00")
			HOUREND = paste0(substr(Ta_end,12,13),"%3A00")

			request_txt <- gsub("DATESTART",DATESTART,request_txt) # DATESTART <- "20170530%20"

			request_txt <- gsub("DATEEND",DATEEND,request_txt) # DATEEND <- "20170531%20"
			request_txt <- gsub("HOURSTART",HOURSTART,request_txt)
			request_txt <- gsub("HOUREND",HOUREND,request_txt)
			request_txt <- gsub("X_val",X_val,request_txt)
			request_txt <- gsub("Y_val",Y_val,request_txt)
			request_txt <- gsub("var_name",product_j,request_txt) # product_j <- "combiprecip_research"

			request_txt_complete <- gsub("token",token,request_txt)

			# Acquisition loop
			token <- download_request(config_j,request_txt,request_txt_complete,token,tmp_file,tag)

			# Convert dates
			data <- suppressWarnings(read.csv(tmp_file, header = FALSE, sep=';'))
			data[["V1"]] <- strptime(data[,1], "%Y/%m/%d %H:%M",tz=config_j$time_zone)

			# Print product used
			print.noquote(paste0(" Used ",product_j," product (",length(data[,1])," values)."))

			# sink()

			return(list(data,token))
			}

			download_timeseries_from_raster_research <- function(config_j,product_j,token,coords_i,time_extension,tmp_file,txt2print,tag){

			# time_extension <- 0
			# tmp_file <- paste0(product_j,"-",inc,".csv")

			# Dates formatting
			Ta_start <- define_computetime(config_j$compute_time_down,0,-time_extension)
			Ta_end <- define_computetime(config_j$compute_time_up,0,time_extension)

			if (!is.null(config_j$product_snow)) { # This case corresponds to the Snow_Analyzer tool
			# Spatial shift according to pixel size
			if (product_j == config_j$product_snow){
			spatial_shift <- (config_j$sp_res_snow/2)
			} else if (product_j == config_j$product_precip){
			spatial_shift <- (min(config_j$sp_res_precip,config_j$sp_res_snow)/2)
			} else if (product_j == config_j$product_temperature){
			spatial_shift <- (min(config_j$sp_res_temp,config_j$sp_res_snow)/2)
			}
			} else {
			spatial_shift <- (config_j$sp_res/2)
			}


			# Coords en dure pour l'instant
			X_val <- coords_i[1]+spatial_shift
			Y_val <- coords_i[2]-spatial_shift

			# Preparation of the request
			request_txt <- paste0(config_j$INI$timeseriesfromraster)

			from <- gsub(" ","T",Ta_start)
			from <- paste0(from,"Z")
			to <- gsub(" ","T",Ta_end)
			to <- paste0(to,"Z")

			request_txt <- gsub("STARTDATE",from,request_txt)
			request_txt <- gsub("ENDDATE",to,request_txt)
			request_txt <- gsub("X_val",X_val,request_txt)
			request_txt <- gsub("Y_val",Y_val,request_txt)
			request_txt <- gsub("productId",product_j,request_txt)
			request_txt_complete <-request_txt # product_j <- "combiprecip_research"

			# Acquisition loop
			token <- download_request(config_j,request_txt,request_txt_complete,token,tmp_file,tag)

			# Convert dates
			data <- suppressWarnings(read.csv(tmp_file, header = FALSE, sep=';'))
			data[["V1"]] <- strptime(data[,1], "%Y/%m/%d %H:%M",tz=config_j$tz_BDDANA)

			# Print product used
			print.noquote(paste0(" ",tag," : Used product ",product_j," (",length(data[,1])," values)."))

			# sink()

			return(list(data,token))
			}

			download_request <- function(config,request_txt,request_txt_complete,token,tmp_file,tag) {

			if (config$INI$API == "node"){
			token <- download_request_node(config,request_txt,request_txt_complete,token,tmp_file,tag)
			} else if (config$INI$API == "research"){
			token <- download_request_research(config,request_txt,token,tmp_file,tag)
			} else {
			print.noquote("Download_request not implemented for this API.")
			}

			return(token)
			}

			download_request_node <- function(config,request_txt,request_txt_complete,token,tmp_file,tag){

			# Initialization
			error <- 0 ; success <- 0
			retry_inc <- 1 ; max_retry <- 60

			while ((error != 0 \| success != 1) & retry_inc<=max_retry){
			# Download data
			error <- tryCatch({
			dir.create(config$dir$temp)
			setwd(config$dir$temp)
			print.noquote(" Attempt to download requested data (NODE) ..")

			time_looping <- 0
			max_time_curl <- 30 # in [s]
			time_inc <- 0.5
			curl_ERR <- c()
			download_finish <- 0
			retry_inc <- retry_inc + 1

			unlink(tmp_file)

			print.noquote(request_txt_complete)

			r <- GET(request_txt_complete, timeout(180))

			print(status_code(r))

			# After maximum time or if succes -> exit process and kill process if still
			if (status_code(r) == 200){

			write.table(content(r, "text"),file.path(tmp_file),row.names=F,col.names=F,quote=F,fileEncoding="UTF-8")
			success <- 1
			error <- 0
			} else if (status_code(r) == 403){
			print.noquote(paste0(" ",tag," : Download failed -> Forbidden !"))
			error <- 1
			} else if (status_code(r) == 500){
			print.noquote(paste0(" ",tag," : Server returned error code 500 !"))
			if (file.exists(tmp_file)) file.remove(tmp_file)
			Sys.sleep(60)
			error <- 1
			} else {
			print.noquote(paste0("Download failed (",status_code(r) ,") -> Curl returned empty response in defined timeout. Process will be killed"))
			Sys.sleep(10)
			if (file.exists(tmp_file)) file.remove(tmp_file) # Delete the file as it is corrupted
			error <- 1
			}
			},
			error = function(e) {
			print.noquote("Failed dowload")
			Sys.sleep(60)
			error <- 1
			return(error)
			}
			)

			# Download new token if required
			tryCatch({
			if (status_code(r) == 403){
			print.noquote("Token seems to be invalid. Routine will try to download new token")
			token <- get_token_server(config)
			request_txt_complete <- gsub("TOKEN",token,request_txt)
			print.noquote("New token download with success")

			} else {
			success <- 1
			}
			})
			}

			if (retry_inc==max_retry+1){
			print.noquote(" Maximum number of retrials reached. Code will be aborted.")
			stop()
			}

			return(token)
			}

			download_request_research <- function(config,request_txt,token,tmp_file,tag=""){

			# For CombiPrecip
			# tmp_file <- file_name
			# tmp_file <- output_file

			# Initialization
			error <- 0 ;
			success <- 0
			retry_inc <- 1 ;
			max_retry <- 300

			while ((error != 0 \| success != 1) & retry_inc<=max_retry){ # (si error == 1 ou success == 0) ET reytry_inc < retry_max

			time_inc <- 1
			ptm <- proc.time()

			# Download data
			error <- tryCatch({
			dir.create(config$dir$download_temp, showWarnings = FALSE, recursive = TRUE)
			setwd(config$dir$download_temp)
			if (retry_inc == 1){
			print.noquote(paste0(" ",tag," : Attempt to download requested data..."))
			print.noquote(paste0(" ",tag," : ", request_txt))
			}
			print.noquote(paste0(" ",tag," : Download iteration = ",retry_inc))

			retry_inc <- retry_inc + 1

			substrRight <- function(x, n){
			substr(x, nchar(x)-n+1, nchar(x))
			}

			if (substrRight(tmp_file, 3)!="tif"){
			r <- GET(request_txt, add_headers(Authorization = paste("Bearer",token)),timeout(180))
			}else{
			r <- GET(request_txt, add_headers(Authorization = paste("Bearer",token)),timeout(180),httr::write_disk(path=tmp_file, overwrite=TRUE))
			}

			duration <- compute_elapsed_time(ptm)

			if (status_code(r) == 200){
			print(paste0("Status code = 200 ; Time = ",duration))

			if (substrRight(tmp_file, 3)!="tif"){
			write.table(suppressMessages(content(r, "text")),file.path(tmp_file),row.names=F,col.names=F,quote=F,fileEncoding="UTF-8")
			}

			success <- 1
			error <- 0
			} else if (status_code(r) == 204){
			print("Status code = 204")
			success <- 1
			error <- 0
			} else if (status_code(r) == 401){
			print("Status code : 401")
			print.noquote(paste0(" ",tag," : Download failed -> Invalid token !"))
			error <- 1
			} else if (status_code(r) == 403){
			print("Status code : 403")
			print.noquote(paste0(" ",tag," : Download failed -> You don't have the rights for this product !"))
			error <- 1
			} else {
			print.noquote(paste0(" ",tag," : Download failed (",status_code(r),")."))
			if (file.exists(tmp_file)){
			# Delete the file as it is corrupted
			file.remove(tmp_file)
			}
			error <- 1
			}
			},
			error = function(e) {

			print.noquote(paste0(" ",tag," : Failed dowload"))
			error <- 1
			return(error)
			}
			)

			tryCatch({
			if (status_code(r) == 401) {
			print.noquote("Token seems to be invalid. Routine will try to download new token")
			token <- get_token_server(config)
			print.noquote("New token download with success")
			}
			})

			}
			if (retry_inc==max_retry+1){
			print.noquote(paste0(" ",tag," : Maximum number of retrials reached. Code will be aborted."))
			stop()
			}
			return(token)
			}

			manage_download_raster <- function(radar_source, ncfile, Ta_start, Ta_end,server_product,token, config){

			# Acquire
			# radar_source <- 'server'
			# ncfile <- 'none'
			# server_product <- "radar"

			#######################
			# Retrial configuration
			n_trial <- 6
			pause_time <- 3 # in seconds

			if (config$debug == 1) {
			radar_source <- config$radar_source
			server_product <- "radar" # radar/combiprecip
			}

			if (radar_source == 'server') {

			print.noquote(paste0(server_product,' read from the server...'))
			prod_list <- eval(parse(text = paste0("config$",server_product)))

			inc <- 1
			success <- 0


			while (inc <= n_trial && success == 0){

			tryCatch({
			res <- download_raster(config, Ta_start,Ta_end, prod_list,token,config$token_file)
			P_Rad <- res[[1]]
			token <- res[[2]]
			raw_raster <- res[[3]]
			success <-1 },
			error = function(e) {
			print.noquote("Something went wront in download_raster function")
			})

			if (success==0 && inc < n_trial ){
			print.noquote("Failed downloading the product. Routine will try again")
			pause_and_print(pause_time)
			token <- get_token_server(config)
			print.noquote("New token download with success")
			} else if (success==0 ) {
			print.noquote("Failed downloading the product after maximum retries. Maybe check the product name.")
			stop()
			}
			inc <- inc+1
			}
			} else if (radar_source == 'local') {

			print.noquote(paste0(server_product,' read from locally...'))

			setwd(paste0(config$dir$data,'/Data'))
			fid<-open.nc(ncfile)
			dat<-read.nc(fid)

			nc_time <- round(as.POSIXct(dat$REFERENCE_TS*86400, origin = "1899-12-30", tz = "UTC"),"hours")
			nc_pos <- which(nc_time == Ta_end)
			dat$y <- dat$y[length(dat$y):1]
			nc_var <- raster(t(dat$AQC[,,nc_pos-1]), xmn=255500, xmx=964500, ymn=-159500, ymx=479500, CRS("+init=epsg:21781"))
			P_Rad <- as(nc_var, 'SpatialGridDataFrame')
			names(P_Rad) <- c("P_rad")

			close.nc(fid)
			}

			else {

			# TODO : créer une erreur
			}

			return(list(P_Rad,token,raw_raster))

			}

			download_raster <- function(config, Ta_start,Ta_end,prod_list,token,token_file){

			# token_file <- config$token_file

			status=1

			tmp <- "Data/Raster/P_rad.tif"

			dir.create(file.path(config$dir$download_temp,"Data","Raster"), showWarnings = FALSE, recursive = TRUE)

			for (l in 1:length(prod_list)){

			if (status==1){
			# l <- 1
			error <- tryCatch({

			print(paste0("Trying to download ",prod_list[l]))

			# Preparation of the request
			request_txt <- config$INI$API_request_raster

			# We are working in UTC
			from <- gsub(" ","T",Ta_start)
			from <- paste0(from,"Z")
			to <- gsub(" ","T",Ta_end)
			to <- paste0(to,"Z")

			request_txt <- gsub("STARTDATE",from,request_txt)
			request_txt <- gsub("ENDDATE",to,request_txt)
			request_txt <- gsub("productId",prod_list[l],request_txt)
			request_txt_complete <-request_txt

			tag = 1000

			# File path definition
			file_name <- gsub(" ","_",Ta_end)
			file_name <- gsub(":00:00","",file_name)
			file_name <- paste0("Data/Raster/",prod_list[[l]],"-",file_name,".tif")

			# Acquisition
			token <- download_request(config,request_txt,request_txt_complete,token,file_name,tag)


			# Read downloaded file
			P_Rad_temp <- raster(file.path(config$dir$download_temp,file_name))

			# If the file P_rad_success.tif does not exist in the workspace, create it
			if (!file.exists(file.path(config$dir$output,'Data','Raster',"P_rad_success.tif"))){
			dir.create(file.path(config$dir$output,'Data','Raster'), showWarnings = FALSE, recursive = TRUE)
			writeRaster(P_Rad_temp, file.path(config$dir$output,'Data','Raster',"P_rad_success.tif"), overwrite = TRUE)
			}

			# Transform into spdf
			P_Rad_sgdf <- P_Rad_temp
			proj4string(P_Rad_sgdf) <- CRS("+init=epsg:2056")
			P_Rad_sgdf <- as(P_Rad_sgdf, 'SpatialGridDataFrame')
			status <- 0

			# Check for negative values in Acquire -> interpolate from nearest value
			if (prod_list[l] == "2"){
			if (length(P_Rad_sgdf@data$P_rad[P_Rad_sgdf@data$P_rad < 0])>0){
			print.noquote(paste0("The downloaded Acquire raster contains ",length(P_Rad_sgdf@data$P_rad[P_Rad_sgdf@data$P_rad < 0]) ," negative values."))
			if (length(P_Rad_sgdf@data$P_rad[P_Rad_sgdf@data$P_rad < 0])<200){
			print.noquote("Routine will interpolate from the nearest radar value.")
			P_Rad_sgdf <- clean_NA_in_raster(P_Rad_sgdf, config)
			} else {
			print.noquote("Too many negative values. No interpolation will be done.")
			error()
			}
			}
			}

			},
			error = function(e) {
			error <- 1
			print.noquote("Failed dowload")
			return(error)
			}
			)
			}
			}
			return(list(P_Rad_sgdf,token,P_Rad_temp))
			}

			download_altitude_of_pixel <- function(config,token,coords_i){

			# From download_csv
			# coords_i <- coords_i

			# From ?
			# coords_i <- coords_list_base[i,]


			if (config$INI$API == "node"){
			download_altitude_output <- download_altitude_of_pixel_node(config,token,coords_i)
			} else if (config$INI$API == "research"){
			download_altitude_output <- download_altitude_of_pixel_research(config,token,coords_i)
			} else {
			print.noquote("Altitude download not implemented for this API.")
			}

			altitude <- download_altitude_output[[1]]
			token <- download_altitude_output[[2]]

			return(list(altitude,token))
			}

			download_altitude_of_pixel_node <- function(config,token,coords_i){

			# Function to extract altitude of a given pixel for a product using the API-node.

			# Config
			setwd(config$dir$download_temp)

			# Preparation of the request
			request_txt <- paste0(config$INI$get_pixel_altitude)

			# Coords en dure pour l'instant
			X_val <- coords_i[1]
			Y_val <- coords_i[2]

			request_txt <- gsub("X_val",X_val,request_txt)
			request_txt <- gsub("Y_val",Y_val,request_txt)
			request_txt <- gsub("var_name",config$product_elevation,request_txt)
			request_txt_complete <- gsub("token",token,request_txt)

			res <- curl_fetch_memory(request_txt_complete)
			curl_code <- res$status_code
			# 200 -> success ; 403 -> invalid token

			# Error : Try to download new token
			if (curl_code==403) {
			print.noquote("Token seems to be invalid. Routine will try to download new token")
			token <- get_token_server(config)
			# setwd(config$dir$data)
			request_txt_complete <- gsub("token",token,request_txt)
			res <- curl_fetch_memory(request_txt_complete)
			curl_code <-res$status_code
			if (curl_code!=403){
			print.noquote("New token download with success")
			} else {
			print.noquote("There seems to be a problem with the connection.")
			stop()
			}
			}

			if (curl_code==200){
			if (length(res$content)>0){

			setwd(config$dir$download_temp)

			# Download data
			curl_download(request_txt_complete,'Data/pixel_elevation.csv')

			# Convert dates
			altitude <- round(suppressWarnings(read.csv('pixel_elevation.csv', header = FALSE, sep=';')),0)
			}
			}

			return(list(altitude,token))
			}

			download_altitude_of_pixel_research <- function(config,token,coords_i){

			# coords_i <- as.numeric(c(X_val,Y_val))
			# coords_i <- coords_list_base[i,]

			# Function to extract altitude of a given pixel for a product using the API-research.

			# Config
			setwd(config$dir$download_temp)

			# Preparation of the request
			request_txt <- paste0(config$INI$get_pixel_altitude)

			if (length(config$sp_res_DEM) ==0) config$sp_res_DEM <- 0
			if (length(config$sp_res_snow) ==0) config$sp_res_snow <- 0
			if (length(config$product_elevation) ==0) config$product_elevation <- 3

			# Coords en dure pour l'instant
			spatial_shift <- (min(config$sp_res_DEM,config$sp_res_snow)/2)
			X_val <- coords_i[1] + spatial_shift
			Y_val <- coords_i[2] - spatial_shift


			request_txt <- gsub("X_val",X_val,request_txt)
			request_txt <- gsub("Y_val",Y_val,request_txt)
			request_txt <- gsub("prod_id",config$product_elevation,request_txt)

			file_path <- 'pixel_elevation.csv'

			token <- download_request_research(config,request_txt,token,file_path)

			altitude <- round(suppressWarnings(read.csv('pixel_elevation.csv', header = FALSE, sep=';')),0)

			return(list(altitude,token))
			}

R10424/Code/fc_API-REST.Rdb97b68e7e43master

fc_API-REST.RView Options

R10424/Code/fc_API-REST.R
db97b68e7e43master

fc_API-REST.R
View Options