BeWoPlaner/Shared/Core/UserSettingsUtils.cs

using System;
using System.Collections.Generic;
using System.Linq;
using BS.Shared.DataContracts;

namespace BS.Shared.Core
{
    public class UserSettingsUtils
    {
        public static string CreateNewSettingValue(string settings, string key, string val)
        {
            if(string.IsNullOrEmpty(settings))
            {
                return key + "=" + val;
            }

            var keyValuePairs = settings.Split(';');
            var newValue = string.Empty;

            foreach(var pair in keyValuePairs)
            {
                if(pair.IndexOf(key + "=") != 0)
                {
                    if(newValue.Length > 0)
                    {
                        newValue += ";";
                    }

                    newValue += pair;
                }
            }

            if(newValue.Length > 0)
            {
                newValue += ";";
            }

            newValue += key + "=" + val;

            return newValue;
        }

        public static string GetSettingValue(string settings, string key)
        {
            if(!string.IsNullOrEmpty(settings))
            {
                if(settings.IndexOf(";") == -1 && settings.IndexOf("=") == -1)
                {
                    return settings;
                }

                var keyValuePairs = settings.Split(';');

                return (from pair in keyValuePairs select pair.Split('=') into keyValuePair where keyValuePair.Length == 2 where keyValuePair[0] == key select keyValuePair[1]).FirstOrDefault();
            }

            return null;
        }

        public static SettingsDC GetSettingValue(SettingsType pType, List<SettingsDC> pSettings)
        {
            return pSettings?.FirstOrDefault(s => s.Type == pType);
        }

        public static string GetSettingValue(SettingsType pType, string key, List<SettingsDC> pSettings)
        {
            var dc = GetSettingValue(pType, pSettings);

            return dc != null ? GetSettingValue(dc.Value, key) : null;
        }

        public static void SetSettingValue(SettingsType pType, string key, string val, List<SettingsDC> pSettings)
        {
            var dc = GetSettingValue(pType, pSettings);

            if(dc == null)
            {
                var newDc = new SettingsDC { Type = pType, Value = CreateNewSettingValue(string.Empty, key, val) };
                pSettings.Add(newDc);
            }
            else
            {
                dc.Value = CreateNewSettingValue(dc.Value, key, val);
            }
        }

        public static bool GetSettingValueAsBool(string settings, string key)
        {
            var stringValue = GetSettingValue(settings, key);

            return "1" == stringValue;
        }

        public static int GetSettingValueAsInteger(string settings, string key, int defaultResult = 0)
        {
            var stringValue = GetSettingValue(settings, key);

            var didParse = int.TryParse(stringValue, out var result);

            return didParse ? result : defaultResult;
        }

        public static double GetSettingValueAsDouble(string settings, string key, double defaultResult = 0d)
        {
            var stringValue = GetSettingValue(settings, key);

            var didParse = double.TryParse(stringValue, out var result);

            return didParse ? result : defaultResult;
        }

        public static long GetSettingValueAsLong(string settings, string key, long defaultResult = 0L)
        {
            var stringValue = GetSettingValue(settings, key);

            var didParse = long.TryParse(stringValue, out var result);

            return didParse ? result : defaultResult;
        }

        public static DateTime? GetSettingValueAsDateTime(string settings, string key)
        {
            var stringValue = GetSettingValue(settings, key);

            if(DateTime.TryParse(stringValue, out var result))
            {
                return result;
            }

            return null;
        }

        /// <summary>
        /// Konvertiert einen Settingswert in einen Enum. Der Settings-Value ist ein String, der einen Integer-Wert darstellt.
        /// </summary>
        /// <typeparam name="T">Enum in den konvertiert werden soll</typeparam>
        /// <param name="settings">User- oder MandatorSettings</param>
        /// <param name="key">Key des Wertes</param>
        /// <param name="defaultResult">Standardwert, falls die Konversion fehlschlägt</param>
        /// <returns></returns>
        public static T GetSettingValueAsEnum<T>(string settings, string key, T defaultResult) where T : struct, Enum
        {
            var stringValue = GetSettingValue(settings, key);

            var didParse = Enum.TryParse(stringValue, out T result);

            var isDefined = Enum.IsDefined(typeof(T), result);

            return didParse && isDefined ? result : defaultResult;
        }

