Export.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway.Setup;
using Waher.IoTGateway.WebResources.ExportFormats;
using Waher.Networking;
using Waher.Runtime.Settings;
 
namespace Waher.IoTGateway
{
    public static class Export
    {
        public static async Task<string> GetFullExportFolderAsync()
        {
            string Path = await GetExportFolderAsync();
 
            if (string.IsNullOrEmpty(Path))
                Path = System.IO.Path.Combine(Gateway.AppDataFolder, "Backup");
 
            return Path;
        }
 
        public static async Task<string> GetFullKeyExportFolderAsync()
        {
            string Path = await GetExportKeyFolderAsync();
 
            if (string.IsNullOrEmpty(Path))
                Path = System.IO.Path.Combine(Gateway.AppDataFolder, "Backup");
 
            return Path;
        }
 
        public static async Task<FileInformation[]> GetExportFilesAsync()
        {
            SortedDictionary<DateTime, FileInformation> Sorted = new SortedDictionary<DateTime, FileInformation>(new ReverseDateTimeOrder());
            string Path = await GetFullExportFolderAsync();
            if (Directory.Exists(Path))
                GetFiles(Path, Sorted);
 
            string Path2 = await GetFullKeyExportFolderAsync();
            if (Path != Path2 && Directory.Exists(Path2))
                GetFiles(Path2, Sorted);
 
            FileInformation[] Result = new FileInformation[Sorted.Count];
            Sorted.Values.CopyTo(Result, 0);
 
            return Result;
        }
 
        private static void GetFiles(string Path, SortedDictionary<DateTime, FileInformation> Sorted)
        {
            string[] Files = Directory.GetFiles(Path, "*.*", SearchOption.TopDirectoryOnly);
            int i, c = Files.Length;
            DateTime Created;
            long Size;
            string SizeStr;
            string s;
 
            Path += System.IO.Path.DirectorySeparatorChar;
 
            for (i = 0; i < c; i++)
            {
                s = Files[i];
 
                try
                {
                    using (FileStream fs = File.OpenRead(s))
                    {
                        Size = fs.Length;
                        SizeStr = FormatBytes(Size);
                    }
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                    Size = 0;
                    SizeStr = string.Empty;
                }
 
                Created = File.GetCreationTime(s);
 
                if (s.StartsWith(Path))
                    s = s.Substring(Path.Length);
 
                while (Sorted.ContainsKey(Created))
                    Created = Created.AddTicks(1);
 
                Sorted[Created] = new FileInformation(s, Created, Size, SizeStr);
            }
        }
 
        private class ReverseDateTimeOrder : IComparer<DateTime>
        {
            public ReverseDateTimeOrder()
            {
            }
 
            public int Compare(DateTime x, DateTime y)
            {
                return y.CompareTo(x);
            }
        }
 
        public static string FormatBytes(double Bytes)
        {
            int i = 0;
 
            while (Bytes >= 1024 && i < 4)
            {
                Bytes /= 1024;
                i++;
            }
 
            if (i == 0)
                return Bytes.ToString("F0") + " " + ByteUnits[i];
            else
                return Bytes.ToString("F2") + " " + ByteUnits[i];
        }
 
        private static readonly string[] ByteUnits = { "B", "kB", "MB", "GB", "TB" };
 
        public static async Task<string> GetExportFolderAsync()
        {
            if (exportFolderValue is null)
                exportFolderValue = await RuntimeSettings.GetAsync("ExportFolder", string.Empty);
 
            return exportFolderValue;
        }
 
        public static async Task SetExportFolderAsync(string Value)
        {
            if (exportFolderValue != Value)
            {
                exportFolderValue = Value;
                await RuntimeSettings.SetAsync("ExportFolder", exportFolderValue);
 
                if (!(BackupConfiguration.Instance is null))
                    await BackupConfiguration.Instance.UpdateExportFolder(await GetFullExportFolderAsync());
 
                await OnExportFolderUpdated.Raise(BackupConfiguration.Instance, EventArgs.Empty);
            }
        }
 
        private static string exportFolderValue = null;
 
        public static event EventHandlerAsync OnExportFolderUpdated;
 
        public static async Task<string> GetExportKeyFolderAsync()
        {
            if (exportKeyFolderValue is null)
                exportKeyFolderValue = await RuntimeSettings.GetAsync("ExportKeyFolder", string.Empty);
 
            return exportKeyFolderValue;
        }
 
