ExportToJson.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Objects;
using Waher.Script.Objects.VectorSpaces;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public class ExportToJson : ILedgerExport
    {
        private readonly ChunkedList<IElement> collections = new ChunkedList<IElement>();
        private readonly ChunkedList<IElement> blocksInCollection = new ChunkedList<IElement>();
        private readonly ChunkedList<IElement> eventsInBlock = new ChunkedList<IElement>();
        private Dictionary<string, IElement> currentCollection = null;
        private Dictionary<string, IElement> currentBlock = null;
        private Dictionary<string, IElement> currentEntry = null;
        private Dictionary<string, IElement> propertiesInEvent = null;
 
        public ExportToJson()
        {
        }
 
        public IVector ToVector()
        {
            return new ObjectVector(this.collections.ToArray());
        }
 
        public Task<bool> StartLedger(ILedgerProvider Provider)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> EndLedger()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartCollection(string CollectionName)
        {
            this.currentCollection = new Dictionary<string, IElement>()
            {
                { "Name", new StringValue(CollectionName) }
            };
 
            this.blocksInCollection.Clear();
 
            return Task.FromResult(true);
        }
 
        public Task<bool> EndCollection()
        {
            if (this.blocksInCollection.Count > 0)
            {
                this.currentCollection["Blocks"] = new ObjectVector(this.blocksInCollection.ToArray());
                this.collections.Add(new ObjectValue(this.currentCollection));
            }
 
            return Task.FromResult(true);
        }
 
        public Task<bool> StartBlock(string BlockID)
        {
            this.currentBlock = new Dictionary<string, IElement>()
            {
                { "Id", new StringValue(BlockID) }
            };
 
            this.eventsInBlock.Clear();
 
            return Task.FromResult(true);
        }
 
        public Task<bool> BlockMetaData(string Key, object Value)
        {
            this.currentBlock[Key] = Expression.Encapsulate(Value);
            return Task.FromResult(true);
        }
 
        public Task<bool> EndBlock()
        {
            if (this.eventsInBlock.Count > 0)
            {
                this.currentBlock["Events"] = new ObjectVector(this.eventsInBlock.ToArray());
                this.blocksInCollection.Add(new ObjectValue(this.currentBlock));
            }
 
            return Task.FromResult(true);
        }
 
        public Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            this.propertiesInEvent = new Dictionary<string, IElement>();
            this.currentEntry = new Dictionary<string, IElement>()
            {
                { "ObjectId", new ObjectValue(ObjectId) },
                { "TypeName", new ObjectValue(TypeName) },
                { "EntryType", new ObjectValue(EntryType) },
                { "Timestamp", new ObjectValue(EntryTimestamp) },
                { "this", new ObjectValue(this.propertiesInEvent) }
            };
 
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            this.propertiesInEvent[PropertyName] = Expression.Encapsulate(PropertyValue);
            return Task.FromResult(true);
        }
 
        public Task<bool> EndEntry()
        {
            this.eventsInBlock.Add(new ObjectValue(this.currentEntry));
            return Task.FromResult(true);
        }
 
        public Task<bool> CollectionCleared(DateTimeOffset EntryTimestamp)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportError(string Message)
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> ReportException(Exception Exception)
        {
            return Task.FromResult(true);
        }
    }
}