Revize 1407c8ba

re #8840 Finishing up Json parser

Server/ServerApp/Parser/OutputInfo/JisInfo.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Parser.OutputInfo
-{
-    class JisInfo
-    {
-        string faculty;
-        int amount;
-        DateTime startTime;
-        int intervalLength;
-
-        public JisInfo(string faculty, int amount, DateTime startTime, int intervalLength)
-        {
-            this.faculty = faculty;
-            this.amount = amount;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime.ToString()} \t {faculty} \t {amount}";
-        }
-    }
-}

Server/ServerApp/Parser/OutputInfo/LogInInfo.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Parser.OutputInfo
-{
-    class LogInInfo
-    {
-        string building;
-        int amount;
-        DateTime startTime;
-        int intervalLength;
-
-        public LogInInfo(string building, int amount, DateTime startTime, int intervalLength)
-        {
-            this.building = building;
-            this.amount = amount;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime} \t {building} \t {amount}";
-        }
-    }
-}

Server/ServerApp/Parser/OutputInfo/LumInfo.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Parser.OutputInfo
-{
-    class LumInfo
-    {
-        // in lux
-        double value;
-        DateTime startTime;
-        int intervalLength;
-
-        public LumInfo(double value, DateTime startTime, int intervalLength)
-        {
-            this.value = value;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime.ToString()} \t {value}";
-        }
-    }
-}

Server/ServerApp/Parser/OutputInfo/RainInfo.cs

@@ -1 @@
-using System;
-
-namespace Parser.OutputInfo
-{
-    class RainInfo
-    {
-        // probability in %
-        double value;
-        DateTime startTime;
-        int intervalLength;
-
-        public RainInfo(double value, DateTime startTime, int intervalLength)
-        {
-            this.value = value;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime.ToString()} \t {value}";
-        }
-    }
-}

Server/ServerApp/Parser/OutputInfo/TempInfo.cs

@@ -1 @@
-using System;
-
-namespace Parser.OutputInfo
-{
-    class TempInfo
-    {
-        // in °C
-        double value;
-        DateTime startTime;
-        int intervalLength;
-
-        public TempInfo(double value, DateTime startTime, int intervalLength)
-        {
-            this.value = value;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime.ToString()} \t {value}";
-        }
-    }
-}

Server/ServerApp/Parser/OutputInfo/WeatherConditions.cs

@@ -13 +13 @@
     /// Transfers lux values to weather conditions and vice versa
     /// </summary>
     /// <author>Alex Konig</author>
-    public static class LuxToConditions
+    public static class ValueToConditions
     {
         /// <summary>
         /// Lux to weather conditions
@@ -26 +26 @@
                 return WeatherConditions.Sunny;
 
             if (lux > 20_000)
-                return WeatherConditions.Overcast;
+                return WeatherConditions.Cloudy;
 
             // TODO tohle bylo 10_000, jak mi to má vycházet, zkusit na hourly data
             if (lux != 0)
-                return WeatherConditions.Cloudy;
+                return WeatherConditions.Overcast;
 
             return WeatherConditions.Dark;
         }
@@ -43 +43 @@
         internal static double TransferConditionsToLux(WeatherConditions condition)
         {
             if (condition == WeatherConditions.Sunny)
-                return 50_000;
+                return 60_000;
 
             if (condition == WeatherConditions.Cloudy)
                 return 30_000;
 
             if (condition == WeatherConditions.Overcast)
-                return 15_000;
+                return 10_000;
 
             if (condition == WeatherConditions.Dark)
-                return 5_000;
+                return 0;
 
             return -1;
         }
+
+        internal static WeatherConditions CloudCoverToConditions(int cloudCover)
+        {
+            if (cloudCover >= 66)
+                return WeatherConditions.Overcast;
+
+            if (cloudCover >= 33)
+                return WeatherConditions.Cloudy;
+
+            if (cloudCover >= 0)
+                return WeatherConditions.Sunny;
+
+            return WeatherConditions.Dark;
+        }
     }
 }

Server/ServerApp/Parser/OutputInfo/WeatherInfo.cs

@@ -21 +21 @@
         public WeatherConditions condition;
 
         /// <summary> Start of interval </summary>
