aswi2021tri-musketyri-gitlab/Server/ServerApp/Parser/Parsers/JisParser.cs @ master

//
// Author: A. Konig
//

using System;
using System.Collections.Generic;
using System.IO;
using log4net;
using ServerApp.Parser.InputData;
using ServerApp.Parser.OutputInfo;

namespace ServerApp.Parser.Parsers
{
    /// <summary>
    /// Class parsing jis files into instances of ActivityInfo divided by given time interval
    /// Data parsed from 7am (included) to 18pm (included)
    /// </summary>
    /// <author>A. Konig</author>
    public class JisParser
    {
        /// <summary> Logger </summary>
        private static readonly ILog _log = LogManager.GetLogger(typeof(JisParser));

        /// <summary> Datafile loader  </summary>
        IDataLoader loader;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="loader">Datafile loader</param>
        public JisParser(IDataLoader loader)
        {
            this.loader = loader;
        }

        /// <summary>
        /// Parses jis data to ActivityInfo instances
        /// Data parsed from 7am (included) to 18pm (included)
        /// </summary>
        /// <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(List<string> jisFiles, DateTime startTime, DateTime endTime, bool wholeDay = true, int interval = 1)
        {
            List<ActivityInfo> list = new List<ActivityInfo>();

            if (jisFiles == null || interval <= 0)
                return list;

            string current = "";
            try
            {
                // parse all files
                foreach (string fileName in jisFiles)
                {
                    current = fileName;

                    if (!File.Exists(fileName))
                        continue;

                    // parse as one instance per day
                    List<ActivityInfo> loadedData = null;
                    if (wholeDay)
                        loadedData = ProcessOneJisFileAsDays(fileName, startTime, endTime);
                    // parse by interval length
                    else
                        loadedData = ProcessOneJisFileAsIntervals(fileName, interval, startTime, endTime);

                    list.AddRange(loadedData);
                }
            }
            catch
            {
                _log.Error("Incorrect jis input file " + current);
            }

            return list;
        }

        /// <summary>
        /// Parses data from one data file as one instance per day
        /// </summary>
        /// <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, DateTime startTime, DateTime endTime)
        {
            List<ActivityInfo> jisInfo = new List<ActivityInfo>();
            
            List<JisInstance> list =  loader.LoadJisFile(path);
            if (list == null || list.Count == 0)
                return jisInfo;

            // data for each faculty
            int[] recordedAmount = new int[TagInfo.buildings.Length];
            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            // interval length
            int range = minmaxHour[1] - minmaxHour[0];

            // first day
            DateTime lastStartTime = new DateTime(list[0].dateTime.Year, list[0].dateTime.Month, list[0].dateTime.Day, minmaxHour[0], 0, 0);
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].dateTime.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of the day -> make an instance
                string place = list[i].placeTag;
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, minmaxHour[0], 0, 0);
                if (!date.Equals(lastStartTime)) 
                {
                    // data for each faculty separate
                    for (int k = 0; k < TagInfo.buildings.Length; k++)
                    {
                        ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[k], recordedAmount[k], lastStartTime, range);
                        if (recordedAmount[k] != 0)
                            jisInfo.Add(dayInfo);
                    }

                    recordedAmount = new int[TagInfo.buildings.Length];
                    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))
                {
                    int index = TagInfo.jisPlaces[place];
                    if (index == -1)
                        for (int l = 0; l < TagInfo.buildings.Length; l++)
                            recordedAmount[l] += list[i].amount;
                    else
                        recordedAmount[index] += list[i].amount;

                }
                else
                {
                    _log.Warn("Unknown code " + list[i].placeTag);
                }

            }

            // last day
            for (int k = 0; k < TagInfo.buildings.Length; k++)
            {
                ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[k], recordedAmount[k], lastStartTime, range);
                if (recordedAmount[k] != 0)
                    jisInfo.Add(dayInfo);
            }

            return jisInfo;
        }

        /// <summary>
        /// Parses data from one data file as instance per interval length in a day
        /// </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, DateTime startTime, DateTime endTime)
        {
            List<ActivityInfo> jisInfo = new List<ActivityInfo>();

            List<JisInstance> list = loader.LoadJisFile(path);
            if (list == null || list.Count == 0)
                return jisInfo;

            // data for each faculty
            int[] recordedAmount = new int[TagInfo.buildings.Length];
            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            int range = minmaxHour[1] - minmaxHour[0];

            if (interval > range)
                return null;

            int indices = (int) Math.Ceiling(range / (double)interval);
            int[] to = new int[indices];
            for (int i = 0; i < to.Length; i++) 
                to[i] = minmaxHour[0] + interval * (i+1);

            // 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 startingTime = minmaxHour[0];
            int index = 0;
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].dateTime.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of the day -> make an instance
                string place = list[i].placeTag;
                bool trigger = false;
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, list[i].dateTime.Hour, 0, 0);

                // end of the day
                if (!(date.Year == lastStartTime.Year && date.Month == lastStartTime.Month && date.Day == lastStartTime.Day))
                {
                    trigger = true;
                    index = 0;
                }

                // end of interval period
                if ( date.Hour >= endtime || trigger) 
                {
                    // start time of last interval
                    DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, startingTime, 0, 0);

                    // find end and start time
                    if (!trigger)
                        index++;
                    while (date.Hour >= to[index])
                        index++;

                    endtime = to[index];
                    if (index == 0)
                        startingTime = minmaxHour[0];
                    else
                        startingTime = to[index - 1];

                    // data for each faculty separate
                    for (int k = 0; k < TagInfo.buildings.Length; k++)
                    {
                        ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[k], recordedAmount[k], stTime, interval);
                        if (recordedAmount[k] != 0)
                            jisInfo.Add(dayInfo);
                    }

                    recordedAmount = new int[TagInfo.buildings.Length];
                    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))
                {
                    int faculty = TagInfo.jisPlaces[place];
                    if (faculty == -1)
                        for (int l = 0; l < TagInfo.buildings.Length; l++)
                            recordedAmount[l] += list[i].amount;
                    else
                        recordedAmount[faculty] += list[i].amount;

                }
                else
                {
                    _log.Warn("Unknown code " + list[i].placeTag);
                }

            }

            // last day
            DateTime startT = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, startingTime, 0, 0);
            for (int k = 0; k < TagInfo.buildings.Length; k++)
            {
                ActivityInfo dayInfo = new ActivityInfo(TagInfo.buildings[k], recordedAmount[k], startT, interval);
                if (recordedAmount[k] != 0)
                    jisInfo.Add(dayInfo);
            }

            return jisInfo;
        }
    }
}