ValidateBackupFile.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.IoTGateway.WebResources.ExportFormats;
using Waher.Persistence;
using Waher.Security;
 
namespace Waher.IoTGateway.Setup
{
    public class ValidateBackupFile : IExportFormat
    {
        protected List<string> index = new List<string>();
 
        protected string collectionName = null;
 
        protected string objectId = null;
 
        protected string typeName = null;
 
        protected readonly Dictionary<string, string> objectIdMap;
 
        protected readonly bool mapObjectIds;
 
        private readonly string fileName;
        private readonly int objectIdByteCount;
        private long nrCollections = 0;
        private long nrIndices = 0;
        private long nrBlocks = 0;
        private long nrObjects = 0;
        private long nrEntries = 0;
        private long nrProperties = 0;
        private long nrFiles = 0;
        private long nrFileBytes = 0;
 
        public ValidateBackupFile(string FileName, Dictionary<string, string> ObjectIdMap)
        {
            this.fileName = FileName;
 
            if ((this.objectIdByteCount = Database.Provider.ObjectIdByteCount) < 16)
            {
                this.objectIdMap = ObjectIdMap ?? new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
                this.mapObjectIds = true;
            }
            else
            {
                this.objectIdMap = null;
                this.mapObjectIds = false;
            }
        }
 
        public string FileName => this.fileName;
 
        public long NrCollections => this.nrCollections;
 
        public long NrIndices => this.nrIndices;
 
        public long NrBlocks => this.nrBlocks;
 
        public long NrObjects => this.nrObjects;
 
        public long NrEntries => this.nrEntries;
 
        public long NrProperties => this.nrProperties;
 
        public long NrFiles => this.nrFiles;
 
        public long NrFileBytes => this.nrFileBytes;
 
        public Dictionary<string, string> ObjectIdMap => this.objectIdMap;
 
        public virtual void Dispose()
        {
        }
 
        public string[] CollectionNames => null;
 
        public virtual Task<bool> Start()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> End()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartDatabase()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndDatabase()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartLedger()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndLedger()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartCollection(string CollectionName)
        {
            this.collectionName = CollectionName;
            this.nrCollections++;
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndCollection()
        {
            this.collectionName = null;
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartIndex()
        {
            this.index.Clear();
            this.nrIndices++;
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndIndex()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> ReportIndexField(string FieldName, bool Ascending)
        {
            if (Ascending)
                this.index.Add(FieldName);
            else
                this.index.Add("-" + FieldName);
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartBlock(string BlockID)
        {
            this.nrBlocks++;
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndBlock()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> BlockMetaData(string Key, object Value)
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<string> StartObject(string ObjectId, string TypeName)
        {
            this.objectId = this.MapObjectId(ObjectId);
            this.typeName = TypeName;
            this.nrObjects++;
 
            return Task.FromResult(ObjectId);
        }
 
        private string MapObjectId(string ObjectId)
        {
            if (this.mapObjectIds)
            {
                string ObjectId0 = ObjectId;
 
                if (!this.objectIdMap.TryGetValue(ObjectId0, out ObjectId))
                {
                    byte[] A;
                    int i, c;
 
                    if (System.Guid.TryParse(ObjectId0, out Guid Guid))
                        A = Guid.ToByteArray();
                    else
                        A = Hashes.StringToBinary(ObjectId0);
 
                    if (!(A is null) && (c = A.Length) != this.objectIdByteCount)
                    {
                        if (c > this.objectIdByteCount)
                        {
                            if (c == 16)
                            {
                                for (i = this.objectIdByteCount; i < c; i++)
                                    A[i] = 0;
 
                                ObjectId = new Guid(A).ToString();
                            }
                            else
                            {
                                Array.Resize(ref A, this.objectIdByteCount);
                                ObjectId = Hashes.BinaryToString(A);
                            }
                        }
                        else
                        {
                            Array.Resize(ref A, this.objectIdByteCount);
 
                            if (this.objectIdByteCount == 16)
                                ObjectId = new Guid(A).ToString();
                            else
                                ObjectId = Hashes.BinaryToString(A);
                        }
 
                        while (this.objectIdMap.ContainsKey(ObjectId))
                        {
                            if (this.objectIdByteCount == 16)
                                ObjectId = Guid.NewGuid().ToString();
                            else
                            {
                                A = Gateway.NextBytes(this.objectIdByteCount);
                                ObjectId = Hashes.BinaryToString(A);
                            }
                        }
 
                        this.objectIdMap[ObjectId0] = ObjectId;
                    }
                    else
                        ObjectId = ObjectId0;
                }
            }
 
            return ObjectId;
        }
 
        public virtual Task<bool> EndObject()
        {
            this.objectId = null;
            this.typeName = null;
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            this.objectId = this.MapObjectId(ObjectId);
            this.typeName = TypeName;
            this.nrEntries++;
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndEntry()
        {
            this.objectId = null;
            this.typeName = null;
 
            return Task.FromResult(true);
        }
 
        public virtual async Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            return
                await this.StartEntry(string.Empty, string.Empty, EntryType.Clear, EntryTimestamp) &&
                await this.EndEntry();
        }
 
        public virtual Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            this.nrProperties++;
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> StartFiles()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> EndFiles()
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> ExportFile(string FileName, Stream File)
        {
            this.nrFiles++;
            this.nrFileBytes += File.Length;
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> ReportError(string Message)
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> ReportException(Exception Exception)
        {
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> UpdateClient(bool ForceUpdate)
        {
            return Task.FromResult(true);
        }
    }
}