-        DateTime startTime;
+        public DateTime startTime;
         /// <summary> Length of interval in hours </summary>
-        int intervalLength;
+        public int intervalLength;
+
+        public WeatherInfo()
+        {
+            condition = WeatherConditions.Dark;
+        }
 
         /// <summary>
         /// Constructor
@@ -43 +48 @@
             this.lum = lum;
             this.intervalLength = intervalLength;
 
-            condition = LuxToConditions.TransferLuxToConditions(lum);
+            condition = ValueToConditions.TransferLuxToConditions(lum);
         }
 
         /// <summary>
@@ -64 +69 @@
             this.condition = condition;
             this.intervalLength = intervalLength;
 
-            lum = LuxToConditions.TransferConditionsToLux(condition);
+            lum = ValueToConditions.TransferConditionsToLux(condition);
         }
 
         /// <summary>
@@ -73 +78 @@
         /// <returns>interval start temperature probability of rain wind    weather condition</returns>
         public override string ToString()
         {
-            return $"{startTime.ToString()} \t {temp}°C \t {rain}% \t {wind}m/s \t {condition.ToString()} \t {lum}";
+            return $"{startTime} \t {temp}°C \t {rain}% \t {wind}m/s \t {condition.ToString()} \t {lum}";
         }
 
     }

Server/ServerApp/Parser/OutputInfo/WindInfo.cs

@@ -1 @@
-using System;
-
-namespace Parser.OutputInfo
-{
-    class WindInfo
-    {
-        // in m/s
-        double value;
-        DateTime startTime;
-        int intervalLength;
-
-        public WindInfo(double value, DateTime startTime, int intervalLength)
-        {
-            this.value = value;
-            this.startTime = startTime;
-            this.intervalLength = intervalLength;
-        }
-
-        public override string ToString()
-        {
-            return $"{startTime.ToString()} \t {value}";
-        }
-    }
-}

Server/ServerApp/Parser/Parsers/JsonParser.cs

@@ -1 +1 @@
 using ServerApp.DataDownload;
+using ServerApp.Parser.OutputInfo;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
-using System.Linq;
 using System.Net;
-using System.Text;
 using System.Text.Json;