        public static async Task SetExportKeyFolderAsync(string Value)
        {
            if (exportKeyFolderValue != Value)
            {
                exportKeyFolderValue = Value;
                await RuntimeSettings.SetAsync("ExportKeyFolder", exportKeyFolderValue);
 
                BackupConfiguration.Instance?.UpdateExportKeyFolder(await GetFullKeyExportFolderAsync());
 
                await OnExportKeyFolderUpdated.Raise(BackupConfiguration.Instance, EventArgs.Empty);
            }
        }
 
        private static string exportKeyFolderValue = null;
 
        public static event EventHandlerAsync OnExportKeyFolderUpdated;
 
        public static bool ExportDatabase
        {
            get
            {
                if (!exportDatabase.HasValue)
                    exportDatabase = RuntimeSettings.Get("ExportDatabase", true);
 
                return exportDatabase.Value;
            }
 
            set
            {
                if (exportDatabase != value)
                {
                    exportDatabase = value;
                    RuntimeSettings.Set("ExportDatabase", exportDatabase.Value);
                }
            }
        }
 
        private static bool? exportDatabase = null;
 
        public static bool ExportLedger
        {
            get
            {
                if (!exportLedger.HasValue)
                    exportLedger = RuntimeSettings.Get("ExportLedger", false);
 
                return exportLedger.Value;
            }
 
            set
            {
                if (exportLedger != value)
                {
                    exportLedger = value;
                    RuntimeSettings.Set("ExportLedger", exportLedger.Value);
                }
            }
        }
 
        private static bool? exportLedger = null;
 
        public static bool ExportWebContent
        {
            get
            {
                if (!exportWebContent.HasValue)
                    exportWebContent = RuntimeSettings.Get("ExportWebContent", false);
 
                return exportWebContent.Value;
            }
 
            set
            {
                if (exportWebContent != value)
                {
                    exportWebContent = value;
                    RuntimeSettings.Set("ExportWebContent", exportWebContent.Value);
                }
            }
        }
 
        private static bool? exportWebContent = null;
 
        public static async Task<bool> GetExportFolderAsync(string FolderName)
        {
            string Key = "Export." + FolderName;
            bool Result;
 
            lock (exportFolder)
            {
                if (exportFolder.TryGetValue(Key, out Result))
                    return Result;
            }
 
            Result = await RuntimeSettings.GetAsync(Key, true);
 
            lock (exportFolder)
            {
                exportFolder[Key] = Result;
            }
 
            return Result;
        }
 
        public static async Task SetExportFolderAsync(string FolderName, bool Export)
        {
            string Key = "Export." + FolderName;
 
            lock (exportFolder)
            {
                if (exportFolder.TryGetValue(Key, out bool b) && b == Export)
                    return;
 
                exportFolder[Key] = Export;
            }
 
            await RuntimeSettings.SetAsync(Key, Export);
        }
 
        private static readonly Dictionary<string, bool> exportFolder = new Dictionary<string, bool>();
 
        public static string ExportType
        {
            get
            {
                if (exportType is null)
                    exportType = RuntimeSettings.Get("ExportType", "Encrypted");
 
                return exportType;
            }
 
            set
            {
                if (exportType != value)
                {
                    exportType = value;
                    RuntimeSettings.Set("ExportType", exportType);
                }
            }
        }
 
        private static string exportType = null;
 
        public static async Task SetAutomaticBackupsAsync(bool Value)
        {
            if (automaticBackups != Value)
            {
                automaticBackups = Value;
                await RuntimeSettings.SetAsync("AutomaticBackups", automaticBackups.Value);
            }
        }
 
        public static async Task<bool> GetAutomaticBackupsAsync()
        {
            if (!automaticBackups.HasValue)
                automaticBackups = await RuntimeSettings.GetAsync("AutomaticBackups", true);
 
            return automaticBackups.Value;
        }
 
        private static bool? automaticBackups = null;
 
        public static async Task SetKeepDaysAsync(long Value)
        {
            if (backupKeepDays != Value)
            {
                backupKeepDays = Value;
                await RuntimeSettings.SetAsync("BackupKeepDays", backupKeepDays.Value);
            }
        }
 
        public static async Task<long> GetKeepDaysAsync()
        {
            if (!backupKeepDays.HasValue)
                backupKeepDays = await RuntimeSettings.GetAsync("BackupKeepDays", 3);
 
            return backupKeepDays.Value;
        }
 
        private static long? backupKeepDays = null;
 
        public static async Task SetKeepMonthsAsync(long Value)
        {
            if (backupKeepMonths != Value)
            {
                backupKeepMonths = Value;
                await RuntimeSettings.SetAsync("BackupKeepMonths", backupKeepMonths.Value);
            }
        }
 
