Revize cdf3c217

re #8841 Fixing errors in start/end time and adding interfaces for DataParser and JsonParser

Server/ServerApp/Parser/InputData/CsvDataLoader.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
@@ -8 +12 @@
     /// <summary>
     /// Class responsible for loading data from file
     /// </summary>
-    /// <author>Alex Konig</author>
-    class CsvDataLoader : DataLoader
+    /// <author>A. Konig</author>
+    class CsvDataLoader : IDataLoader
     {
         /// <summary> Culture info for parsing numbers </summary>
         static CultureInfo cultureInfo = new CultureInfo("de-DE");

Server/ServerApp/Parser/InputData/DataLoader.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace ServerApp.Parser.InputData
-{
-    /// <author>Alex Konig</author>
-    interface DataLoader
-    {
-        /// <summary>
-        /// Load jis data from file
-        /// </summary>
-        /// <param name="pathToFile">Path to file</param>
-        /// <returns></returns>
-        List<JisInstance> LoadJisFile(string pathToFile);
-
-        /// <summary>
-        /// Load login data from file
-        /// </summary>
-        /// <param name="pathToFile">Path to file</param>
-        /// <returns></returns>
-        List<LogInInstance> LoadLoginFile(string pathToFile);
-        /// <summary>
-        /// Load weather data from file
-        /// </summary>
-        /// <param name="pathToFile">Path to file</param>
-        /// <returns></returns>
-        List<WeatherInstance> LoadWeatherFile(string pathToFile);
-
-    }
-}

Server/ServerApp/Parser/InputData/IDataLoader.cs

@@ +1 @@
+//
+// Author: A. Konig
+//
+
+using System.Collections.Generic;
+
+namespace ServerApp.Parser.InputData
+{
+    /// <summary>
+    /// Interface that every DataLoader should implement
+    /// </summary>
+    /// <author>A. Konig</author>
+    interface IDataLoader
+    {
+        /// <summary>
+        /// Load jis data from file
+        /// </summary>
+        /// <param name="pathToFile">Path to file</param>
+        /// <returns></returns>
+        List<JisInstance> LoadJisFile(string pathToFile);
+
+        /// <summary>
+        /// Load login data from file
+        /// </summary>
+        /// <param name="pathToFile">Path to file</param>
+        /// <returns></returns>
+        List<LogInInstance> LoadLoginFile(string pathToFile);
+        /// <summary>
+        /// Load weather data from file
+        /// </summary>
+        /// <param name="pathToFile">Path to file</param>
+        /// <returns></returns>
+        List<WeatherInstance> LoadWeatherFile(string pathToFile);
+
+    }
+}

Server/ServerApp/Parser/InputData/JisInstance.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 
 namespace ServerApp.Parser.InputData
 {
@@ -13 +17 @@
     ///     "A1";"08.04.2018 14:23:15";1
     ///     [place tag];[date time];[amount]
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class JisInstance
     {
         /// <summary> Place tag  </summary>

Server/ServerApp/Parser/InputData/LogInInstance.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 
 namespace ServerApp.Parser.InputData
 {
@@ -20 +24 @@
     ///     "27.10.2011 00:00:00";1;7;"13:00";"13:45";"UI";"Laboratoř";"UI-505";"ui505av07-lps"
     ///     [datum];[amount];[lesson];[lesson start];[lesson end];[building];[room type];[room];[hostname]
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class LogInInstance
     {
         /// <summary> Date time </summary>

Server/ServerApp/Parser/InputData/WeatherInstance.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 
 namespace ServerApp.Parser.InputData
 {
@@ -9 +13 @@
     ///     "30.04.2019 16:19:01";20.3;5.3;0;19
     ///     [date time];[temperature];[wind];[rain];[luminance]
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class WeatherInstance
     {
         /// <summary> Date and time </summary>

Server/ServerApp/Parser/OutputInfo/ActivityInfo.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 
 namespace ServerApp.Parser.OutputInfo
 {
@@ -6 +10 @@
     /// Class representing the number of events in a given time interval a given faculty
     /// - shortest possible interval is 1h
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class ActivityInfo
     {
         /// <summary> Building </summary>

Server/ServerApp/Parser/OutputInfo/ValueToConditions.cs

@@ +1 @@
+//
+// Author: A. Konig
+//
+
+namespace ServerApp.Parser.OutputInfo
+{
+    /// <summary>
+    /// Transfers various values to weather conditions and vice versa
+    /// </summary>
+    /// <author>A. Konig</author>
+    public static class ValueToConditions
+    {
+        /// <summary>
+        /// Lux to weather conditions
+        /// </summary>
+        /// <param name="lux">Lux value</param>
+        /// <returns>Weather conditions</returns>
+        public static WeatherConditions TransferLuxToConditions(double lux)
+        {
+            if (lux > 40_000)
+                return WeatherConditions.Sunny;
+
+            if (lux > 20_000)
+                return WeatherConditions.Cloudy;
+
+            // TODO tohle bylo 10_000, jak mi to má vycházet, zkusit na hourly data
+            if (lux != 0)
+                return WeatherConditions.Overcast;
+
+            return WeatherConditions.Dark;
+        }
+
+        /// <summary>
+        /// Weather conditions to average lux
+        /// </summary>
+        /// <param name="condition">Weather conditions</param>
+        /// <returns>Lux value</returns>
+        internal static double TransferConditionsToLux(WeatherConditions condition)
+        {
+            if (condition == WeatherConditions.Sunny)
+                return 60_000;
+
+            if (condition == WeatherConditions.Cloudy)
+                return 30_000;
+
+            if (condition == WeatherConditions.Overcast)
+                return 10_000;
+
+            if (condition == WeatherConditions.Dark)
+                return 0;
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Cloud cover value in percentage to weather conditions
+        /// </summary>
+        /// <param name="cloudCover">Value expected between 0-100</param>
+        /// <returns>WeatherConditions</returns>
+        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/WeatherConditions.cs

@@ -1 @@
-namespace ServerApp.Parser.OutputInfo
+//
+// Author: A. Konig
+//
+
+namespace ServerApp.Parser.OutputInfo
 {
     /// <summary>
     /// Weather conditions in regards to sun level
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     public enum WeatherConditions
     {
         Sunny, Cloudy, Overcast, Dark
     }
-
-    /// <summary>
-    /// Transfers lux values to weather conditions and vice versa
-    /// </summary>
-    /// <author>Alex Konig</author>
-    public static class ValueToConditions
-    {
-        /// <summary>
-        /// Lux to weather conditions
-        /// </summary>
-        /// <param name="lux">Lux value</param>
-        /// <returns>Weather conditions</returns>
-        public static WeatherConditions TransferLuxToConditions(double lux)
-        {
-            if (lux > 40_000)
-                return WeatherConditions.Sunny;
-
-            if (lux > 20_000)
-                return WeatherConditions.Cloudy;
-
-            // TODO tohle bylo 10_000, jak mi to má vycházet, zkusit na hourly data
-            if (lux != 0)
-                return WeatherConditions.Overcast;
-
-            return WeatherConditions.Dark;
-        }
-
-        /// <summary>
-        /// Weather conditions to average lux
-        /// </summary>
-        /// <param name="condition">Weather conditions</param>
-        /// <returns>Lux value</returns>
-        internal static double TransferConditionsToLux(WeatherConditions condition)
-        {
-            if (condition == WeatherConditions.Sunny)
-                return 60_000;
-
-            if (condition == WeatherConditions.Cloudy)
-                return 30_000;
-
-            if (condition == WeatherConditions.Overcast)
-                return 10_000;
-
-            if (condition == WeatherConditions.Dark)
-                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

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 
 namespace ServerApp.Parser.OutputInfo
 {
@@ -6 +10 @@
     /// Class representing the weather in a given interval at ZCU
     /// - shortest possible interval is 1h
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class WeatherInfo
     {
         /// <summary> Temperature in °C </summary>

Server/ServerApp/Parser/Parsers/DataParser.cs

@@ -1 @@
-using ServerApp.Parser.InputData;
+//
+// Author: A. Konig
+//
+
+using ServerApp.DataDownload;
+using ServerApp.Parser.InputData;
 using ServerApp.Parser.OutputInfo;
 using System;
 using System.Collections.Generic;
@@ -11 +16 @@
     /// Class parsing data files into instances of ActivityInfo and WeatherInfo divided by given time interval
     /// Data parsed from 7am (included) to 18pm (included)
     /// </summary>
-    /// <author>Alex Konig</author>
-    class DataParser
+    /// <author>A. Konig</author>
+    class DataParser : IDataParser
     {
-        /// <summary> Path to data folder </summary>
-        string path;
+        /// <summary> Data downloader </summary>
+        DataDownloader downloader;
+
         /// <summary> Weather data parser </summary>
         WeatherParser weatherParser;
         /// <summary> Jis data parser </summary>
@@ -25 +31 @@
 
         /// <summary> WeatherInfo </summary>
         List<WeatherInfo> weatherList;
-        public List<WeatherInfo> WeatherList { get => weatherList; }
+        public new List<WeatherInfo> WeatherList { get => weatherList; }
         /// <summary> ActivityInfo repersenting overall activity </summary>
         List<ActivityInfo> attendanceList;
-        public List<ActivityInfo> AttendanceList { get => attendanceList; }
+        public new List<ActivityInfo> AttendanceList { get => attendanceList; }
 
         /// <summary> ActivityInfo representing jis activity </summary>
         List<ActivityInfo> jisList;
         /// <summary> ActivityInfo representing login activity</summary>
         List<ActivityInfo> loginList;
 
+
         /// <summary>
         /// Constructor
         /// </summary>
-        public DataParser(string path)
+        public DataParser(DataDownloader downloader)
         {
+            this.downloader = downloader;
+
             TagInfo.CreateDictionaries();
 
-            // TODO ask for data folder
-            this.path = path;
-            DataLoader loader = new CsvDataLoader();
+            IDataLoader loader = new CsvDataLoader();
 
             weatherParser = new WeatherParser(loader);
             jisParser = new JisParser(loader);
@@ -56 +63 @@
         /// </summary>
         /// <param name="interval">Length of an interval</param>
         /// <param name="wholeDay">Parse data as one instance per day</param>
-        public bool Parse(DateTime startTime, DateTime endTime, int interval = 1, bool wholeDay = true)
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
+        override public bool Parse(DateTime startTime, DateTime endTime, int interval = 1, bool wholeDay = true)
         {
-            // TODO start and end time -> ask for files from this span, plus validate if the data really is from this span (issue with 00 files)
 
             var cultureInfo = CultureInfo.GetCultureInfo("en-GB");
             Thread.CurrentThread.CurrentCulture = cultureInfo;
             Thread.CurrentThread.CurrentUICulture = cultureInfo;
 
-            string pathWeather = path + "weather";
-            string pathJis = path + "jis";
-            string pathLogIn = path + "login";
+            // get path to folder w/ datafiles
+            string pathWeather = downloader.DataSubDirectories[DataType.POCASI]; // path + "weather";
+            string pathJis = downloader.DataSubDirectories[DataType.JIS]; // path + "jis";
+            string pathLogIn = downloader.DataSubDirectories[DataType.STROJE]; // path + "login";
+
+            // get all files that should be parsed
+            Date start = new Date((uint)startTime.Month, (uint)startTime.Year);
+            Date end = new Date((uint)endTime.Month, (uint)endTime.Year);
+            var weatherFiles = downloader.GetData(pathWeather, start, end);
+            var jisFiles = downloader.GetData(pathJis, start, end);
+            var loginFiles = downloader.GetData(pathLogIn, start, end);
 
-            weatherList = weatherParser.ParseWeatherData(pathWeather, wholeDay, interval);
-            jisList = jisParser.ParseJisData(pathJis, wholeDay, interval);
-            loginList = loginParser.ParseLogInData(pathLogIn, wholeDay, interval);
+            weatherList = weatherParser.ParseWeatherData(weatherFiles, startTime, endTime, wholeDay, interval);
+            jisList = jisParser.ParseJisData(jisFiles, startTime, endTime, wholeDay, interval);
+            loginList = loginParser.ParseLogInData(loginFiles, startTime, endTime, wholeDay, interval);
 
             //Console.WriteLine("WEATHER");
             //WriteToConsole(weatherList);
-            //Console.WriteLine("JIS");
-            //WriteToConsole(jisList);
+            Console.WriteLine("JIS");
+            WriteToConsole(jisList);
             //Console.WriteLine("LOGIN");
             //WriteToConsole(loginList);
 
@@ -83 +99 @@
 
             MergeAttendance();
 
-            //Console.WriteLine("MERGED IN ONE LIST");
-            //WriteToConsole(attendanceList);
+            Console.WriteLine("MERGED IN ONE LIST");
+            WriteToConsole(attendanceList);
 
             if (weatherList.Count == 0 || attendanceList.Count == 0)
                 return false;

Server/ServerApp/Parser/Parsers/IDataParser.cs

@@ +1 @@
+//
+// Author: A. Konig
+//
+
+using ServerApp.Parser.OutputInfo;
+using System;
+using System.Collections.Generic;
+
+namespace ServerApp.Parser.Parsers
+{
+    /// <summary>
+    /// Abstract class that every DataParser should inherit from
+    /// </summary>
+    /// <author>A. Konig</author>
+    abstract class IDataParser
+    {
+        /// <summary> WeatherInfo </summary>
+        List<WeatherInfo> weatherList;
+        public List<WeatherInfo> WeatherList { get => weatherList; }
+        /// <summary> ActivityInfo repersenting overall activity </summary>
+        List<ActivityInfo> attendanceList;
+        public List<ActivityInfo> AttendanceList { get => attendanceList; }
+
+        /// <summary>
+        /// Parse data
+        /// </summary>
+        /// <param name="interval">Length of an interval</param>
+        /// <param name="wholeDay">Parse data as one instance per day</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
+        public abstract bool Parse(DateTime startTime, DateTime endTime, int interval = 1, bool wholeDay = true);
+
+    }
+}

Server/ServerApp/Parser/Parsers/JisParser.cs

@@ -1 @@
-using System;
+//
+// Author: A. Konig
+//
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using ServerApp.Parser.InputData;
@@ -10 +14 @@
     /// Class parsing jis files into instances of ActivityInfo divided by given time interval
     /// Data parsed from 7am (included) to 18pm (included)
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class JisParser
     {
 
         /// <summary> Datafile loader  </summary>
-        DataLoader loader;
+        IDataLoader loader;
 
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="loader">Datafile loader</param>
-        public JisParser(DataLoader loader)
+        public JisParser(IDataLoader loader)
         {
             this.loader = loader;
         }
@@ -30 +34 @@
         /// Parses jis data to ActivityInfo instances
         /// Data parsed from 7am (included) to 18pm (included)
         /// </summary>
-        /// <param name="folder">Folder with login data files</param>
+        /// <param name="jisFiles">Paths to files with login data files</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <param name="wholeDay">Should data be parsed as one instance per day (if true parameter interval will be ignored)</param>
         /// <param name="interval">Time interval to divide days by, minimum is 1h</param>
         /// <returns></returns>
-        public List<ActivityInfo> ParseJisData(string folder, bool wholeDay = true, int interval = 1)
+        public List<ActivityInfo> ParseJisData(List<string> jisFiles, DateTime startTime, DateTime endTime, bool wholeDay = true, int interval = 1)
         {
-            if (!Directory.Exists(folder))
-                return null;
-
             List<ActivityInfo> list = new List<ActivityInfo>();
 
+            if (jisFiles == null || startTime == null || endTime == null || interval <= 0)
+                return list;
+
             // parse all files
-            string[] fileEntries = Directory.GetFiles(folder);
-            foreach (string fileName in fileEntries)
+            foreach (string fileName in jisFiles)
             {
-                List<ActivityInfo> loadedData = null;
-
+                if (!File.Exists(fileName))
+                    continue;
+                
                 // parse as one instance per day
+                List<ActivityInfo> loadedData = null;
                 if (wholeDay)
-                    loadedData = ProcessOneJisFileAsDays(fileName);
+                    loadedData = ProcessOneJisFileAsDays(fileName, startTime, endTime);
                 // parse by interval length
                 else
-                    loadedData = ProcessOneJisFileAsIntervals(fileName, interval);
+                    loadedData = ProcessOneJisFileAsIntervals(fileName, interval, startTime, endTime);
 
                 list.AddRange(loadedData);
             }
@@ -63 +70 @@
         /// <summary>
         /// Parses data from one data file as one instance per day
         /// </summary>
-        /// <param name="path">Path ti file</param>
+        /// <param name="path">Path to file</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with ActivityInfo instances</returns>
-        private List<ActivityInfo> ProcessOneJisFileAsDays(string path)
+        private List<ActivityInfo> ProcessOneJisFileAsDays(string path, DateTime startTime, DateTime endTime)
         {
+            List<ActivityInfo> jisInfo = new List<ActivityInfo>();
+            
             if (!File.Exists(path))
-                return null;
+                return jisInfo;
 
-            List<ActivityInfo> jisInfo = new List<ActivityInfo>();
             List<JisInstance> list =  loader.LoadJisFile(path);
 
             // data for each faculty
@@ -104 +114 @@
                     lastStartTime = date;
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].dateTime < startTime || list[i].dateTime > endTime)
+                    continue;
+
                 // aggregate data
                 if (TagInfo.jisPlaces.ContainsKey(place))
                 {
@@ -138 +152 @@
         /// </summary>
         /// <param name="path">Path ti file</param>
         /// <param name="interval">Interval length</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with ActivityInfo instances</returns>
-        private List<ActivityInfo> ProcessOneJisFileAsIntervals(string path, int interval)
+        private List<ActivityInfo> ProcessOneJisFileAsIntervals(string path, int interval, DateTime startTime, DateTime endTime)
         {
+            List<ActivityInfo> jisInfo = new List<ActivityInfo>();
+            
             if (!File.Exists(path))
-                return null;
+                return jisInfo;
 
-            List<ActivityInfo> jisInfo = new List<ActivityInfo>();
             List<JisInstance> list = loader.LoadJisFile(path);
 
             // data for each faculty
@@ -164 +181 @@
             // first day
             DateTime lastStartTime = new DateTime(list[0].dateTime.Year, list[0].dateTime.Month, list[0].dateTime.Day, minmaxHour[0], 0, 0);
             int endtime = to[0];
-            int startTime = minmaxHour[0];
+            int startingTime = minmaxHour[0];
             int index = 0;
             for (int i = 0; i < list.Count; i++)
             {
@@ -188 +205 @@
                 if ( date.Hour >= endtime || trigger) 
                 {
                     // start time of last interval
-                    DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, startTime, 0, 0);
+                    DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, startingTime, 0, 0);
 
                     // find end and start time
                     if (!trigger)
@@ -198 +215 @@
 
                     endtime = to[index];
                     if (index == 0)
-                        startTime = minmaxHour[0];
+                        startingTime = minmaxHour[0];
                     else
-                        startTime = to[index - 1];
+                        startingTime = to[index - 1];
 
                     // data for each faculty separate
                     for (int k = 0; k < TagInfo.buildings.Length; k++)
@@ -213 +230 @@
                     lastStartTime = date;
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].dateTime < startTime || list[i].dateTime > endTime)
+                    continue;
+
                 // aggregate data
                 if (TagInfo.jisPlaces.ContainsKey(place))
                 {

Server/ServerApp/Parser/Parsers/JsonParser.cs

@@ -1 @@
-using ServerApp.DataDownload;
-using ServerApp.Parser.OutputInfo;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Net;
-using System.Text.Json;
-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);
-
-            JsonDocument doc = JsonDocument.Parse(data);
-            JsonElement root = doc.RootElement;
-            var weatherP = root.EnumerateObject();
-            predictions = new List<WeatherInfo>();
-
-            while (weatherP.MoveNext())
-            {
-                string name = weatherP.Current.Name;
-                Console.WriteLine(name);
-
-                switch (name)
-                {
-                    // 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/{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++)
-            {
-                WeatherInfo w = predictions[i];
-                WeatherInfo wNext = predictions[i + 1];
-
-                // if wNext time < than w time then it is prediction from the next day -> add 24 to correctly calculate timespan
-                int timespan = wNext.startTime.Hour - w.startTime.Hour;
-                if (wNext.startTime.Hour < w.startTime.Hour)
-                    timespan = (wNext.startTime.Hour+24) - 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);
-
-            }
-
-        }
-
-        /// <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/LogInParser.cs

@@ -1 @@
-using ServerApp.Parser.InputData;
+//
+// Author: A. Konig
+//
+
+using ServerApp.Parser.InputData;
 using ServerApp.Parser.OutputInfo;
 using System;
 using System.Collections.Generic;
@@ -10 +14 @@
     /// Class parsing login files into instances of ActivityInfo divided by given time interval
     /// Data parsed from 7am (included) to 18pm (included)
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class LogInParser
     {
         /// <summary> Datafile loader  </summary>
-        DataLoader loader;
+        IDataLoader loader;
 
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="loader">Datafile loader</param>
-        public LogInParser(DataLoader loader)
+        public LogInParser(IDataLoader loader)
         {
             this.loader = loader;
         }
@@ -29 +33 @@
         /// Parses login data to ActivityInfo instances
         /// Data parsed from 7am (included) to 18pm (included)
         /// </summary>
-        /// <param name="folder">Folder with login data files</param>
+        /// <param name="loginFiles">Paths to files with login data files</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <param name="wholeDay">Should data be parsed as one instance per day (if true parameter interval will be ignored)</param>
         /// <param name="interval">Time interval to divide days by, minimum is 1h</param>
         /// <returns></returns>
-        public List<ActivityInfo> ParseLogInData(string folder, bool wholeDay = true, int interval = 1)
+        public List<ActivityInfo> ParseLogInData(List<string> loginFiles, DateTime startTime, DateTime endTime, bool wholeDay = true, int interval = 1)
         {
-            if (!Directory.Exists(folder))
-                return null;
-            
             List<ActivityInfo> list = new List<ActivityInfo>();
 
-            // get all files in folder
-            string[] fileEntries = Directory.GetFiles(folder);
-            foreach (string fileName in fileEntries)
+            if (loginFiles == null || startTime == null || endTime == null || interval <= 0)
+                return list;
+
+            // for all files in folder
+            foreach (string fileName in loginFiles)
             {
-                List<ActivityInfo> loadedData = null;
+                if (!File.Exists(fileName))
+                    continue;
                 
                 // parse as one instance per day
+                List<ActivityInfo> loadedData = null;
                 if (wholeDay)
-                    loadedData = ProcessOneLogInFileAsDays(fileName);
+                    loadedData = ProcessOneLogInFileAsDays(fileName, startTime, endTime);
                 // parse by interval length
                 else
-                    loadedData = ProcessOneLoginFileAsIntervals(fileName, interval);
+                    loadedData = ProcessOneLoginFileAsIntervals(fileName, interval, startTime, endTime);
 
                 list.AddRange(loadedData);
             }
@@ -63 +70 @@
         /// Parses data from one data file as one instance per day
         /// </summary>
         /// <param name="path">Path ti file</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with ActivityInfo instances</returns>
-        private List<ActivityInfo> ProcessOneLogInFileAsDays(string path)
+        private List<ActivityInfo> ProcessOneLogInFileAsDays(string path, DateTime startTime, DateTime endTime)
         {
+            List<ActivityInfo> loginInfo = new List<ActivityInfo>();
+
             if (!File.Exists(path))
-                return null;
+                return loginInfo;
 
-            List<ActivityInfo> loginInfo = new List<ActivityInfo>();
             List<LogInInstance> list = loader.LoadLoginFile(path);
 
             // data for each faculty
@@ -103 +113 @@
                     lastStartDay = date;
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].date < startTime || list[i].date > endTime)
+                    continue;
+
                 // aggregate data
                 if (TagInfo.buildingTags.ContainsKey(place))
                 {
@@ -140 +154 @@
         /// </summary>
         /// <param name="path">Path to file</param>
         /// <param name="interval">Interval length</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with ActivityInfo instances</returns>
-        private List<ActivityInfo> ProcessOneLoginFileAsIntervals(string path, int interval)
+        private List<ActivityInfo> ProcessOneLoginFileAsIntervals(string path, int interval, DateTime startTime, DateTime endTime)
         {
+            List<ActivityInfo> loginInfo = new List<ActivityInfo>();
+            
             if (!File.Exists(path))
-                return null;
+                return loginInfo;
 
-            List<ActivityInfo> loignInfo = new List<ActivityInfo>();
             List<LogInInstance> list = loader.LoadLoginFile(path);
 
             // min/max hour taken into account
@@ -190 +207 @@
                         for (int l = 0; l < TagInfo.buildings.Length; l++)
                         {
                             ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[l], data[k][l], stTime, interval);
-                            loignInfo.Add(dayInfo);
+                            loginInfo.Add(dayInfo);
                         }
 
                         data[k] = new int[TagInfo.buildings.Length];
@@ -198 +215 @@
                     lastStartTime = date;
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].date < startTime || list[i].date > endTime)
+                    continue;
+
                 // find index for current instance
                 index = 0;
                 for (int k = 1; k < to.Length; k++)
@@ -243 +264 @@
                 for (int l = 0; l < TagInfo.buildings.Length; l++)
                 {
                     ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[l], data[k][l], stTime, interval);
-                    loignInfo.Add(dayInfo);
+                    loginInfo.Add(dayInfo);
                 }
             }
 
-            return loignInfo;
+            return loginInfo;
         }
 
     }

Server/ServerApp/Parser/Parsers/TagInfo.cs

@@ -1 @@
-using System.Collections.Generic;
+//
+// Author: A. Konig
+//
 
-// 30min
+using System.Collections.Generic;
 
 namespace ServerApp.Parser.Parsers
 {
+    /// <summary>
+    /// Class with Tags used in application
+    /// </summary>
     /// <author>Alex Konig</author>
     class TagInfo
     {

Server/ServerApp/Parser/Parsers/WeatherParser.cs

@@ -1 @@
-using ServerApp.Parser.InputData;
+//
+// Author: A. Konig
+//
+
+using ServerApp.Parser.InputData;
 using ServerApp.Parser.OutputInfo;
 using System;
 using System.Collections.Generic;
@@ -10 +14 @@
     /// Class parsing weather files into instances of WeatherInfo divided by given time interval
     /// Data parsed from 7am (included) to 18pm (included)
     /// </summary>
-    /// <author>Alex Konig</author>
+    /// <author>A. Konig</author>
     class WeatherParser
     {
 
         /// <summary> Datafile loader  </summary>
-        DataLoader loader;
+        IDataLoader loader;
 
         /// <summary>
         /// Constructor
         /// </summary>
         /// <param name="loader">Datafile loader</param>
-        public WeatherParser(DataLoader loader)
+        public WeatherParser(IDataLoader loader)
         {
             this.loader = loader;
         }
@@ -30 +34 @@
         /// Parses weather data to WeatherInfo instances
         /// Data parsed from 7am (included) to 18pm (included)
         /// </summary>
-        /// <param name="folder">Folder with weather data files</param>
+        /// <param name="weatherFiles">Paths to files with weather data files</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <param name="wholeDay">Should data be parsed as one instance per day (if true parameter interval will be ignored)</param>
         /// <param name="interval">Time interval to divide days by, minimum is 1h</param>
         /// <returns></returns>
-        public List<WeatherInfo> ParseWeatherData(string folder, bool wholeDay = true, int interval = 1)
+        public List<WeatherInfo> ParseWeatherData(List<string> weatherFiles, DateTime startTime, DateTime endTime, bool wholeDay = true, int interval = 1)
         {
-            if (!Directory.Exists(folder))
-                return null;
-
             List<WeatherInfo> list = new List<WeatherInfo>();
 
+            if (weatherFiles == null || startTime == null || endTime == null || interval <= 0)
+                return list;
+
             // get all files in folder
-            string[] fileEntries = Directory.GetFiles(folder);
-            foreach (string fileName in fileEntries)
+            foreach (string fileName in weatherFiles)
             {
-                List<WeatherInfo> loadedData = null;
-                
+                if (!File.Exists(fileName))
+                    continue;
+
                 // parse as one instance per day
+                List<WeatherInfo> loadedData = null;
                 if (wholeDay)
-                    loadedData = ProcessOneWeatherFileAsDays(fileName);
+                    loadedData = ProcessOneWeatherFileAsDays(fileName, startTime, endTime);
                 // parse according to interval
                 else
                 {
-                    loadedData = ProcessOneWeatherFileAsIntervals(fileName, interval);
+                    loadedData = ProcessOneWeatherFileAsIntervals(fileName, interval, startTime, endTime);
                 }
 
                 list.AddRange(loadedData);
@@ -66 +73 @@
         /// Parses data from one data file as one instance per day
         /// </summary>
         /// <param name="path">Path ti file</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with WeatherInfo instances</returns>
-        private List<WeatherInfo> ProcessOneWeatherFileAsDays(string path)
+        private List<WeatherInfo> ProcessOneWeatherFileAsDays(string path, DateTime startTime, DateTime endTime)
         {
+            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();
+
             if (!File.Exists(path))
-                return null;
+                return weatherInfo;
 
-            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();
             List<WeatherInstance> list = loader.LoadWeatherFile(path);
 
             // array with data [temp, rain, wind, lum]
@@ -105 +115 @@
                     weatherValues = 0;
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].dateTime < startTime|| list[i].dateTime > endTime)
+                    continue;
+
                 // aggregate data
                 recordedAmount[0] += list[i].temp;
                 recordedAmount[1] += list[i].rain;
@@ -128 +142 @@
         /// </summary>
         /// <param name="path">Path to file</param>
         /// <param name="interval">Interval length</param>
+        /// <param name="endTime">End time of related data</param>
+        /// <param name="startTime">Start time of related data</param>
         /// <returns>List with ActivityInfo instances</returns>
-        private List<WeatherInfo> ProcessOneWeatherFileAsIntervals(string path, int interval)
+        private List<WeatherInfo> ProcessOneWeatherFileAsIntervals(string path, int interval, DateTime startTime, DateTime endTime)
         {
+            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();
+
             if (!File.Exists(path))
-                return null;
+                return weatherInfo;
 
-            List<WeatherInfo> loignInfo = new List<WeatherInfo>();
             List<WeatherInstance> list = loader.LoadWeatherFile(path);
 
             // min/max hour taken into account
@@ -184 +201 @@
 
                         WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                         if (count[k] != 0)
-                            loignInfo.Add(intervalInfo);
+                            weatherInfo.Add(intervalInfo);
 
                     }
 
@@ -194 +211 @@
                         data[l] = new double[4];
                 }
 
+                // if not in allowed time window -> discard
+                if (list[i].dateTime < startTime || list[i].dateTime > endTime)
+                    continue;
+
                 // find index for current instance
                 index = 0;
                 for (int k = 1; k < to.Length; k++)
@@ -228 +249 @@
 
                 WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                 if (count[k] != 0)
-                    loignInfo.Add(intervalInfo);
+                    weatherInfo.Add(intervalInfo);
             }
 
-            return loignInfo;
+            return weatherInfo;
         }
     }
 

Server/ServerApp/Program.cs

@@ -3 +3 @@
 using ServerApp.Parser.Parsers;
 using ServerApp.Predictor;
 using ServerApp.User;
+using ServerApp.WeatherPredictionParser;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -30 +31 @@
         static void Main(string[] args)
         {
 
-			JsonParser p = new JsonParser(null);
-			p.ParsePrediction();
-
-			/*
+			// SETUP FOLDERS
 
 			Config config = FillConfigInfo(args);
 			if (config == null)