API tools faq
paste
SemlerPDX

AVCS SENS OWM MAIN-v5 Inline Function in C# for VoiceAttack & Open Weather API

SemlerPDX
Jun 14th, 2022
1,282
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 39.88 KB | None | 0 0
raw download clone embed print report
  1. //AVCS SENS - Open Weather Maps Monitor Main Timer
  2. // by SemlerPDX Mar2022 (see credits in menu)
  3. // VETERANS-GAMING.COM
  4.  
  5.  
  6. using System;
  7. using System.Diagnostics;
  8. using System.Collections.Generic;
  9. using System.Net;
  10.  
  11.  
  12. public class VAInline
  13. {
  14.     string timerInterval = "";
  15.     int GetWeatherTimerDelay = 5000;  // default timer delay 5 seconds
  16.     int GetWeatherInterval = 180;  // default multiple of delay (180xDelay=15 minutes)
  17.     bool debugging = false;
  18.     bool debuggingFC = false;
  19.    
  20.     public void ClearWeatherVariables()
  21.     {
  22.         //Clear Weather TTS Variables
  23.         VA.SetText("AVCS_SENS_TempOWMu", null);
  24.         VA.SetText("AVCS_SENS_TempOWMwiu", null);
  25.         VA.SetText("AVCS_SENS_TempOWMwid", null);
  26.         VA.SetText("AVCS_SENS_TempOWMloc", null);
  27.         VA.SetText("AVCS_SENS_TempOWMmain", null);
  28.         VA.SetText("AVCS_SENS_TempOWMfull", null);
  29.         VA.SetDecimal("AVCS_SENS_TempOWMc", null);
  30.         VA.SetDecimal("AVCS_SENS_TempOWMf", null);
  31.         VA.SetDecimal("AVCS_SENS_TempOWMhic", null);
  32.         VA.SetDecimal("AVCS_SENS_TempOWMhif", null);
  33.         VA.SetDecimal("AVCS_SENS_TempOWMh", null);
  34.         VA.SetDecimal("AVCS_SENS_TempOWMwim", null);
  35.         VA.SetDecimal("AVCS_SENS_TempOWMwik", null);
  36.     }
  37.    
  38.     private void GetWeatherTimerElapsed(object sender, System.Timers.ElapsedEventArgs e)
  39.     {
  40.         int intervalOWM = 0;
  41.         if (VA.GetInt("AVCS_SENS_OWM_INTERVAL") != null)
  42.         {
  43.             intervalOWM = Convert.ToInt32(VA.GetInt("AVCS_SENS_OWM_INTERVAL"));
  44.             intervalOWM += 1;
  45.             if (intervalOWM >= GetWeatherInterval)
  46.                 intervalOWM = 0;
  47.             VA.SetInt("AVCS_SENS_OWM_INTERVAL", intervalOWM);
  48.         }
  49.         else
  50.         {
  51.             VA.SetInt("AVCS_SENS_OWM_INTERVAL", 0);
  52.         }
  53.        
  54.         if (VA.GetBoolean("AVCS_OWM_Debugging") != true)
  55.         {
  56.             debugging = false;
  57.         }
  58.         else
  59.         {
  60.             debugging = true;
  61.             if (canShowInterval(intervalOWM))
  62.                 VA.WriteToLog(showNextInterval(intervalOWM, GetWeatherInterval, GetWeatherTimerDelay), "blank");
  63.         }
  64.        
  65.         if (intervalOWM == 0)
  66.         {
  67.             if (debugging)
  68.                 VA.WriteToLog("AVCS OWM Monitor is getting New Weather Data now...", "green");
  69.            
  70.             try
  71.             {
  72.                
  73.                 if (canGetWeatherData())
  74.                 {
  75.                     VA.SetBoolean("AVCS_OWM_SET", null);
  76.                     GetWeatherData(VA);
  77.                 }
  78.                 if (VA.GetBoolean("AVCS_OWM_SET") != true)
  79.                 {
  80.                     VA.SetBoolean("AVCS_OWM_Monitoring", false);
  81.                 }
  82.                 else
  83.                 {
  84.                     if (canGetDailyForecast())
  85.                     {
  86.                         GetWeatherDailyForecastData(VA);
  87.                     }
  88.                 }
  89.             }
  90.             catch
  91.             {
  92.                 //for any expected unexpected faults
  93.                 VA.SetBoolean("AVCS_OWM_Monitoring", false);
  94.             }
  95.         }
  96.        
  97.         if (VA.GetBoolean("AVCS_OWM_Monitoring") != true)
  98.         {
  99.             ClearWeatherVariables();
  100.             VA.WriteToLog("AVCS Open Weather Map Timer has been terminated...", "black");
  101.             if ((VA.GetBoolean("AVCS_SENS_UnloadClose") != true) && (VA.GetBoolean("AVCS_OWM_Checking") != true))
  102.             {
  103.                 VA.SetText("AVCS_SENS_TTS_WILDCARD", "Weather Data [Monitoring;;] Systems have been [terminated;disabled;ended]");
  104.                 VA.Command.Execute("F_SAY_TTS", true);
  105.             }
  106.             VA.SetBoolean("AVCS_OWM_Checking", null);
  107.             (sender as System.Timers.Timer).Stop();
  108.         }
  109.        
  110.         if (VA.Stopped)
  111.         {
  112.             // Catch Here if anything could be interrupted by VA Stop (long running TTS?)
  113.             if (debugging)
  114.                 VA.WriteToLog("AVCS OWM Monitor Timer saw and ignored Stop Commands", "yellow");
  115.         }
  116.     }
  117.    
  118.    
  119.     private void GetWeatherTimer(string timerInterval)
  120.     {
  121.         System.Timers.Timer t = new System.Timers.Timer(GetWeatherTimerDelay);
  122.         t.Elapsed += GetWeatherTimerElapsed;
  123.         VA.WriteToLog("AVCS Open Weather Map Timer is now running...", "black");
  124.         VA.WriteToLog("Current Weather Update Interval: " + timerInterval, "black");
  125.         t.Start();
  126.     }
  127.    
  128.    
  129.     public class AVCSexception : Exception
  130.     {
  131.         public void GetWeatherURLException(dynamic VA)
  132.         {
  133.             VA.SetBoolean("AVCS_OWM_SET", null);
  134.             VA.WriteToLog("AVCS OWM Get Weather Data has failed!", "red");
  135.             VA.WriteToLog("Please check settings. See user guide for more information.", "blank");
  136.         }
  137.         public void GetWeatherFailException(dynamic VA)
  138.         {
  139.             VA.WriteToLog("AVCS OWM Get Weather Data has failed!", "red");
  140.             VA.WriteToLog("Please check settings. See user guide for more information.", "blank");
  141.             VA.SetText("AVCS_SENS_TTS_WILDCARD", "Weather data unavailable. Please check settings.");
  142.             VA.Command.Execute("F_SAY_TTS", false);
  143.             VA.SetBoolean("AVCS_OWM_Monitoring", false);
  144.         }
  145.     }
  146.    
  147.     private void GetWeatherData(dynamic VA)
  148.     {
  149.         string cityName;
  150.         string stateName;
  151.         string newLat = "";
  152.         string newLon = "";
  153.         string locationData = "New York, NY, US";
  154.         string apiKey = "";
  155.         string baseURL = "https://api.openweathermap.org/data/2.5/weather?lat=AVCS_SENS_OWMLAT&lon=AVCS_SENS_OWMLON&units=metric&exclude=minutely,hourly&appid=AVCS_SENS_OWMKEY";
  156.         string weatherURL = "";
  157.         bool hasGPS = false;
  158.         bool faultDetected = false;
  159.        
  160.        
  161.         if (VA.GetText("AVCS_SENS_OWMKEY") != null)
  162.         {
  163.             apiKey = VA.GetText("AVCS_SENS_OWMKEY");
  164.         }
  165.         else
  166.         {
  167.             apiKey = VA.GetText("AVCS_SENS_OWM_DefaultKey");
  168.         }
  169.         if (VA.GetText("AVCS_SENS_OWMCITY") != null)
  170.             locationData = VA.GetText("AVCS_SENS_OWMCITY");
  171.         if (VA.GetText("AVCS_SENS_OWMLAT") != null && VA.GetText("AVCS_SENS_OWMLON") != null)
  172.             weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",VA.GetText("AVCS_SENS_OWMLAT")).Replace("AVCS_SENS_OWMLON",VA.GetText("AVCS_SENS_OWMLON")).Replace("AVCS_SENS_OWMKEY",apiKey).Trim();
  173.         if (weatherURL == "")
  174.         {
  175.             if (locationData.Contains(","))
  176.             {
  177.                 string[] locationDataSet = locationData.Split(
  178.                     new string[] { "," },
  179.                     StringSplitOptions.RemoveEmptyEntries
  180.                 );
  181.                 if (1 < locationDataSet.Length)
  182.                 {
  183.                     decimal checkLat;
  184.                     decimal checkLon;
  185.                     bool checkLatIsValid = decimal.TryParse(locationDataSet[0], out checkLat) && Math.Abs(checkLat) < 90;
  186.                     bool checkLonIsValid = decimal.TryParse(locationDataSet[1], out checkLon) && Math.Abs(checkLon) < 180;
  187.                     if ((checkLatIsValid && checkLonIsValid) && (Math.Abs(checkLat) > 4.4m && Math.Abs(checkLon) > 4.4m))
  188.                     {
  189.                         hasGPS = true;
  190.                         newLat = locationDataSet[0].Trim();
  191.                         newLon = locationDataSet[1].Trim();
  192.                         VA.SetText("AVCS_SENS_OWMLAT", newLat);
  193.                         VA.SetText("AVCS_SENS_OWMLON", newLon);
  194.                         weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",newLat).Replace("AVCS_SENS_OWMLON",newLon).Replace("AVCS_SENS_OWMKEY",apiKey).Trim();
  195.                     }
  196.                 }
  197.             }
  198.             if (hasGPS != true)
  199.             {
  200.                 try
  201.                 {
  202.                     string apiReturn = "";
  203.                     VA.SetText("~avcs_owm_return", null);
  204.                     weatherURL = "http://api.openweathermap.org/geo/1.0/direct?q="+locationData+"&limit=1&appid="+apiKey;
  205.                    
  206.                     GetWeatherApiReturn(weatherURL, VA);
  207.                    
  208.                     if (VA.GetText("~avcs_owm_return") != null)
  209.                         apiReturn = VA.GetText("~avcs_owm_return").Replace("\"","").Replace("{","").Replace("}","");
  210.                    
  211.                     if (apiReturn.Contains(","))
  212.                     {
  213.                         string[] lines = apiReturn.Split(
  214.                             new string[] { "," },
  215.                             StringSplitOptions.RemoveEmptyEntries
  216.                         );
  217.                        
  218.                         foreach (string line in lines)
  219.                         {
  220.                             if (line.Contains("lat"))
  221.                             {
  222.                                 if (line.Contains(":"))
  223.                                 {
  224.                                     string[] checkLine = line.Split(
  225.                                         new string[] { ":" },
  226.                                         StringSplitOptions.RemoveEmptyEntries
  227.                                     );
  228.                                     if(1 < checkLine.Length)
  229.                                         newLat = checkLine[1];
  230.                                 }
  231.                             }
  232.                             if (line.Contains("lon"))
  233.                             {
  234.                                 if (line.Contains(":"))
  235.                                 {
  236.                                     string[] checkLine = line.Split(
  237.                                         new string[] { ":" },
  238.                                         StringSplitOptions.RemoveEmptyEntries
  239.                                     );
  240.                                     if(1 < checkLine.Length)
  241.                                         newLon = checkLine[1];
  242.                                 }
  243.                             }
  244.                         }
  245.                         decimal tryNewDecimal;
  246.                         if ((newLat != "" && Decimal.TryParse(newLat, out tryNewDecimal)) && (newLon != "" && Decimal.TryParse(newLat, out tryNewDecimal)))
  247.                         {
  248.                             VA.SetText("AVCS_SENS_OWMLAT", newLat);
  249.                             VA.SetText("AVCS_SENS_OWMLON", newLon);
  250.                             weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",newLat).Replace("AVCS_SENS_OWMLON",newLon).Replace("AVCS_SENS_OWMKEY",apiKey);
  251.                         }
  252.                         else
  253.                         {
  254.                             throw new AVCSexception();
  255.                         }
  256.                     }
  257.                     else
  258.                     {
  259.                         throw new AVCSexception();
  260.                     }
  261.                 }
  262.                 catch (AVCSexception e)
  263.                 {
  264.                     //for any expected unexpected faults
  265.                     faultDetected = true;
  266.                     e.GetWeatherURLException(VA);
  267.                 }
  268.             }
  269.         }
  270.         if (faultDetected != true)
  271.         {
  272.             string apiLoc = "";
  273.             string apiMain = "";
  274.             string apiTempC = "";
  275.             string apiTempF = "";
  276.             string apiHeatIndexC = "";
  277.             string apiHeatIndexF = "";
  278.             string apiWindSpeedK = "";
  279.             string apiWindSpeedM = "";
  280.             string apiHumidity = "";
  281.             string apiWindDir = "";
  282.             string apiTempUnits = "°C";
  283.             string apiWindUnits = "kph";
  284.             string apiWindFrom = "North";
  285.             string ttsTemp = "";
  286.             string ttsIndex = "";
  287.             string ttsWind = "";
  288.            
  289.             try
  290.             {
  291.                 string apiReturn = "";
  292.                 VA.SetText("~avcs_owm_return", null);
  293.                 GetWeatherApiReturn(weatherURL, VA);
  294.                 if (VA.GetText("~avcs_owm_return") != null)
  295.                     apiReturn = VA.GetText("~avcs_owm_return").Replace("\"","").Replace("{","").Replace("}","");
  296.                
  297.                 if (apiReturn.Contains(","))
  298.                 {
  299.                     string[] lines = apiReturn.Split(
  300.                         new string[] { "," },
  301.                         StringSplitOptions.RemoveEmptyEntries
  302.                     );
  303.                     foreach (string line in lines)
  304.                     {
  305.                         if (line.Contains("name") && apiLoc == "")
  306.                         {
  307.                             if (line.Contains(":"))
  308.                             {
  309.                                 string[] checkLine = line.Split(
  310.                                     new string[] { ":" },
  311.                                     StringSplitOptions.RemoveEmptyEntries
  312.                                 );
  313.                                 if(1 < line.Length)
  314.                                     apiLoc = checkLine[1];
  315.                             }
  316.                         }
  317.                         if (line.Contains("description") && apiMain == "")
  318.                         {
  319.                             if (line.Contains(":"))
  320.                             {
  321.                                 string[] checkLine = line.Split(
  322.                                     new string[] { ":" },
  323.                                     StringSplitOptions.RemoveEmptyEntries
  324.                                 );
  325.                                 if (1 < line.Length)
  326.                                 {
  327.                                     apiMain = checkLine[1].Trim().ToLower();
  328.                                 }
  329.                                
  330.                                 if (apiMain.StartsWith("few"))
  331.                                 {
  332.                                     apiMain = apiMain.Replace("few","a few");
  333.                                 }
  334.                                 else if (apiMain == "clouds" )
  335.                                 {
  336.                                     apiMain = apiMain.Replace("clouds","cloudy");
  337.                                 }
  338.                                 else if (apiMain == "sun" )
  339.                                 {
  340.                                     apiMain = apiMain.Replace("sun","sunny");
  341.                                 }
  342.                                 else if ((apiMain == "rain" ) || (apiMain == "mist" ))
  343.                                 {
  344.                                     apiMain = apiMain + "y";
  345.                                 }
  346.                                 apiMain = apiMain.Replace("sky","skies");
  347.                             }
  348.                         }
  349.                         if (line.Contains("temp") && apiTempC == "")
  350.                         {
  351.                             if (line.Contains(":"))
  352.                             {
  353.                                 string[] checkLine = line.Split(
  354.                                     new string[] { ":" },
  355.                                     StringSplitOptions.RemoveEmptyEntries
  356.                                 );
  357.                                 if(1 < line.Length)
  358.                                 {
  359.                                     decimal convertTemp = 1;
  360.                                     decimal convertedTemp = 1;
  361.                                     apiTempC = checkLine[2];
  362.                                     if (Decimal.TryParse(apiTempC, out convertTemp))
  363.                                     {
  364.                                         convertedTemp = ((convertTemp * 9) / 5) + 32;
  365.                                         convertedTemp = Math.Round(convertedTemp, 0);
  366.                                         VA.SetDecimal("AVCS_SENS_TempOWMf", convertedTemp);
  367.                                         apiTempF = convertedTemp.ToString();
  368.                                     }
  369.                                     if (Decimal.TryParse(apiTempC, out convertTemp))
  370.                                     {
  371.                                         convertedTemp = Math.Round(convertedTemp, 0);
  372.                                         VA.SetDecimal("AVCS_SENS_TempOWMc", convertedTemp);
  373.                                         apiTempC = convertedTemp.ToString();
  374.                                     }
  375.                                     if (VA.GetBoolean("AVCS_SENS_OWM_UnitMetric") != true)
  376.                                     {
  377.                                         ttsTemp = apiTempF;
  378.                                         apiTempUnits = "°F";
  379.                                     }
  380.                                     else
  381.                                     {
  382.                                         ttsTemp = apiTempC;
  383.                                         apiTempUnits = "°C";
  384.                                     }
  385.                                 }
  386.                             }
  387.                         }
  388.                         if (line.Contains("feels_like") && apiHeatIndexC == "")
  389.                         {
  390.                             if (line.Contains(":"))
  391.                             {
  392.                                 string[] checkLine = line.Split(
  393.                                     new string[] { ":" },
  394.                                     StringSplitOptions.RemoveEmptyEntries
  395.                                 );
  396.                                 if(1 < line.Length)
  397.                                 {
  398.                                     decimal convertIndex = 1;
  399.                                     decimal convertedIndex = 1;
  400.                                     apiHeatIndexC = checkLine[1];
  401.                                    
  402.                                     if (Decimal.TryParse(apiHeatIndexC, out convertIndex))
  403.                                     {
  404.                                         convertedIndex = ((convertIndex * 9) / 5) + 32;
  405.                                         convertedIndex = Math.Round(convertedIndex, 0);
  406.                                         VA.SetDecimal("AVCS_SENS_TempOWMhif", convertedIndex);
  407.                                         apiHeatIndexF = convertedIndex.ToString();
  408.                                         ttsIndex = apiHeatIndexF;
  409.                                     }
  410.                                     if (Decimal.TryParse(apiHeatIndexC, out convertIndex))
  411.                                     {
  412.                                         convertedIndex = Math.Round(convertedIndex, 0);
  413.                                         VA.SetDecimal("AVCS_SENS_TempOWMhic", convertedIndex);
  414.                                         apiHeatIndexC = convertedIndex.ToString();
  415.                                         ttsIndex = apiHeatIndexC;
  416.                                     }
  417.                                 }
  418.                             }
  419.                         }
  420.                         if (line.Contains("humidity") && apiHumidity == "")
  421.                         {
  422.                             if (line.Contains(":"))
  423.                             {
  424.                                 string[] checkLine = line.Split(
  425.                                     new string[] { ":" },
  426.                                     StringSplitOptions.RemoveEmptyEntries
  427.                                 );
  428.                                 if(1 < line.Length)
  429.                                 {
  430.                                     decimal convertedRH;
  431.                                     apiHumidity = checkLine[1];
  432.                                     if (Decimal.TryParse(apiHumidity, out convertedRH))
  433.                                     {
  434.                                         convertedRH = Math.Round(convertedRH, 0);
  435.                                         VA.SetDecimal("AVCS_SENS_TempOWMh", convertedRH);
  436.                                         apiHumidity = convertedRH.ToString();
  437.                                     }
  438.                                 }
  439.                             }
  440.                         }
  441.                         if (line.Contains("speed") && apiWindSpeedK == "")
  442.                         {
  443.                             if (line.Contains(":"))
  444.                             {
  445.                                 string[] checkLine = line.Split(
  446.                                     new string[] { ":" },
  447.                                     StringSplitOptions.RemoveEmptyEntries
  448.                                 );
  449.                                 if(1 < line.Length)
  450.                                 {
  451.                                     decimal convertedSpeed;
  452.                                     apiWindSpeedK = checkLine[2];
  453.                                     if (VA.GetBoolean("AVCS_SENS_OWM_WindMetric") != true)
  454.                                     {
  455.                                         if (Decimal.TryParse(apiWindSpeedK, out convertedSpeed))
  456.                                         {
  457.                                             convertedSpeed *= 0.6214m;
  458.                                             convertedSpeed = Math.Round(convertedSpeed, 0);
  459.                                             VA.SetDecimal("AVCS_SENS_TempOWMwim", convertedSpeed);
  460.                                             apiWindSpeedM = convertedSpeed.ToString();
  461.                                             ttsWind = apiWindSpeedM;
  462.                                             apiWindUnits = "mph";
  463.                                         }
  464.                                     }
  465.                                     else
  466.                                     {
  467.                                         if (Decimal.TryParse(apiWindSpeedK, out convertedSpeed))
  468.                                         {
  469.                                             convertedSpeed = Math.Round(convertedSpeed, 0);
  470.                                             VA.SetDecimal("AVCS_SENS_TempOWMwik", convertedSpeed);
  471.                                             apiWindSpeedK = convertedSpeed.ToString();
  472.                                             ttsWind = apiWindSpeedK;
  473.                                             apiWindUnits = "kph";
  474.                                         }
  475.                                     }
  476.                                 }
  477.                             }
  478.                         }
  479.                         if (line.Contains("deg") && apiWindDir == "")
  480.                         {
  481.                             if (line.Contains(":"))
  482.                             {
  483.                                 string[] checkLine = line.Split(
  484.                                     new string[] { ":" },
  485.                                     StringSplitOptions.RemoveEmptyEntries
  486.                                 );
  487.                                 if(1 < line.Length)
  488.                                 {
  489.                                     apiWindDir = checkLine[1];
  490.                                     decimal convertedDir = 1;
  491.                                    
  492.                                     if (Decimal.TryParse(apiWindDir, out convertedDir))
  493.                                     {
  494.                                         if ((convertedDir > 337.5m && convertedDir <= 359m) || (convertedDir >= 0m && convertedDir < 22.5m))
  495.                                         {
  496.                                             apiWindFrom = "North";
  497.                                         }
  498.                                         else if (convertedDir >= 22.5m && convertedDir < 67.5m)
  499.                                         {
  500.                                             apiWindFrom = "Northeast";
  501.                                         }
  502.                                         else if (convertedDir >= 67.5m && convertedDir <= 112.5m)
  503.                                         {
  504.                                             apiWindFrom = "East";
  505.                                         }
  506.                                         else if (convertedDir > 112.5m && convertedDir <= 157.5m)
  507.                                         {
  508.                                             apiWindFrom = "Southeast";
  509.                                         }
  510.                                         else if (convertedDir > 157.5m && convertedDir <= 202.5m)
  511.                                         {
  512.                                             apiWindFrom = "South";
  513.                                         }
  514.                                         else if (convertedDir > 202.5m && convertedDir <= 247.5m)
  515.                                         {
  516.                                             apiWindFrom = "Southwest";
  517.                                         }
  518.                                         else if (convertedDir > 247.5m && convertedDir <= 292.5m)
  519.                                         {
  520.                                             apiWindFrom = "West";
  521.                                         }
  522.                                         else if (convertedDir > 292.5m && convertedDir <= 337.5m)
  523.                                         {
  524.                                             apiWindFrom = "Northwest";
  525.                                         }
  526.                                     }
  527.                                 }
  528.                             }
  529.                         }
  530.                     }
  531.                    
  532.                     //Store New Temperature Units Text for TTS Requests
  533.                     VA.SetText("AVCS_SENS_TempOWMu", apiTempUnits);
  534.                    
  535.                     //Store New Wind Units Text for TTS Requests
  536.                     VA.SetText("AVCS_SENS_TempOWMwiu", apiWindUnits);
  537.                     VA.SetText("AVCS_SENS_TempOWMwid", apiWindFrom);
  538.                    
  539.                     //Store New Weather Conditions and City Name Values for TTS Requests
  540.                     VA.SetText("AVCS_SENS_TempOWMloc", apiLoc);
  541.                     VA.SetText("AVCS_SENS_TempOWMmain", apiMain);
  542.                    
  543.                     //Store New Main Conditions Value for TTS Requests
  544.                     VA.SetText("AVCS_SENS_TempOWMfull", "Conditions are " + apiMain + " right now at around " + ttsTemp + apiTempUnits + ", with a heat index of " + ttsIndex + apiTempUnits + " and humidity at " + apiHumidity + "%. Winds are out of the " + apiWindFrom + " at " + ttsWind + apiWindUnits);
  545.                    
  546.                     //Store current time plus seconds of interval for next check
  547.                     string nextCheckUnixSecsString = "UNIX";
  548.                     decimal setNextCheckUnixSecs = 0;
  549.                     if (VA.GetInt("AVCS_SENS_OWM_WG_Calls") != null && (Decimal.TryParse(VA.ParseTokens("{INT:AVCS_SENS_OWM_WG_Calls:900}"), out setNextCheckUnixSecs)))
  550.                     {
  551.                         setNextCheckUnixSecs += DateTimeOffset.Now.ToUnixTimeSeconds();
  552.                     }
  553.                     else
  554.                     {
  555.                         VA.SetInt("AVCS_SENS_OWM_WG_Calls", 900);
  556.                         setNextCheckUnixSecs = 900m + DateTimeOffset.Now.ToUnixTimeSeconds();
  557.                     }
  558.                     nextCheckUnixSecsString += setNextCheckUnixSecs.ToString();
  559.                     VA.SetText("AVCS_SENS_OWM_NextWeatherGetCheck", nextCheckUnixSecsString);
  560.                    
  561.                     VA.SetBoolean("AVCS_OWM_SET", true);
  562.                     if (debugging)
  563.                         VA.WriteToLog(VA.GetText("AVCS_SENS_TempOWMfull"), "green");
  564.                 }
  565.                 else
  566.                 {
  567.                     throw new AVCSexception();
  568.                 }
  569.             }
  570.             catch (AVCSexception e)
  571.             {
  572.                 //for any expected unexpected faults
  573.                 e.GetWeatherURLException(VA);
  574.             }
  575.         }
  576.     }
  577.    
  578.     private void GetWeatherDailyForecastData(dynamic VA)
  579.     {
  580.         string cityName;
  581.         string stateName;
  582.         string newLat = "";
  583.         string newLon = "";
  584.         string locationData = "New York, NY, US";
  585.         string apiKey = "";
  586.         string baseURL = "https://api.openweathermap.org/data/2.5/onecall?lat=AVCS_SENS_OWMLAT&lon=AVCS_SENS_OWMLON&exclude=current,minutely,hourly,alerts&appid=AVCS_SENS_OWMKEY&units=metric";
  587.  
  588.         string weatherURL = "";
  589.         bool hasGPS = false;
  590.         bool faultDetected = false;
  591.        
  592.        
  593.         if (VA.GetText("AVCS_SENS_OWMKEY") != null)
  594.         {
  595.             apiKey = VA.GetText("AVCS_SENS_OWMKEY");
  596.         }
  597.         else
  598.         {
  599.             apiKey = VA.GetText("AVCS_SENS_OWM_DefaultKey");
  600.         }
  601.         if (VA.GetText("AVCS_SENS_OWMCITY") != null)
  602.             locationData = VA.GetText("AVCS_SENS_OWMCITY");
  603.         if (VA.GetText("AVCS_SENS_OWMLAT") != null && VA.GetText("AVCS_SENS_OWMLON") != null)
  604.             weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",VA.GetText("AVCS_SENS_OWMLAT")).Replace("AVCS_SENS_OWMLON",VA.GetText("AVCS_SENS_OWMLON")).Replace("AVCS_SENS_OWMKEY",apiKey).Trim();
  605.         if (weatherURL == "")
  606.         {
  607.             if (locationData.Contains(","))
  608.             {
  609.                 string[] locationDataSet = locationData.Split(
  610.                     new string[] { "," },
  611.                     StringSplitOptions.RemoveEmptyEntries
  612.                 );
  613.                 if (1 < locationDataSet.Length)
  614.                 {
  615.                     decimal checkLat;
  616.                     decimal checkLon;
  617.                     bool checkLatIsValid = decimal.TryParse(locationDataSet[0], out checkLat) && Math.Abs(checkLat) < 90;
  618.                     bool checkLonIsValid = decimal.TryParse(locationDataSet[1], out checkLon) && Math.Abs(checkLon) < 180;
  619.                     if ((checkLatIsValid && checkLonIsValid) && (Math.Abs(checkLat) > 4.4m && Math.Abs(checkLon) > 4.4m))
  620.                     {
  621.                         hasGPS = true;
  622.                         newLat = locationDataSet[0].Trim();
  623.                         newLon = locationDataSet[1].Trim();
  624.                         VA.SetText("AVCS_SENS_OWMLAT", newLat);
  625.                         VA.SetText("AVCS_SENS_OWMLON", newLon);
  626.                         weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",newLat).Replace("AVCS_SENS_OWMLON",newLon).Replace("AVCS_SENS_OWMKEY",apiKey).Trim();
  627.                     }
  628.                 }
  629.             }
  630.             if (hasGPS != true)
  631.             {
  632.                 try
  633.                 {
  634.                     string apiReturn = "";
  635.                     VA.SetText("~avcs_owm_return", null);
  636.                     weatherURL = "http://api.openweathermap.org/geo/1.0/direct?q="+locationData+"&limit=1&appid="+apiKey;
  637.                    
  638.                     GetWeatherApiReturn(weatherURL, VA);
  639.                    
  640.                     if (VA.GetText("~avcs_owm_return") != null)
  641.                         apiReturn = VA.GetText("~avcs_owm_return").Replace("\"","").Replace("{","").Replace("}","");
  642.                    
  643.                     if (apiReturn.Contains(","))
  644.                     {
  645.                         string[] lines = apiReturn.Split(
  646.                             new string[] { "," },
  647.                             StringSplitOptions.RemoveEmptyEntries
  648.                         );
  649.                        
  650.                         foreach (string line in lines)
  651.                         {
  652.                             if (line.Contains("lat"))
  653.                             {
  654.                                 if (line.Contains(":"))
  655.                                 {
  656.                                     string[] checkLine = line.Split(
  657.                                         new string[] { ":" },
  658.                                         StringSplitOptions.RemoveEmptyEntries
  659.                                     );
  660.                                     if(1 < checkLine.Length)
  661.                                         newLat = checkLine[1];
  662.                                 }
  663.                             }
  664.                             if (line.Contains("lon"))
  665.                             {
  666.                                 if (line.Contains(":"))
  667.                                 {
  668.                                     string[] checkLine = line.Split(
  669.                                         new string[] { ":" },
  670.                                         StringSplitOptions.RemoveEmptyEntries
  671.                                     );
  672.                                     if(1 < checkLine.Length)
  673.                                         newLon = checkLine[1];
  674.                                 }
  675.                             }
  676.                         }
  677.                         decimal tryNewDecimal;
  678.                         if ((newLat != "" && Decimal.TryParse(newLat, out tryNewDecimal)) && (newLon != "" && Decimal.TryParse(newLat, out tryNewDecimal)))
  679.                         {
  680.                             VA.SetText("AVCS_SENS_OWMLAT", newLat);
  681.                             VA.SetText("AVCS_SENS_OWMLON", newLon);
  682.                             weatherURL = baseURL.Replace("AVCS_SENS_OWMLAT",newLat).Replace("AVCS_SENS_OWMLON",newLon).Replace("AVCS_SENS_OWMKEY",apiKey);
  683.                         }
  684.                         else
  685.                         {
  686.                             throw new AVCSexception();
  687.                         }
  688.                     }
  689.                     else
  690.                     {
  691.                         throw new AVCSexception();
  692.                     }
  693.                 }
  694.                 catch (AVCSexception e)
  695.                 {
  696.                     //for any expected unexpected faults
  697.                     faultDetected = true;
  698.                     e.GetWeatherURLException(VA);
  699.                 }
  700.             }
  701.         }
  702.         if (faultDetected != true)
  703.         {
  704.             string apiLoc = "";
  705.             string apiMain = "";
  706.             string apiTempMinC = "";
  707.             string apiTempMinF = "";
  708.             string apiTempMaxC = "";
  709.             string apiTempMaxF = "";
  710.             string apiWindSpeedK = "";
  711.             string apiWindSpeedM = "";
  712.             string apiHumidity = "";
  713.             string apiWindDir = "";
  714.             string apiTempUnits = "°C";
  715.             string apiWindUnits = "kph";
  716.             string apiWindFrom = "North";
  717.             string ttsTempMin = "";
  718.             string ttsTempMax = "";
  719.             string ttsWind = "";
  720.            
  721.             int dayCounter = -1;
  722.             string dayCurrent = "";
  723.            
  724.             decimal convertTempMin = 1;
  725.             decimal convertedTempMin = 1;
  726.             decimal convertTempMax = 1;
  727.             decimal convertedTempMax = 1;
  728.            
  729.             bool nextCheckSet = false;
  730.             //===================== GET FORECAST===================
  731.            
  732.            
  733.             try
  734.             {
  735.                 string apiReturn = "";
  736.                 VA.SetText("~avcs_owm_return", null);
  737.                 GetWeatherApiReturn(weatherURL, VA);
  738.                 if (VA.GetText("~avcs_owm_return") != null)
  739.                     apiReturn = VA.GetText("~avcs_owm_return").Replace("\"","").Replace("{","").Replace("}","").Replace("uvi",";,uvi");
  740.                
  741.                 if (apiReturn.Contains(";"))
  742.                 {
  743.                     string[] daysForecasted = apiReturn.Split(
  744.                         new string[] { ";" },
  745.                         StringSplitOptions.RemoveEmptyEntries
  746.                     );
  747.                     //Get Days of Week array
  748.                     List<string> newDaysOfWeek = (new List<string> {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}).GetRange((int)DateTime.Now.DayOfWeek, 8);
  749.                     dayCounter = -1;
  750.                     dayCurrent = "";
  751.                     VA.SetText("AVCS_SENS_OWM_FORECASTS", "");
  752.                     foreach (string dayForcasted in daysForecasted)
  753.                     {
  754.                         apiLoc = "";
  755.                         apiMain = "";
  756.                         apiTempMinC = "";
  757.                         apiTempMinF = "";
  758.                         apiTempMaxC = "";
  759.                         apiTempMaxF = "";
  760.                         apiWindSpeedK = "";
  761.                         apiWindSpeedM = "";
  762.                         apiHumidity = "";
  763.                         apiWindDir = "";
  764.                         dayCounter++;
  765.                         if (dayCounter >= 8)
  766.                             break;
  767.                        
  768.                         dayCurrent = newDaysOfWeek[dayCounter];
  769.                         if (dayCounter == 0)
  770.                             dayCurrent = "Today";
  771.                        
  772.                         if (dayForcasted.Contains(","))
  773.                         {
  774.                             string[] lines = dayForcasted.Split(
  775.                                 new string[] { "," },
  776.                                 StringSplitOptions.RemoveEmptyEntries
  777.                             );
  778.                             foreach (string line in lines)
  779.                             {
  780.                                
  781.                                 // Check and save the second forecast day 'dt' Unix Time (seconds) as time of next daily forecast check
  782.                                 if (nextCheckSet != true && line.Contains("dt") && dayCounter == 1)
  783.                                 {
  784.                                     if (line.Contains(":"))
  785.                                     {
  786.                                         string[] checkLine = line.Split(
  787.                                             new string[] { ":" },
  788.                                             StringSplitOptions.RemoveEmptyEntries
  789.                                         );
  790.                                         if(1 < line.Length)
  791.                                         {
  792.                                             string nextUnixSecsString = "UNIX";
  793.                                             decimal setNextUnixSecs = 0;
  794.                                             if (VA.GetInt("AVCS_SENS_OWM_FC_Calls") != null && (Decimal.TryParse(VA.ParseTokens("{INT:AVCS_SENS_OWM_FC_Calls:86400}"), out setNextUnixSecs)))
  795.                                             {
  796.                                                 setNextUnixSecs += DateTimeOffset.Now.ToUnixTimeSeconds();
  797.                                             }
  798.                                             else
  799.                                             {
  800.                                                 setNextUnixSecs = 86400m + DateTimeOffset.Now.ToUnixTimeSeconds();
  801.                                             }
  802.                                             nextUnixSecsString += setNextUnixSecs.ToString();
  803.                                             VA.SetText("AVCS_SENS_OWM_NextDailyForecastCheck", nextUnixSecsString);
  804.                                             VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_OWM_NextDailyForecastCheck=" + nextUnixSecsString + Environment.NewLine);
  805.                                             nextCheckSet = true;
  806.                                         }
  807.                                     }
  808.                                 }
  809.                                
  810.                                
  811.                                 if (line.Contains("description") && apiMain == "")
  812.                                 {
  813.                                     if (line.Contains(":"))
  814.                                     {
  815.                                         string[] checkLine = line.Split(
  816.                                             new string[] { ":" },
  817.                                             StringSplitOptions.RemoveEmptyEntries
  818.                                         );
  819.                                         if (1 < line.Length)
  820.                                         {
  821.                                             apiMain = checkLine[1].Trim().ToLower();
  822.                                         }
  823.                                        
  824.                                         if (apiMain.StartsWith("few"))
  825.                                         {
  826.                                             apiMain = apiMain.Replace("few", "a few");
  827.                                         }
  828.                                         else if (apiMain == "clouds" )
  829.                                         {
  830.                                             apiMain = apiMain.Replace("clouds", "cloudy");
  831.                                         }
  832.                                         else if (apiMain == "sun" )
  833.                                         {
  834.                                             apiMain+="ny";
  835.                                         }
  836.                                         else if ((apiMain == "rain" ) || (apiMain == "mist" ))
  837.                                         {
  838.                                             apiMain+="y";
  839.                                         }
  840.                                         apiMain = apiMain.Replace("sky", "skies");
  841.                                         VA.SetText("AVCS_SENS_TempOWMmain_" + dayCurrent, apiMain);
  842.                                         VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMmain_" + dayCurrent + "=" + apiMain + Environment.NewLine);
  843.                                     }
  844.                                 }
  845.                                
  846.                                 //Min Temp for this day (in C and F)
  847.                                 if (line.Contains("min") && apiTempMinC == "")
  848.                                 {
  849.                                     if (line.Contains(":"))
  850.                                     {
  851.                                         string[] checkLine = line.Split(
  852.                                             new string[] { ":" },
  853.                                             StringSplitOptions.RemoveEmptyEntries
  854.                                         );
  855.                                         if(1 < line.Length)
  856.                                         {
  857.                                             convertTempMin = 1;
  858.                                             convertedTempMin = 1;
  859.                                             apiTempMinC = checkLine[1];
  860.                                             if (Decimal.TryParse(apiTempMinC, out convertTempMin))
  861.                                             {
  862.                                                 convertedTempMin = ((convertTempMin * 9) / 5) + 32;
  863.                                                 convertedTempMin = Math.Round(convertedTempMin, 0);
  864.                                                 VA.SetInt("AVCS_SENS_TempOWMf_Min_" + dayCurrent, Convert.ToInt32(convertedTempMin));
  865.                                                 apiTempMinF = convertedTempMin.ToString();
  866.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMf_Min_" + dayCurrent + "=" + apiTempMinF + Environment.NewLine);
  867.                                             }
  868.                                             if (Decimal.TryParse(apiTempMinC, out convertTempMin))
  869.                                             {
  870.                                                 convertedTempMin = Math.Round(convertedTempMin, 0);
  871.                                                 VA.SetInt("AVCS_SENS_TempOWMc_Min_" + dayCurrent, Convert.ToInt32(convertedTempMin));
  872.                                                 apiTempMinC = convertedTempMin.ToString();
  873.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMf_Min_" + dayCurrent + "=" + apiTempMinC + Environment.NewLine);
  874.                                             }
  875.                                             if (VA.GetBoolean("AVCS_SENS_OWM_UnitMetric") != true)
  876.                                             {
  877.                                                 ttsTempMin = apiTempMinF;
  878.                                             }
  879.                                             else
  880.                                             {
  881.                                                 ttsTempMin = apiTempMinC;
  882.                                             }
  883.                                         }
  884.                                     }
  885.                                 }
  886.                                
  887.                                 //Max Temp for this day (in C and F)
  888.                                 if (line.Contains("max") && apiTempMaxC == "")
  889.                                 {
  890.                                     if (line.Contains(":"))
  891.                                     {
  892.                                         string[] checkLine = line.Split(
  893.                                             new string[] { ":" },
  894.                                             StringSplitOptions.RemoveEmptyEntries
  895.                                         );
  896.                                         if(1 < line.Length)
  897.                                         {
  898.                                             convertTempMax = 1;
  899.                                             convertedTempMax = 1;
  900.                                             apiTempMaxC = checkLine[1];
  901.                                             if (Decimal.TryParse(apiTempMaxC, out convertTempMax))
  902.                                             {
  903.                                                 convertedTempMax = ((convertTempMax * 9) / 5) + 32;
  904.                                                 convertedTempMax = Math.Round(convertedTempMax, 0);
  905.                                                 VA.SetInt("AVCS_SENS_TempOWMf_Max_" + dayCurrent, Convert.ToInt32(convertedTempMax));
  906.                                                 apiTempMaxF = convertedTempMax.ToString();
  907.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMf_Max_" + dayCurrent + "=" + apiTempMaxF + Environment.NewLine);
  908.                                             }
  909.                                             if (Decimal.TryParse(apiTempMaxC, out convertTempMax))
  910.                                             {
  911.                                                 convertedTempMax = Math.Round(convertedTempMax, 0);
  912.                                                 VA.SetInt("AVCS_SENS_TempOWMc_Max_" + dayCurrent, Convert.ToInt32(convertedTempMax));
  913.                                                 apiTempMaxC = convertedTempMax.ToString();
  914.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMc_Max_" + dayCurrent + "=" + apiTempMaxC + Environment.NewLine);
  915.                                             }
  916.                                             if (VA.GetBoolean("AVCS_SENS_OWM_UnitMetric") != true)
  917.                                             {
  918.                                                 ttsTempMax = apiTempMaxF;
  919.                                             }
  920.                                             else
  921.                                             {
  922.                                                 ttsTempMax = apiTempMaxC;
  923.                                             }
  924.                                         }
  925.                                     }
  926.                                 }
  927.                                
  928.                                
  929.                                
  930.                                 // Humidity for this days forecast
  931.                                 if (line.Contains("humidity") && apiHumidity == "")
  932.                                 {
  933.                                     if (line.Contains(":"))
  934.                                     {
  935.                                         string[] checkLine = line.Split(
  936.                                             new string[] { ":" },
  937.                                             StringSplitOptions.RemoveEmptyEntries
  938.                                         );
  939.                                         if(1 < line.Length)
  940.                                         {
  941.                                             decimal convertedRH;
  942.                                             apiHumidity = checkLine[1];
  943.                                             if (Decimal.TryParse(apiHumidity, out convertedRH))
  944.                                             {
  945.                                                 convertedRH = Math.Round(convertedRH, 0);
  946.                                                 VA.SetInt("AVCS_SENS_TempOWMh_" + dayCurrent, Convert.ToInt32(convertedRH));
  947.                                                 apiHumidity = convertedRH.ToString();
  948.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMh_" + dayCurrent + "=" + apiHumidity + Environment.NewLine);
  949.                                             }
  950.                                         }
  951.                                     }
  952.                                 }
  953.                                
  954.                                 // Avg. Wind Speed for this days forecast
  955.                                 if (line.Contains("speed") && apiWindSpeedK == "")
  956.                                 {
  957.                                     if (line.Contains(":"))
  958.                                     {
  959.                                         string[] checkLine = line.Split(
  960.                                             new string[] { ":" },
  961.                                             StringSplitOptions.RemoveEmptyEntries
  962.                                         );
  963.                                         if(1 < line.Length)
  964.                                         {
  965.                                             decimal convertedSpeed;
  966.                                             apiWindSpeedK = checkLine[1];
  967.                                             if (Decimal.TryParse(apiWindSpeedK, out convertedSpeed))
  968.                                             {
  969.                                                 convertedSpeed *= 0.6214m;
  970.                                                 convertedSpeed = Math.Round(convertedSpeed, 0);
  971.                                                 VA.SetInt("AVCS_SENS_TempOWMwim_" + dayCurrent, Convert.ToInt32(convertedSpeed));
  972.                                                 apiWindSpeedM = convertedSpeed.ToString();
  973.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMwim_" + dayCurrent + "=" + apiWindSpeedM + Environment.NewLine);
  974.                                             }
  975.                                             if (Decimal.TryParse(apiWindSpeedK, out convertedSpeed))
  976.                                             {
  977.                                                 convertedSpeed = Math.Round(convertedSpeed, 0);
  978.                                                 VA.SetInt("AVCS_SENS_TempOWMwik_" + dayCurrent, Convert.ToInt32(convertedSpeed));
  979.                                                 apiWindSpeedK = convertedSpeed.ToString();
  980.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMwik_" + dayCurrent + "=" + apiWindSpeedK + Environment.NewLine);
  981.                                             }
  982.                                             if (VA.GetBoolean("AVCS_SENS_OWM_WindMetric") != true)
  983.                                             {
  984.                                                 ttsWind = apiWindSpeedM;
  985.                                             }
  986.                                             else
  987.                                             {
  988.                                                 ttsWind = apiWindSpeedK;
  989.                                             }
  990.                                         }
  991.                                     }
  992.                                 }
  993.                                
  994.                                 // Avg. expected Wind Direct for this days forecast
  995.                                 if (line.Contains("deg") && apiWindDir == "")
  996.                                 {
  997.                                     if (line.Contains(":"))
  998.                                     {
  999.                                         string[] checkLine = line.Split(
  1000.                                             new string[] { ":" },
  1001.                                             StringSplitOptions.RemoveEmptyEntries
  1002.                                         );
  1003.                                         if(1 < line.Length)
  1004.                                         {
  1005.                                             apiWindDir = checkLine[1];
  1006.                                             decimal convertedDir = 1;
  1007.                                            
  1008.                                             if (Decimal.TryParse(apiWindDir, out convertedDir))
  1009.                                             {
  1010.                                                 if ((convertedDir > 337.5m && convertedDir <= 359m) || (convertedDir >= 0m && convertedDir < 22.5m))
  1011.                                                 {
  1012.                                                     apiWindFrom = "North";
  1013.                                                 }
  1014.                                                 else if (convertedDir >= 22.5m && convertedDir < 67.5m)
  1015.                                                 {
  1016.                                                     apiWindFrom = "Northeast";
  1017.                                                 }
  1018.                                                 else if (convertedDir >= 67.5m && convertedDir <= 112.5m)
  1019.                                                 {
  1020.                                                     apiWindFrom = "East";
  1021.                                                 }
  1022.                                                 else if (convertedDir > 112.5m && convertedDir <= 157.5m)
  1023.                                                 {
  1024.                                                     apiWindFrom = "Southeast";
  1025.                                                 }
  1026.                                                 else if (convertedDir > 157.5m && convertedDir <= 202.5m)
  1027.                                                 {
  1028.                                                     apiWindFrom = "South";
  1029.                                                 }
  1030.                                                 else if (convertedDir > 202.5m && convertedDir <= 247.5m)
  1031.                                                 {
  1032.                                                     apiWindFrom = "Southwest";
  1033.                                                 }
  1034.                                                 else if (convertedDir > 247.5m && convertedDir <= 292.5m)
  1035.                                                 {
  1036.                                                     apiWindFrom = "West";
  1037.                                                 }
  1038.                                                 else if (convertedDir > 292.5m && convertedDir <= 337.5m)
  1039.                                                 {
  1040.                                                     apiWindFrom = "Northwest";
  1041.                                                 }
  1042.                                                 VA.SetText("AVCS_SENS_TempOWMwid_" + dayCurrent, apiWindFrom);
  1043.                                                 VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMwid_" + dayCurrent + "=" + apiWindFrom + Environment.NewLine);
  1044.                                             }
  1045.                                         }
  1046.                                     }
  1047.                                    
  1048.                                 }
  1049.                                
  1050.                                
  1051.                             }
  1052.                            
  1053.                             if (VA.GetBoolean("AVCS_SENS_OWM_UnitMetric") != true)
  1054.                                 apiTempUnits = "°F";
  1055.                             if (VA.GetBoolean("AVCS_SENS_OWM_WindMetric") != true)
  1056.                                 apiWindUnits = "mph";
  1057.                            
  1058.                             //Store New Main Conditions Value for TTS Requests
  1059.                             VA.SetText("AVCS_SENS_TempOWMfull_" + dayCurrent, dayCurrent + " will be " + apiMain + " with [lows;low temperatures] around " + ttsTempMin + apiTempUnits + " and highs [of;around;of around] " + ttsTempMax + ". [Expect;There will be] " + apiHumidity + "% humidity, and winds out of the " + apiWindFrom + " at " + ttsWind + apiWindUnits + ".");
  1060.                             VA.SetText("AVCS_SENS_OWM_FORECASTS", VA.GetText("AVCS_SENS_OWM_FORECASTS") + "AVCS_SENS_TempOWMfull_" + dayCurrent + "=" + VA.GetText("AVCS_SENS_TempOWMfull_" + dayCurrent) + Environment.NewLine);
  1061.                             if (debuggingFC)
  1062.                                 VA.WriteToLog(VA.GetText("AVCS_SENS_TempOWMfull_" + dayCurrent), "black");
  1063.                         }
  1064.                         else
  1065.                         {
  1066.                             throw new AVCSexception();
  1067.                         }
  1068.                        
  1069.                         //end of days loop
  1070.                     }
  1071.                     VA.SetBoolean("AVCS_OWM_FCSET", true);
  1072.                     if (VA.Command.Active("F_SFS_SAVE_FORECAST") != true)
  1073.                         VA.Command.Execute("F_SFS_SAVE_FORECAST", false);
  1074.                 }
  1075.                 else
  1076.                 {
  1077.                     throw new AVCSexception();
  1078.                 }
  1079.             }
  1080.             catch (AVCSexception e)
  1081.             {
  1082.                 //for any expected unexpected faults
  1083.                 e.GetWeatherURLException(VA);
  1084.             }
  1085.         }
  1086.     }
  1087.    
  1088.     private void GetWeatherApiReturn(string apiURL, dynamic VA)
  1089.     {
  1090.         VA.SetText("~avcs_owm_return", null);
  1091.         try
  1092.         {
  1093.             string apiReturn;
  1094.             using (WebClient wc = new WebClient())
  1095.             {
  1096.                 wc.Headers.Add("Accept-Language", " en-US");
  1097.                 wc.Headers.Add("Accept", " text/html, application/xhtml+xml, */*");
  1098.                 apiReturn = wc.DownloadString(apiURL);
  1099.                 VA.SetText("~avcs_owm_return", apiReturn);
  1100.             }
  1101.            
  1102.         }
  1103.         catch (WebException ex)
  1104.         {
  1105.             if (ex.Status == WebExceptionStatus.ProtocolError && ex.Response != null)
  1106.             {
  1107.                 var resp = (HttpWebResponse)ex.Response;
  1108.                 if (resp.StatusCode == HttpStatusCode.NotFound)// handle HTTP 404 errors
  1109.                 {
  1110.                     VA.WriteToLog("AVCS ERROR - HTTP 404 - Unable to find page at URL:", "red");
  1111.                     VA.WriteToLog(apiURL, "blank");
  1112.                 }
  1113.             }
  1114.         }
  1115.     }
  1116.    
  1117.     static bool canShowInterval(int n)
  1118.     {
  1119.         if (n > 0)
  1120.         {
  1121.             while (n > 0)
  1122.                 n = n - 3;
  1123.            
  1124.             if (n == 0)
  1125.                 return true;
  1126.         }
  1127.         return false;
  1128.     }
  1129.    
  1130.     private bool canGetDailyForecast()
  1131.     {
  1132.         decimal nextUnixSecs;
  1133.         if (Decimal.TryParse(VA.ParseTokens("{TXTNUM:AVCS_SENS_OWM_NextDailyForecastCheck}"), out nextUnixSecs))
  1134.             if (nextUnixSecs >= DateTimeOffset.Now.ToUnixTimeSeconds())
  1135.                 return false;
  1136.         return true;
  1137.     }
  1138.    
  1139.     private bool canGetWeatherData()
  1140.     {
  1141.         decimal nextUnixSecs;
  1142.         if (Decimal.TryParse(VA.ParseTokens("{TXTNUM:AVCS_SENS_OWM_NextWeatherGetCheck}"), out nextUnixSecs))
  1143.             if (nextUnixSecs >= DateTimeOffset.Now.ToUnixTimeSeconds())
  1144.                 return false;
  1145.         return true;
  1146.     }
  1147.    
  1148.     private static string showNextInterval(int intervalOWM, int GetWeatherInterval, int GetWeatherTimerDelay)
  1149.     {
  1150.         string timeRemaining;
  1151.         try
  1152.         {
  1153.             double minutesRemaining = TimeSpan.FromMilliseconds(((GetWeatherInterval - intervalOWM) * GetWeatherTimerDelay)).TotalMinutes;
  1154.             timeRemaining = "AVCS OWM Monitor will get new data in " + minutesRemaining.ToString().Substring(0,4) + " minutes";
  1155.         }
  1156.         catch
  1157.         {
  1158.             timeRemaining = "";
  1159.         }
  1160.        
  1161.         return timeRemaining;
  1162.     }
  1163.    
  1164.     public void main()
  1165.     {
  1166.         if (VA.GetBoolean("AVCS_OWM_Monitoring") != true)
  1167.         {
  1168.             VA.SetBoolean("AVCS_OWM_Monitoring", true);
  1169.             VA.SetBoolean("AVCS_OWM_SET", null);
  1170.             if (VA.GetBoolean("AVCS_OWM_Monitor_Startup") != true)
  1171.                 VA.SetBoolean("AVCS_OWM_Monitor_Startup", true);
  1172.            
  1173.             try
  1174.             {
  1175.                 GetWeatherData(VA);
  1176.                 if (VA.GetBoolean("AVCS_OWM_SET") != true)
  1177.                 {
  1178.                     VA.SetBoolean("AVCS_OWM_Monitoring", false);
  1179.                 }
  1180.             }
  1181.             catch
  1182.             {
  1183.                 //for any expected unexpected faults
  1184.                 VA.SetBoolean("AVCS_OWM_Monitoring", false);
  1185.             }
  1186.            
  1187.             if (VA.GetBoolean("AVCS_OWM_Monitoring") == true)
  1188.             {
  1189.                 if (VA.GetInt("AVCS_SENS_OWM_API_Calls") != null)
  1190.                 {
  1191.                     GetWeatherInterval = Convert.ToInt32(VA.GetInt("AVCS_SENS_OWM_API_Calls"));
  1192.                     if (GetWeatherInterval == 180)
  1193.                     {
  1194.                         timerInterval = "15 minutes";
  1195.                     }
  1196.                     else if (GetWeatherInterval == 360)
  1197.                     {
  1198.                         timerInterval = "30 minutes";
  1199.                     }
  1200.                     else if (GetWeatherInterval == 720)
  1201.                     {
  1202.                         timerInterval = "60 minutes";
  1203.                     }
  1204.                     else
  1205.                     {
  1206.                         int getNextWeatherInterval = (GetWeatherInterval * 5) / 60;
  1207.                         timerInterval = getNextWeatherInterval.ToString() + " minute(s)";
  1208.                     }
  1209.                 }
  1210.                 else
  1211.                 {
  1212.                     GetWeatherInterval = 180;
  1213.                     timerInterval = "15 minutes";
  1214.                 }
  1215.                
  1216.                 int getNextCheckInterval = (GetWeatherTimerDelay/1000) * GetWeatherInterval;
  1217.                 VA.SetInt("AVCS_SENS_OWM_WG_Calls", getNextCheckInterval);
  1218.                
  1219.                 GetWeatherTimer(timerInterval);
  1220.                
  1221.                 if (VA.ParseTokens("{CMDACTION}") == "Plugin")
  1222.                 {
  1223.                     VA.SetText("AVCS_SENS_TTS_WILDCARD", "Weather Data [Monitoring;;] Systems are now [active;online;ready;engaged]");
  1224.                     VA.Command.Execute("F_SAY_TTS", true);
  1225.                 }
  1226.             }
  1227.             else
  1228.             {
  1229.                 if (VA.ParseTokens("{CMDACTION}") == "Plugin")
  1230.                 {
  1231.                     VA.SetText("AVCS_SENS_TTS_WILDCARD", "Weather data unavailable. Please check settings.");
  1232.                     VA.Command.Execute("F_SAY_TTS", true);
  1233.                 }
  1234.             }
  1235.             VA.SetBoolean("AVCS_OWM_Monitor_Startup", null);
  1236.         }
  1237.     }
  1238. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!