        public static async Task<long> GetKeepMonthsAsync()
        {
            if (!backupKeepMonths.HasValue)
                backupKeepMonths = await RuntimeSettings.GetAsync("BackupKeepMonths", 3);
 
            return backupKeepMonths.Value;
        }
 
        private static long? backupKeepMonths = null;
 
        public static async Task SetKeepYearsAsync(long Value)
        {
            if (backupKeepYears != Value)
            {
                backupKeepYears = Value;
                await RuntimeSettings.SetAsync("BackupKeepYears", backupKeepYears.Value);
            }
        }
 
        public static async Task<long> GetKeepYearsAsync()
        {
            if (!backupKeepYears.HasValue)
                backupKeepYears = await RuntimeSettings.GetAsync("BackupKeepYears", 3);
 
            return backupKeepYears.Value;
        }
 
        private static long? backupKeepYears = null;
 
        public static async Task SetBackupTimeAsync(TimeSpan Value)
        {
            if (backupTime != Value)
            {
                backupTime = Value;
                await RuntimeSettings.SetAsync("BackupTime", backupTime.Value);
            }
        }
 
        public static async Task<TimeSpan> GetBackupTimeAsync()
        {
            if (!backupTime.HasValue)
                backupTime = await RuntimeSettings.GetAsync("BackupTime", TimeSpan.FromHours(5));
 
            return backupTime.Value;
        }
 
        private static TimeSpan? backupTime = null;
 
        public static async Task<DateTime> GetLastBackupAsync()
        {
            if (!lastBackup.HasValue)
                lastBackup = await RuntimeSettings.GetAsync("LastBackup", DateTime.MinValue);
 
            return lastBackup.Value;
        }
 
        public static async Task SetLastBackupAsync(DateTime Value)
        {
            if (lastBackup != Value)
            {
                lastBackup = Value;
                await RuntimeSettings.SetAsync("LastBackup", Value);
            }
        }
 
        private static DateTime? lastBackup = null;
 
        public static void RegisterFolders(string CategoryId, string DisplayName, params string[] Folders)
        {
            lock (folders)
            {
                if (folders.ContainsKey(CategoryId))
                    throw new ArgumentException("Category ID already registered.", nameof(CategoryId));
 
                folders[DisplayName] = new FolderCategory()
                {
                    CategoryId = CategoryId,
                    DisplayName = DisplayName,
                    Folders = Folders
                };
            }
        }
 
        public static FolderCategory[] GetRegisteredFolders()
        {
            FolderCategory[] Result;
 
            lock (folders)
            {
                Result = new FolderCategory[folders.Count];
                folders.Values.CopyTo(Result, 0);
            }
 
            return Result;
        }
 
        public class FolderCategory
        {
            public string CategoryId;
 
            public string DisplayName;
 
            public string[] Folders;
        }
 
        private static readonly Dictionary<string, FolderCategory> folders = new Dictionary<string, FolderCategory>();
 
        public static async Task<string[]> GetBackupHostsAsync()
        {
            if (backupHosts is null)
                backupHosts = StringToArray(await RuntimeSettings.GetAsync("BackupHosts", string.Empty));
 
            return backupHosts;
        }
 
        public static async Task SetBackupHostsAsync(string[] Value)
        {
            if (backupHosts != Value)
            {
                backupHosts = Value;
                await RuntimeSettings.SetAsync("BackupHosts", ArrayToString(backupHosts));
            }
        }
 
        private static string[] backupHosts = null;
 
        public static async Task<string[]> GetKeyHostsAsync()
        {
            if (keyHosts is null)
                keyHosts = StringToArray(await RuntimeSettings.GetAsync("KeyHosts", string.Empty));
 
            return keyHosts;
        }
 
        public static async Task SetKeyHostsAsync(string[] Value)
        {
            if (keyHosts != Value)
            {
                keyHosts = Value;
                await RuntimeSettings.SetAsync("KeyHosts", ArrayToString(keyHosts));
            }
        }
 
        private static string[] keyHosts = null;
 
        private static string[] StringToArray(string s)
        {
            return s.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
        }
 
        private static string ArrayToString(string[] Items)
        {
            StringBuilder Result = new StringBuilder();
            bool First = true;
 
            foreach (string Item in Items)
            {
                if (First)
                    First = false;
                else
                    Result.AppendLine();
 
                Result.Append(Item);
            }
 
            return Result.ToString();
        }
    }
}