2017-11-07 1 views
0

Ich habe eine R-Shiny-App gemacht, die auf einem Linux-Server läuft. Alle Daten, die ich brauche, stammen von einer Website mit API und der Bibliothek (Coinmarketcapr).ReactiveTimer mit if-Anweisung R-Shiny

Die App ruft die neuesten Daten alle 5 Minuten ab und speichert sie in einer CSV-Datei auf dem Server.

Aber jetzt habe ich das Problem, dass jedes Mal, wenn ich die Seite neu lade, die App die neuen Daten abruft und ich immer doppelte Werte in meiner Zeitreihe habe.

Ich arbeite mit dem ReactiveTimer, auf 5 Minuten eingestellt.

Gibt es eine Möglichkeit, dass der ReactiveTimer den Zeitpunkt des letzten Eintrags in der csv-Datei überprüft und mit der aktuellen Systemzeit vergleicht? Wenn die Zeit in der CSV-Datei 5 Minuten oder älter als die Systemzeit sein sollte, sollte er den Code ausführen, sonst nicht.

Ich wollte auch fragen, ob jemand weiß, ob Sie eine glänzende App ausführen können, ohne es im Browser zu öffnen, ich. e. der Code läuft ständig und sammelt Daten?

EDIT:

App auf: http://srv-lab-t-416.zhaw.ch/shiny/Crypto10/

R-Code:

autoInvalidate3 <- reactiveTimer((5*60*1000), session) 

      Crypto10 <- reactive({ 
        Crypto10 <- rep(NA,length(Index.Daten$Date)) 
        z = 0 
        for(i in length(Index.Daten$Date):1){ 
           z = z +1 

           # Price 
           P.i = c(Index.Daten$BTC.Price[i],Index.Daten$BCH.Price[i],Index.Daten$ETH.Price[i],Index.Daten$DASH.Price[i],Index.Daten$MIOTA.Price[i], 
             Index.Daten$LTC.Price[i],Index.Daten$XMR.Price[i],Index.Daten$XEM.Price[i],Index.Daten$NEO.Price[i],Index.Daten$XRP.Price[i]) 

           P.0 = c(Index.Daten$BTC.Price[length(Index.Daten$Date)],Index.Daten$BCH.Price[length(Index.Daten$Date)],Index.Daten$ETH.Price[length(Index.Daten$Date)], 
             Index.Daten$DASH.Price[length(Index.Daten$Date)],Index.Daten$MIOTA.Price[length(Index.Daten$Date)], 
             Index.Daten$LTC.Price[length(Index.Daten$Date)],Index.Daten$XMR.Price[length(Index.Daten$Date)], 
             Index.Daten$XEM.Price[length(Index.Daten$Date)],Index.Daten$NEO.Price[length(Index.Daten$Date)],Index.Daten$XRP.Price[length(Index.Daten$Date)]) 
           # Coins 
           Q.i = c(Index.Daten$BTC.Coins[i],Index.Daten$BCH.Coins[i],Index.Daten$ETH.Coins[i],Index.Daten$DASH.Coins[i],Index.Daten$MIOTA.Coins[i], 
             Index.Daten$LTC.Coins[i],Index.Daten$XMR.Coins[i],Index.Daten$XEM.Coins[i],Index.Daten$NEO.Coins[i],Index.Daten$XRP.Coins[i]) 


           # MK.i = Preis.i * Q.i 
           MK.i = P.i*Q.i 

           # MK.0 = Preis.0 * Q.i 
           MK.0 = P.0*Q.i 

           Crypto10[z] = (sum(MK.i))/((sum(MK.0))/100) 
        } 
        return(Crypto10) 
      }) 

      output$C10 <- renderDygraph({ 
        q <- data.frame(Index.Daten$Date,rev(Crypto10())) 
        dygraph(xts(q[,-1], order.by=q[,1]), xlab = "Time", ylab = "Indexpunkte") %>% dyRangeSelector() 
      }) 

      Crypto10.V3 <- reactive({ 
        autoInvalidate3() 
        if(!file.exists(paste(path,"Index.Daten.V3.csv", sep = ""))){ 

           Index.Daten.V3 = data.frame(Date = NA 
                  ,BTC.Price = NA,BTC.Coins = NA 
                  ,BCH.Price = NA,BCH.Coins = NA 
                  ,ETH.Price = NA,ETH.Coins = NA 
                  ,DASH.Price = NA,DASH.Coins = NA 
                  ,MIOTA.Price = NA,MIOTA.Coins = NA 
                  ,LTC.Price = NA,LTC.Coins = NA 
                  ,XMR.Price = NA,XMR.Coins = NA 
                  ,XEM.Price = NA,XEM.Coins = NA 
                  ,NEO.Price = NA,NEO.Coins = NA 
                  ,XRP.Price = NA,XRP.Coins = NA) 

           Sys.setenv(TZ='CET') 
           Index.Daten.V3$Date = Sys.time() 

           write.csv(Index.Daten.V3,(paste(path,"Index.Daten.V3.csv", sep = ""))) 

        } else{ 

           # Index.Daten.V3 einlesen 
           Index.Daten.V3 = subset(read.csv(paste(path,"Index.Daten.V3.csv", sep = ""),sep = ","),select = -X) 
           Index.Daten.V3$Date = as.POSIXct(Index.Daten.V3$Date) 
        } 

        API.BTC = API.all()[which(API.all()$symbol == "BTC"),] 
        API.BCH = API.all()[which(API.all()$symbol == "BCH"),] 
        API.ETH = API.all()[which(API.all()$symbol == "ETH"),] 
        API.DASH = API.all()[which(API.all()$symbol == "DASH"),] 
        API.MIOTA = API.all()[which(API.all()$symbol == "MIOTA"),] 
        API.LTC = API.all()[which(API.all()$symbol == "LTC"),] 
        API.XMR = API.all()[which(API.all()$symbol == "XMR"),] 
        API.XEM = API.all()[which(API.all()$symbol == "XEM"),] 
        API.NEO = API.all()[which(API.all()$symbol == "NEO"),] 
        API.XRP = API.all()[which(API.all()$symbol == "XRP"),] 

        if(is.na(Index.Daten.V3$BTC.Price[length(Index.Daten.V3$BTC.Price)])){ 

           p = length(Index.Daten.V3$Date) 

           Index.Daten.V3[p,2:21] = c(
             as.numeric(API.BTC$price_usd),as.numeric(API.BTC$available_supply), 
             as.numeric(API.BCH$price_usd),as.numeric(API.BCH$available_supply), 
             as.numeric(API.ETH$price_usd),as.numeric(API.ETH$available_supply), 
             as.numeric(API.DASH$price_usd),as.numeric(API.DASH$available_supply), 
             as.numeric(API.MIOTA$price_usd),as.numeric(API.MIOTA$available_supply), 
             as.numeric(API.LTC$price_usd),as.numeric(API.LTC$available_supply), 
             as.numeric(API.XMR$price_usd),as.numeric(API.XMR$available_supply), 
             as.numeric(API.XEM$price_usd),as.numeric(API.XEM$available_supply), 
             as.numeric(API.NEO$price_usd),as.numeric(API.NEO$available_supply), 
             as.numeric(API.XRP$price_usd),as.numeric(API.XRP$available_supply) 
          ) 

           # Index.Daten.V3 als CSV speichern 
           write.csv(Index.Daten.V3,(paste(path,"Index.Daten.V3.csv", sep = ""))) 

        }else{ 

           p = length(Index.Daten.V3$Date)+1 

           Index.Daten.V3[p,2:21] = c(
             as.numeric(API.BTC$price_usd),as.numeric(API.BTC$available_supply), 
             as.numeric(API.BCH$price_usd),as.numeric(API.BCH$available_supply), 
             as.numeric(API.ETH$price_usd),as.numeric(API.ETH$available_supply), 
             as.numeric(API.DASH$price_usd),as.numeric(API.DASH$available_supply), 
             as.numeric(API.MIOTA$price_usd),as.numeric(API.MIOTA$available_supply), 
             as.numeric(API.LTC$price_usd),as.numeric(API.LTC$available_supply), 
             as.numeric(API.XMR$price_usd),as.numeric(API.XMR$available_supply), 
             as.numeric(API.XEM$price_usd),as.numeric(API.XEM$available_supply), 
             as.numeric(API.NEO$price_usd),as.numeric(API.NEO$available_supply), 
             as.numeric(API.XRP$price_usd),as.numeric(API.XRP$available_supply)) 

           Sys.setenv(TZ='CET') 
           Index.Daten.V3$Date[p] = Sys.time() 

           # Index.Daten.V3 als CSV speichern 
           write.csv(Index.Daten.V3,(paste(path,"Index.Daten.V3.csv", sep = ""))) 
        } 
+0

Könnten Sie bitte einen reproduzierbaren Beispielcode teilen? – amrrs

+2

Idealerweise möchten Sie einen separaten R-Job, der über crontab ausgeführt wird, etwa: https://stackoverflow.com/questions/12014837/how-to-run-an-r-script-in-contab –

Antwort

0

Ich löste das Problem, indem sie cronR verwenden. Alle Berechnungen und API-Funktionen wurden nun in einer separaten Datei erstellt und die glänzende App sammelt nur die Daten und zeigt sie an.

Jetzt muss ich den ReactiveTimer nicht mehr verwenden.

Verwandte Themen