CustomEntryExport.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public abstract class CustomEntryExport : ILedgerExport
    {
        private readonly Dictionary<string, object> blockMetaData = new Dictionary<string, object>();
        private readonly ILedgerExport output;
        private string startedCollection = null;
        private string startedBlock = null;
        private bool startedCollectionExported = false;
        private bool startedBlockExported = false;
        private bool hasBlockMetaData = false;
        private bool includeCurrentEntry = false;
 
        public CustomEntryExport(ILedgerExport Output)
        {
            this.output = Output;
        }
 
        protected string StartedCollection => this.startedCollection;
 
        protected string StartedBlock => this.startedBlock;
 
        public Task<bool> StartLedger(ILedgerProvider Provider)
        {
            return this.output.StartLedger(Provider);
        }
 
        public Task<bool> EndLedger()
        {
            return this.output.EndLedger();
        }
 
        public virtual Task<bool> StartCollection(string CollectionName)
        {
            this.startedCollection = CollectionName;
            this.startedCollectionExported = false;
 
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndCollection()
        {
            if (this.startedCollectionExported)
            {
                if (!await this.output.EndCollection())
                    return false;
 
                this.startedCollectionExported = false;
            }
 
            this.startedCollection = null;
 
            return true;
        }
 
        public virtual Task<bool> StartBlock(string BlockID)
        {
            this.startedBlock = BlockID;
            this.startedBlockExported = false;
            this.hasBlockMetaData = false;
 
            return Task.FromResult(true);
        }
 
        public virtual Task<bool> BlockMetaData(string Key, object Value)
        {
            this.blockMetaData[Key] = Value;
            this.hasBlockMetaData = true;
 
            return Task.FromResult(true);
        }
 
        public async Task<bool> EndBlock()
        {
            if (this.startedBlockExported)
            {
                if (!await this.output.EndBlock())
                    return false;
 
                this.startedBlockExported = false;
            }
 
            if (this.hasBlockMetaData)
            {
                this.blockMetaData.Clear();
                this.hasBlockMetaData = false;
            }
 
            this.startedBlock = null;
 
            return true;
        }
 
        public abstract bool IncludeEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp);
 
        public abstract bool IncludeNonEntryEvent();
 
        public virtual bool ContinueExport() => true;
 
        public virtual async Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            if (this.IncludeEntry(ObjectId, TypeName, EntryType, EntryTimestamp))
            {
                if (!await this.OutputPendingInfo())
                    return false;
 
                this.includeCurrentEntry = true;
 
                return await this.output.StartEntry(ObjectId, TypeName, EntryType, EntryTimestamp);
            }
            else
            {
                this.includeCurrentEntry = false;
                return true;
            }
        }
 
        private async Task<bool> OutputPendingInfo()
        {
            if (!this.startedCollectionExported && !(this.startedCollection is null))
            {
                if (!await this.output.StartCollection(this.startedCollection))
                    return false;
 
                this.startedCollectionExported = true;
            }
 
            if (!this.startedBlockExported && !(this.startedBlock is null))
            {
                if (!await this.output.StartBlock(this.startedBlock))
                    return false;
 
                this.startedBlockExported = true;
 
                if (this.hasBlockMetaData)
                {
                    foreach (KeyValuePair<string, object> P in this.blockMetaData)
                    {
                        if (!await this.output.BlockMetaData(P.Key, P.Value))
                            return false;
                    }
 
                    this.blockMetaData.Clear();
                    this.hasBlockMetaData = false;
                }
            }
 
            return true;
        }
 
        public virtual Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            if (this.includeCurrentEntry)
                return this.output.ReportProperty(PropertyName, PropertyValue);
            else
                return Task.FromResult(true);
        }
 
        public virtual async Task<bool> EndEntry()
        {
            if (this.includeCurrentEntry)
            {
                this.includeCurrentEntry = false;
                if (!await this.output.EndEntry())
                    return false;
            }
            
            return this.ContinueExport();
        }
 
        public async Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            if (this.IncludeNonEntryEvent())
            {
                if (!await this.OutputPendingInfo())
                    return false;
 
                if (!await this.output.CollectionCleared(EntryTimestamp))
                    return false;
            }
 
            return true;
        }
 
        public Task<bool> ReportError(string Message)
        {
            if (this.IncludeNonEntryEvent())
                return this.output.ReportError(Message);
            else
                return Task.FromResult(true);
        }
 
        public Task<bool> ReportException(Exception Exception)
        {
            if (this.IncludeNonEntryEvent())
                return this.output.ReportException(Exception);
            else
                return Task.FromResult(true);
        }
    }
}