ExportFormat.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Persistence;
 
namespace Waher.IoTGateway.WebResources.ExportFormats
{
    public abstract class ExportFormat : IExportFormat, IDisposable
    {
        private DateTime lastUpdate = DateTime.Now;
        private readonly DateTime created;
        private FileStream fs;
        private readonly string fileName;
        private readonly bool onlySelectedCollections;
        private readonly Array selectedCollections;
 
        public ExportFormat(string FileName, DateTime Created, FileStream File, bool OnlySelectedCollections, Array SelectedCollections)
        {
            this.fileName = FileName;
            this.created = Created;
            this.fs = File;
            this.onlySelectedCollections = OnlySelectedCollections;
            this.selectedCollections = SelectedCollections;
        }
 
        public string[] CollectionNames
        {
            get
            {
                if (this.onlySelectedCollections)
                {
                    int i, c = this.selectedCollections.Length;
                    string[] Result = new string[c];
 
                    for (i = 0; i < c; i++)
                        Result[i] = this.selectedCollections.GetValue(i).ToString();
 
                    return Result;
                }
                else
                    return null;
            }
        }
 
        public string FileName => this.fileName;
 
        public DateTime Created => this.created;
 
        public virtual void Dispose()
        {
            if (!(this.fs is null))
            {
                if (this.fs.CanWrite)
                    this.fs.Flush();
 
                this.fs.Dispose();
                this.fs = null;
            }
        }
 
        protected bool ExportCollection(string CollectionName)
        {
            return !this.onlySelectedCollections || Array.IndexOf(this.selectedCollections, CollectionName) >= 0;
        }
 
        public abstract Task<bool> Start();
 
        public abstract Task<bool> End();
 
        public abstract Task<bool> StartDatabase(IDatabaseProvider Provider);
 
        public abstract Task<bool> EndDatabase();
 
        public abstract Task<bool> StartLedger(ILedgerProvider Provider);
 
        public abstract Task<bool> EndLedger();
 
        public abstract Task<bool> StartCollection(string CollectionName);
 
        public abstract Task<bool> EndCollection();
 
        public abstract Task<bool> StartIndex();
 
        public abstract Task<bool> EndIndex();
 
        public abstract Task<bool> ReportIndexField(string FieldName, bool Ascending);
 
        public abstract Task<bool> StartBlock(string BlockID);
 
        public abstract Task<bool> EndBlock();
 
        public abstract Task<bool> BlockMetaData(string Key, object Value);
 
        public abstract Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp);
 
        public abstract Task<bool> EndEntry();
 
        public virtual async Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            return
                await this.StartEntry(string.Empty, string.Empty, EntryType.Clear, EntryTimestamp) &&
                await this.EndEntry();
        }
 
        public abstract Task<string> StartObject(string ObjectId, string TypeName);
 
        public abstract Task<bool> EndObject();
 
        public abstract Task<bool> ReportProperty(string PropertyName, object PropertyValue);
 
        public abstract Task<bool> ReportError(string Message);
 
        public abstract Task<bool> ReportException(Exception Exception);
 
        public abstract Task<bool> StartFiles();
 
        public abstract Task<bool> EndFiles();
 
        public abstract Task<bool> ExportFile(string FileName, Stream File);
 
        public Task<bool> UpdateClient(bool ForceUpdate)
        {
            DateTime TP = DateTime.Now;
 
            if (ForceUpdate || (TP - this.lastUpdate).TotalSeconds >= 1)
            {
                this.lastUpdate = TP;
                UpdateClientsFileUpdated(this.fileName, this.fs.Length, this.created);
            }
 
            return Task.FromResult(true);
        }
 
        public static void UpdateClientsFileUpdated(string FileName, long Length, DateTime Created)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append("{\"fileName\":\"");
            sb.Append(CommonTypes.JsonStringEncode(FileName));
            sb.Append("\", \"size\": \"");
            if (Length >= 0)
                sb.Append(CommonTypes.JsonStringEncode(Export.FormatBytes(Length)));
            sb.Append("\", \"created\": \"");
            sb.Append(CommonTypes.JsonStringEncode(Created.ToString()));
            sb.Append("\", \"button\": \"");
            sb.Append(CommonTypes.JsonStringEncode("<button class=\"negButtonSm\" onclick=\"DeleteExport('" + FileName + "');\">Delete</button>"));
            sb.Append("\", \"isKey\": ");
            sb.Append(FileName.EndsWith(".key", StringComparison.CurrentCultureIgnoreCase) ? "true" : "false");
            sb.Append("}");
 
            string[] TabIDs = ClientEvents.GetTabIDsForLocation("/Settings/Backup.md");
 
            Task _ = ClientEvents.PushEvent(TabIDs, "UpdateExport", sb.ToString(), true, "User");
        }
 
        public static void UpdateClientsFileDeleted(string FileName)
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append("{\"fileName\":\"");
            sb.Append(CommonTypes.JsonStringEncode(FileName));
            sb.Append("\"}");
 
            string[] TabIDs = ClientEvents.GetTabIDsForLocation("/Settings/Backup.md");
 
            Task _ = ClientEvents.PushEvent(TabIDs, "FileDeleted", sb.ToString(), true, "User");
        }
    }
}