-using System.Threading.Tasks;
-
+using static System.Text.Json.JsonElement;
 
 namespace ServerApp.Parser.Parsers
 {
+    /// <summary>
+    /// Class representing a parser for json prediction data
+    /// </summary>
+    /// <author>A. Konig</author>
     class JsonParser
     {
+        /// <summary> Current weather </summary>
+        public WeatherInfo current;
+        /// <summary> Prediction for today, tommorrow and day after tommorrow </summary>
+        public List<WeatherInfo> predictions;
+        
+        /// <summary> Data loader </summary>
         DataDownloader loader;
+        /// <summary> Currently parsed day </summary>
+        DateTime currParsedDay;
+        /// <summary> Sunrise time of currently parsed day </summary>
+        DateTime sunriseTime;
+        /// <summary> Sunset time of currently parsed day </summary>
+        DateTime sunsetTime;
 
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="loader"></param>
         public JsonParser(DataDownloader loader)
         {
             this.loader = loader;
         }
 
-
+        /// <summary>
+        /// Parse weather prediction
+        /// Results is in attributes current for current weather and pred for weather prediction for today, tommorrow and day after tommorrow
+        /// </summary>
         public void ParsePrediction()
         {
             // TODO ask DataDownloader for download said file and return path to it
+            
             // get file
             string file = DownloadWeatherPrediction();
             DateTime now = DateTime.Now;
             Console.WriteLine(File.Exists(file));
 
             // parse file
-            string data =  File.ReadAllText(file);
+            string data = File.ReadAllText(file);
 
             JsonDocument doc = JsonDocument.Parse(data);
             JsonElement root = doc.RootElement;
+            var weatherP = root.EnumerateObject();
+            predictions = new List<WeatherInfo>();
 
-            var users = root.EnumerateObject();
-            while (users.MoveNext())
+            while (weatherP.MoveNext())
             {
-                var user = users.Current;
-                Console.WriteLine(user.Name);
-                
-                /*
-                var props = user.EnumerateObject();
+                string name = weatherP.Current.Name;
+                Console.WriteLine(name);
 
-                while (props.MoveNext())
+                switch (name)
                 {
-                    var prop = props.Current;
-                    Console.WriteLine($"{prop.Name}: {prop.Value}");
+                    // current weather
+                    case "current_condition":
+                        {
+                            ArrayEnumerator currentWeather = weatherP.Current.Value.EnumerateArray();
+                            current = ParseCurrentWeather(currentWeather);
+
+                            break;
+
+                        }
+                    // weather prediction
+                    case "weather":
+                        {
+                            ArrayEnumerator weather = weatherP.Current.Value.EnumerateArray();
+                            ParseWeatherPredict(weather);
+
+                            break;
+                        }
                 }
-                */
             }
 
+            // sunrise + sunset into data
+            EncompassSunRiseSetTimes();
+
+            TestConsoleOutput();
+        }
+
+        private void TestConsoleOutput()
+        {
+            Console.WriteLine(current);
+            foreach (WeatherInfo w in predictions)
+                Console.WriteLine(w);
         }
 
+        // TODO move to data loader
+        /// <summary>
+        /// Downloads json file
+        /// </summary>
+        /// <returns> Path to file </returns>
         private string DownloadWeatherPrediction()
         {
             DateTime now = DateTime.Now;
             WebClient webClient = new WebClient();
-            webClient.DownloadFile("http://wttr.in/Plzen,czechia?format=j1", $"data/weather/{now.Year}{now.Month}{now.Day}.json");
+            webClient.DownloadFile("http://wttr.in/Plzen,czechia?format=j1", $"data/{now.Year}{now.Month}{now.Day}.json");
+
+            return $"data/{now.Year}{now.Month}{now.Day}.json";
+        }
+
+        /// <summary>
+        /// Change data in a way that they now reflect sunrise and sunset times
+        /// If current time under sunrise or over sunset -> WeatherConditions is Dark
+        /// If prediction time is under sunrise or over sunset and more than half of the interval is under/over said time -> WeatherCondition is Dark
+        /// </summary>
+        private void EncompassSunRiseSetTimes()
+        {
+            // change current weather
+            if ((current.startTime.TimeOfDay > sunsetTime.TimeOfDay) || (current.startTime.TimeOfDay < sunriseTime.TimeOfDay))
+                current.condition = WeatherConditions.Dark;
+
+            // change prediction
+            for (int i = 0; i < predictions.Count - 1; i++)
+            {
+                // TODO what about when days change -> detect end / start of day and do differently ?
+
+                WeatherInfo w = predictions[i];
+                WeatherInfo wNext = predictions[i + 1];
+
+                int timespan = wNext.startTime.Hour - w.startTime.Hour;
+                w.intervalLength = timespan;
+
+                // if start under sunset
+                if (w.startTime.TimeOfDay > sunsetTime.TimeOfDay)
+                    w.condition = WeatherConditions.Dark;
+
+                // if start under sunrise
+                if (w.startTime.TimeOfDay < sunriseTime.TimeOfDay)
+                {
+                    double howMuch = ((sunriseTime.Hour * 60 + sunriseTime.Minute) - (w.startTime.Hour * 60 + w.startTime.Minute)) / 60.0;
+
+                    if (howMuch >= timespan / 2.0)
+                        w.condition = WeatherConditions.Dark;
+                }
+
+                // if start under sunrise
+                TimeSpan endTime = new TimeSpan(w.startTime.TimeOfDay.Hours + timespan, w.startTime.TimeOfDay.Minutes, 0);
+                if (endTime > sunsetTime.TimeOfDay)
+                {
+                    double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.Minute)) / 60.0;
+
+                    if (howMuch >= timespan / 2.0)
+                        w.condition = WeatherConditions.Dark;
+                }
+            }
+
+            // last prediction
+            WeatherInfo wLast = predictions[predictions.Count - 1];
+            TimeSpan endTimeW = new TimeSpan(24, 0, 0);
+            int timespanLast = endTimeW.Hours - wLast.startTime.Hour;
+            wLast.intervalLength = timespanLast;
+
+            // if start under sunset
+            if (wLast.startTime.TimeOfDay > sunsetTime.TimeOfDay)
+                wLast.condition = WeatherConditions.Dark;
+
+            // if start under sunrise
+            if (wLast.startTime.TimeOfDay < sunriseTime.TimeOfDay)
+            {
+                double howMuch = ((sunriseTime.Hour * 60 + sunriseTime.Minute) - (wLast.startTime.Hour * 60 + wLast.startTime.Minute)) / 60.0;
+
+                if (howMuch >= timespanLast / 2.0)
+                    wLast.condition = WeatherConditions.Dark;
+            }
+
+            // if start under sunrise
+            if (endTimeW > sunsetTime.TimeOfDay)
+            {
+                double howMuch = ((endTimeW.Hours * 60 + endTimeW.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.Minute)) / 60.0;
+
+                if (howMuch >= timespanLast / 2.0)
+                    wLast.condition = WeatherConditions.Dark;
+            }
+        }
+
+        /// <summary>
+        /// Parse weather prediction
+        /// </summary>
+        /// <param name="weather"> ArrayEnumerator of weather predictions </param>
+        private void ParseWeatherPredict(ArrayEnumerator weather)
+        {
+            while (weather.MoveNext())
+            {
+                // prediction for one day
+                var obj = weather.Current.EnumerateObject();
+
+                while (obj.MoveNext())
+                {
+                    switch (obj.Current.Name)
+                    {
+                        case "date":
+                            {
+                                DateTime.TryParseExact(obj.Current.Value.GetString(), "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out currParsedDay);
+                                break;
+                            }
+                        // hourly predictions
+                        case "hourly":
+                            {
+                                ParseHourly(obj.Current.Value.EnumerateArray());
+                                break;
+                            }
+                        // sunset / sunrise hours
+                        case "astronomy":
+                            {
+                                ParseAstronomy(obj.Current.Value.EnumerateArray());
+                                break;
+                            }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse sunrise and sunset times
+        /// </summary>
+        /// <param name="astronomy"> Astronomy array enumerator </param>
+        private void ParseAstronomy(ArrayEnumerator astronomy)
+        {
+            while (astronomy.MoveNext())
+            {
+                var astrInfo = astronomy.Current.EnumerateObject();
+                
+                while (astrInfo.MoveNext())
+                {
+                    switch (astrInfo.Current.Name)
+                    {
+                        case "sunrise":
+                            {
+                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunriseTime);
+                                Console.WriteLine("\t sunrise time : " + sunriseTime + " " + astrInfo.Current.Value.GetString());
+                                break;
+                            }
+                        case "sunset":
+                            {
+                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunsetTime);
+                                Console.WriteLine("\t sunset time : " + sunsetTime + " " + astrInfo.Current.Value.GetString());
+                                break;
+                            }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse hourly predictions
+        /// </summary>
+        /// <param name="hourly">Enumerated array of hourly predictions</param>
+        private void ParseHourly(ArrayEnumerator hourly)
+        {
+            while (hourly.MoveNext())
+            {
+                // one hourly prediction
+                var oneH = hourly.Current.EnumerateObject();
+                WeatherInfo weather = new WeatherInfo();
+
+                while (oneH.MoveNext())
+                {
+                    switch (oneH.Current.Name)
+                    {
+                        case "FeelsLikeC":
+                            {
+                                Double.TryParse(oneH.Current.Value.GetString(), out weather.temp);
+                                break;
+                            }
+                        case "cloudcover":
+                            {
+                                int cloudCover;
+                                Int32.TryParse(oneH.Current.Value.GetString(), out cloudCover);
+                                weather.condition = ValueToConditions.CloudCoverToConditions(cloudCover);
+                                break;
+                            }
+                        // take into account highest value from "chanceofrain" and "chaceofsnow"
+                        case "chanceofrain":
+                            {
+                                int rain;
+                                Int32.TryParse(oneH.Current.Value.GetString(), out rain);
+                                weather.rain = rain > weather.rain ? rain : weather.rain;
+                                break;
+                            }
+                        case "chanceofsnow":
+                            {
+                                int snow;
+                                Int32.TryParse(oneH.Current.Value.GetString(), out snow);
+                                weather.rain = snow > weather.rain ? snow : weather.rain;
+                                break;
+                            }
+                        // wind kmph has to be translated to mps
+                        case "WindGustKmph":
+                            {
+                                double windkmh;
+                                Double.TryParse(oneH.Current.Value.GetString(), out windkmh);
+                                weather.wind= windkmh * 1000 / (60.0*60.0);
+                                break;
+                            }
+                        case "time":
+                            {
+                                int h;
+                                Int32.TryParse(oneH.Current.Value.GetString(), out h);
+                                h /= 100;
+                                DateTime time = new DateTime(currParsedDay.Year, currParsedDay.Month, currParsedDay.Day, h, 0, 0);
+                                weather.startTime = time;
+                                break;
+                            }
+                    }
+                }
+
+                // Console.WriteLine(weather.ToString());
+                predictions.Add(weather);
+
+            }
 
-            return $"data/weather/{now.Year}{now.Month}{now.Day}.json";
         }
+
+        /// <summary>
+        /// Parse current weather
+        /// </summary>
+        /// <param name="currentWeather">Enumerated hour of weather data</param>
+        /// <returns>WeatherInfo with current weather</returns>
+        private WeatherInfo ParseCurrentWeather(ArrayEnumerator currentWeather)
+        {
+            WeatherInfo res = new WeatherInfo();
+            //res.current = true;
+
+            while (currentWeather.MoveNext())
+            {
+                var obj = currentWeather.Current.EnumerateObject();
+
+                while (obj.MoveNext())
+                {
+                    switch (obj.Current.Name)
+                    {
+                        case "localObsDateTime":
+                            {
+                                DateTime.TryParse(obj.Current.Value.GetString(), out res.startTime);
+                                break;
+                            }
+                        case "FeelsLikeC":
+                            {
+                                Double.TryParse(obj.Current.Value.GetString(), out res.temp);
+                                break;
+                            }
+                        case "cloudcover":
+                            {
+                                int cloudCover;
+                                Int32.TryParse(obj.Current.Value.GetString(), out cloudCover);
+                                res.condition = ValueToConditions.CloudCoverToConditions(cloudCover);
+                                break;
+                            }
+                        case "precipMM":
+                            {
+                                double rainMM;
+                                Double.TryParse(obj.Current.Value.GetString(), out rainMM);
+                                res.rain = rainMM > 0 ? 100 : 0;
+                                break;
+                            }
+                        case "windspeedKmph":
+                            {
+                                double wind;
+                                Double.TryParse(obj.Current.Value.GetString(), out wind);
+                                res.wind = wind * 1000 / (60.0 * 60.0);
+                                break;
+                            }
+                    }
+                }
+
+            }
+
+            return res;
+        }
+
     }
 }

Server/ServerApp/Parser/Parsers/WeatherParser.cs

@@ -110 +110 @@
                 recordedAmount[1] += list[i].rain;
                 recordedAmount[2] += list[i].wind;
 
-                if (LuxToConditions.TransferLuxToConditions(list[i].lum * 1000) != WeatherConditions.Dark)
+                if (ValueToConditions.TransferLuxToConditions(list[i].lum * 1000) != WeatherConditions.Dark)
                     recordedAmount[3] += list[i].lum * 1000; weatherValues++;
 
                 values++;

Server/ServerApp/ServerApp.csproj

@@ -151 +151 @@
     <Compile Include="Parser\InputData\LogInInstance.cs" />
     <Compile Include="Parser\InputData\WeatherInstance.cs" />
     <Compile Include="Parser\OutputInfo\ActivityInfo.cs" />
-    <Compile Include="Parser\OutputInfo\JisInfo.cs" />
-    <Compile Include="Parser\OutputInfo\LogInInfo.cs" />
-    <Compile Include="Parser\OutputInfo\LumInfo.cs" />
-    <Compile Include="Parser\OutputInfo\RainInfo.cs" />
-    <Compile Include="Parser\OutputInfo\TempInfo.cs" />
     <Compile Include="Parser\OutputInfo\WeatherConditions.cs" />
     <Compile Include="Parser\OutputInfo\WeatherInfo.cs" />
-    <Compile Include="Parser\OutputInfo\WindInfo.cs" />
     <Compile Include="Parser\Parsers\DataParser.cs" />
     <Compile Include="Parser\Parsers\JisParser.cs" />
     <Compile Include="Parser\Parsers\JsonParser.cs" />