DomainSettings.cs

using System;
using System.IO;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.Runtime.IO;
using Waher.Runtime.Settings;
 
namespace Waher.IoTGateway
{
    public static class DomainSettings
    {
        #region Getting settings
 
        public static Task<string> GetSettingAsync(IHostReference HostRef, string Key, string DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<string> GetSettingAsync(string Host, string Key, string DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<long> GetSettingAsync(IHostReference HostRef, string Key, long DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<long> GetSettingAsync(string Host, string Key, long DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<double> GetSettingAsync(IHostReference HostRef, string Key, double DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<double> GetSettingAsync(string Host, string Key, double DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<DateTime> GetSettingAsync(IHostReference HostRef, string Key, DateTime DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<DateTime> GetSettingAsync(string Host, string Key, DateTime DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<TimeSpan> GetSettingAsync(IHostReference HostRef, string Key, TimeSpan DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<TimeSpan> GetSettingAsync(string Host, string Key, TimeSpan DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<Enum> GetSettingAsync(IHostReference HostRef, string Key, Enum DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<Enum> GetSettingAsync(string Host, string Key, Enum DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<bool> GetSettingAsync(IHostReference HostRef, string Key, bool DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<bool> GetSettingAsync(string Host, string Key, bool DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        public static Task<object> GetSettingAsync(IHostReference HostRef, string Key, object DefaultValue)
        {
            return GetSettingAsync(HostRef.Host, Key, DefaultValue);
        }
 
        public static async Task<object> GetSettingAsync(string Host, string Key, object DefaultValue)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.GetAsync(Host, Key, DefaultValue);
            else
                return await RuntimeSettings.GetAsync(Key, DefaultValue);
        }
 
        internal static string IsAlternativeDomain(string Host)
        {
            if (string.IsNullOrEmpty(Host))
                return null;
 
            Host = Host.RemovePortNumber();
 
            if (Gateway.IsDomain(Host, true) && !Gateway.IsDomain(Host, false))
                return Host;
            else
                return null;
        }
 
        #endregion
 
        #region Setting settings
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, string Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, string Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, long Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, long Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, double Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, double Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, DateTime Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, DateTime Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, TimeSpan Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, TimeSpan Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, Enum Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, Enum Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, bool Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, bool Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        public static Task<bool> SetSettingAsync(IHostReference HostRef, string Key, object Value)
        {
            return SetSettingAsync(HostRef.Host, Key, Value);
        }
 
        public static async Task<bool> SetSettingAsync(string Host, string Key, object Value)
        {
            Host = IsAlternativeDomain(Host);
 
            if (!string.IsNullOrEmpty(Host))
                return await HostSettings.SetAsync(Host, Key, Value);
            else
                return await RuntimeSettings.SetAsync(Key, Value);
        }
 
        #endregion
 
        #region Getting file-based settings
 
        public static Task<string> GetTextFileSettingAsync(IHostReference HostRef, string FileName)
        {
            return GetTextFileSettingAsync(HostRef.Host, FileName);
        }
 
        public static async Task<string> GetTextFileSettingAsync(string Host, string FileName)
        {
            Host = IsAlternativeDomain(Host);
 
            string Content;
 
            if (!string.IsNullOrEmpty(Host))
                Content = await HostSettings.GetAsync(Host, FileName, string.Empty);
            else
                Content = await RuntimeSettings.GetAsync(FileName, string.Empty);
 
            if (!string.IsNullOrEmpty(Content))
                return Content;
 
            return await Files.ReadAllTextAsync(FileName);
        }
 
        public static Task<byte[]> GetBinaryFileSettingAsync(IHostReference HostRef, string FileName)
        {
            return GetBinaryFileSettingAsync(HostRef.Host, FileName);
        }
 
        public static async Task<byte[]> GetBinaryFileSettingAsync(string Host, string FileName)
        {
            Host = IsAlternativeDomain(Host);
 
            string Content;
 
            if (!string.IsNullOrEmpty(Host))
                Content = await HostSettings.GetAsync(Host, FileName, string.Empty);
            else
                Content = await RuntimeSettings.GetAsync(FileName, string.Empty);
 
            if (!string.IsNullOrEmpty(Content))
            {
                try
                {
                    return Convert.FromBase64String(Content);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            }
 
            return await Runtime.IO.Files.ReadAllBytesAsync(FileName);
        }
 
        public static Task<DateTime> GetFileSettingTimestampAsync(IHostReference HostRef, string FileName)
        {
            return GetFileSettingTimestampAsync(HostRef.Host, FileName);
        }
 
        public static async Task<DateTime> GetFileSettingTimestampAsync(string Host, string FileName)
        {
            Host = IsAlternativeDomain(Host);
 
            DateTime Timestamp;
 
            if (!string.IsNullOrEmpty(Host))
                Timestamp = await HostSettings.GetAsync(Host, FileName, DateTime.MinValue);
            else
                Timestamp = await RuntimeSettings.GetAsync(FileName, DateTime.MinValue);
 
            if (Timestamp == DateTime.MinValue)
                return File.GetLastWriteTimeUtc(FileName);
            else
                return Timestamp;
        }
 
        #endregion
    }
}