SystemConfiguration.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
 
namespace Waher.IoTGateway.Setup
{
    [CollectionName("SystemConfigurations")]
    [ArchivingTime]
    public abstract class SystemConfiguration : ISystemConfiguration
    {
        private TaskCompletionSource<bool> completionSource = null;
        private HttpResource configResource = null;
 
        private Guid objectId = Guid.Empty;
        private DateTime created = DateTime.MinValue;
        private DateTime updated = DateTime.MinValue;
        private DateTime completed = DateTime.MinValue;
        private bool complete = false;
 
        [ObjectId]
        public Guid ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        [DefaultValue(false)]
        public bool Complete
        {
            get => this.complete;
            set => this.complete = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime Created
        {
            get => this.created;
            set => this.created = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime Updated
        {
            get => this.updated;
            set => this.updated = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime Completed
        {
            get => this.completed;
            set => this.completed = value;
        }
 
        public abstract string Resource
        {
            get;
        }
 
        public abstract int Priority
        {
            get;
        }
 
        public abstract Task<string> Title(Language Language);
 
        public abstract Task ConfigureSystem();
 
        public abstract void SetStaticInstance(ISystemConfiguration Configuration);
 
        public virtual Task InitSetup(HttpServer WebServer)
        {
            return Task.CompletedTask;
        }
 
        public virtual Task UnregisterSetup(HttpServer WebServer)
        {
            return Task.CompletedTask;
        }
 
        public virtual Task<bool> SetupConfiguration(HttpServer WebServer)
        {
            this.completionSource = new TaskCompletionSource<bool>();
 
            this.configResource = WebServer.Register("/Settings/ConfigComplete", null, this.ConfigComplete, true, false, true);
 
            return this.completionSource.Task;
        }
 
        public virtual Task CleanupAfterConfiguration(HttpServer WebServer)
        {
            if (!(this.configResource is null))
            {
                WebServer.Unregister(this.configResource);
                this.configResource = null;
            }
 
            return Task.CompletedTask;
        }
 
        protected virtual async Task ConfigComplete(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, new string[] { this.ConfigPrivilege });
 
            await this.MakeCompleted();
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
        }
 
        protected abstract string ConfigPrivilege
        {
            get;
        }
 
        public virtual Task MakeCompleted()
        {
            return this.MakeCompleted(false);
        }
 
        protected async Task MakeCompleted(bool ReloadConfiguration)
        {
            this.complete = true;
            this.completed = DateTime.Now;
            this.updated = DateTime.Now;
 
            if (!ReloadConfiguration)
            {
                if (this.Priority <= 0)
                    await Gateway.InternalDatabase.Update(this);
                else
                    await Database.Update(this);
            }
 
            this.completionSource?.TrySetResult(ReloadConfiguration);
        }
 
        public virtual Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(false);
        }
 
        public abstract Task<bool> EnvironmentConfiguration();
 
        public void LogEnvironmentError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError(null, EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableMissingError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError("Value missing.", EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableInvalidBooleanError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError("Invalid Boolean Value.", EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableInvalidIntegerError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError("Invalid integer Value.", EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableInvalidTimeError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError("Invalid time Value.", EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableInvalidDateError(string EnvironmentVariable, object Value)
        {
            this.LogEnvironmentError("Invalid date Value.", EnvironmentVariable, Value);
        }
 
        public void LogEnvironmentVariableInvalidRangeError(int Min, int Max, string EnvironmentVariable, object Value)
        {
            if (Max == int.MaxValue)
            {
                this.LogEnvironmentError("Value not in valid range. Must be at least " + Min.ToString() + ".",
                    EnvironmentVariable, Value);
            }
            else if (Min == int.MinValue)
            {
                this.LogEnvironmentError("Value not in valid range. Must be at most " + Max.ToString() + ".",
                    EnvironmentVariable, Value);
            }
            else
            {
                this.LogEnvironmentError("Value not in valid range. Must be between " + Min.ToString() + " and " + Max.ToString() + ".",
                    EnvironmentVariable, Value);
            }
        }
 
        public void LogEnvironmentError(string Message, string EnvironmentVariable, object Value)
        {
            if (string.IsNullOrEmpty(Message))
                Message = "Environment Variable contains an invalid value.";
            else
                Message = "Environment Variable contains an invalid value: " + Message;
 
            Log.Error(Message, EnvironmentVariable, string.Empty, "ConfigError",
                new KeyValuePair<string, object>("EnvironmentVariable", EnvironmentVariable),
                new KeyValuePair<string, object>("Value", Value));
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, bool Required, out string Value)
        {
            Value = Environment.GetEnvironmentVariable(VariableName) ?? string.Empty;
            if (!string.IsNullOrEmpty(Value))
                return true;
 
            if (Required)
                this.LogEnvironmentVariableMissingError(VariableName, Value);
 
            return false;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, bool Required, out bool Value)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, Required, out string s))
            {
                Value = default;
                return false;
            }
 
            if (!CommonTypes.TryParse(s, out Value))
            {
                this.LogEnvironmentVariableInvalidBooleanError(VariableName, s);
                return false;
            }
 
            return true;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, out bool Value, bool Default)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, false, out string s))
            {
                Value = Default;
                return true;
            }
 
            if (!CommonTypes.TryParse(s, out Value))
            {
                this.LogEnvironmentVariableInvalidBooleanError(VariableName, s);
                return false;
            }
 
            return true;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, bool Required, out int Value)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, Required, out string s))
            {
                Value = default;
                return false;
            }
 
            if (!int.TryParse(s, out Value))
            {
                this.LogEnvironmentVariableInvalidIntegerError(VariableName, s);
                return false;
            }
 
            return true;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, int Min, int Max, bool Required, ref int Value)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, Required, out int i))
                return false;
 
            if (i < Min || i > Max)
            {
                this.LogEnvironmentVariableInvalidRangeError(Min, Max, VariableName, i);
                return false;
            }
 
            Value = i;
 
            return true;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, bool Required, out TimeSpan? Value)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, Required, out string s))
            {
                Value = default;
                return false;
            }
 
            if (!TimeSpan.TryParse(s, out TimeSpan TS) || TS < TimeSpan.Zero || TS.TotalHours >= 24)
            {
                this.LogEnvironmentVariableInvalidTimeError(VariableName, s);
                Value = default;
                return false;
            }
 
            Value = TS;
            return true;
        }
 
        public bool TryGetEnvironmentVariable(string VariableName, bool Required, out DateTime? Value)
        {
            if (!this.TryGetEnvironmentVariable(VariableName, Required, out string s))
            {
                Value = default;
                return false;
            }
 
            if (!XML.TryParse(s, out DateTime TP) || TP.TimeOfDay != TimeSpan.Zero)
            {
                this.LogEnvironmentVariableInvalidDateError(VariableName, s);
                Value = default;
                return false;
            }
 
            Value = TP;
            return true;
        }
 
        public virtual Task DeferredConfiguration(HttpServer WebServer)
        {
            return Task.CompletedTask;  // No deferred configuration, by default.
        }
    }
}