        public static void SetDefaultFlsConfigSetting(FLSAnalysisConfigDC config, List<SettingsDC> settings)
        {
            if (config != null)
            {
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "StartDate", config.StartDate.HasValue ? String.Format("{0:dd.MM.yyyy}", config.StartDate) : "", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "EndDate", config.EndDate.HasValue ? String.Format("{0:dd.MM.yyyy}", config.EndDate) : "", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowChart", config.ShowChart ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowServiceRecords", config.ShowServiceRecords ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyTotalRows", config.ShowOnlyTotalRows ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyMarker", config.ShowOnlyMarker ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowEinheitInMinuten", config.ShowEinheitInMinuten ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyDeleted", config.ShowOnlyDeleted ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowArchivedEmployees", config.ShouldAnalyzeArchivedEmployees ? "1" : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "DateInterval", config.DateInterval.HasValue ? config.DateInterval.Value.ToString() : "", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ReportType", ((int)config.ReportType).ToString(), settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "EmployeeOid", config.EmployeeOid.HasValue ? config.EmployeeOid.Value.ToString() : "0", settings);
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "CustomerOid", config.CustomerOid.HasValue ? config.CustomerOid.Value.ToString() : "0", settings);

                if (config.ServiceDescriptionOids == null)
                {
                    config.ServiceDescriptionOids = new List<long>();
                }
                SetSettingValue(SettingsType.FlsDefaultFilterSettings, "ServiceDescriptionOids", String.Join(",", config.ServiceDescriptionOids), settings);

            }
        }

        public static FLSAnalysisConfigDC GetDefaultFlsConfigSetting(List<SettingsDC> settings, long loggedInEmployeeOid)
        {
            var config = CreateDefaultConfig();
            config.EmployeeOid = loggedInEmployeeOid;

            var val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "StartDate", settings);

            if (val != null && DateTime.TryParse(val, out var sdt))
            {
                config.StartDate = sdt;
            }
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "EndDate", settings);
            if (val != null && DateTime.TryParse(val, out var edt))
            {
                config.EndDate = edt;
            }
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowChart", settings);
            config.ShowChart = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowServiceRecords", settings);
            config.ShowServiceRecords = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyTotalRows", settings);
            config.ShowOnlyTotalRows = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyMarker", settings);
            config.ShowOnlyMarker = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowEinheitInMinuten", settings);
            config.ShowEinheitInMinuten = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowOnlyDeleted", settings);
            config.ShowOnlyDeleted = "1".Equals(val);

            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ShowArchivedEmployees", settings);
            config.ShouldAnalyzeArchivedEmployees = "1".Equals(val);
            
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "DateInterval", settings);
            if (val != null && Int32.TryParse(val, out var di))
            {
                config.DateInterval = di;
            }
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ReportType", settings);
            if (val != null && Int32.TryParse(val, out var rt))
            {
                config.ReportType = (FLSReportType)rt;
            }
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "EmployeeOid", settings);
            if (val != null && Int64.TryParse(val, out var eoid))
            {
                config.EmployeeOid = eoid;
                if (eoid == 0)
                {
                    config.EmployeeOid = null;
                }
            }
            
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "CustomerOid", settings);
            if (val != null && Int64.TryParse(val, out var coid))
            {
                config.CustomerOid = coid;
                if (coid == 0)
                {
                    config.CustomerOid = null;
                }
            }
            val = GetSettingValue(SettingsType.FlsDefaultFilterSettings, "ServiceDescriptionOids", settings);
            if (val != null)
            {
                config.ServiceDescriptionOids = val.Split(',').Select(s => s.Trim()).Where(s => long.TryParse(s, out _)).Select(long.Parse).ToList();
            }

            return config;
        
        }

        private static FLSAnalysisConfigDC CreateDefaultConfig()
        {
            var config = new FLSAnalysisConfigDC();

            var startDate = DateTime.Now.AddMonths(-1);

            config.StartDate = new DateTime(startDate.Year, startDate.Month, 1);
            config.EndDate = DateTime.Now;

            config.ShowChart = false;
            config.ShowServiceRecords = false;
            config.ShowOnlyTotalRows = false;
            config.ShowOnlyMarker = false;
            config.ShowEinheitInMinuten = false;
            config.ShowOnlyDeleted = false;
            config.DateInterval = 4; // Woche, enum DateInterval in FLSOverviewGenerator.cs
            config.ReportType = FLSReportType.Employee;
            

            return config;
        }
    }
}