ExportToLambda.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Serialization;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public class ExportToLambda : ILedgerExport
    {
        private readonly ILambdaExpression lambda;
        private readonly IElement[] arguments = new IElement[] { ObjectValue.Null };
        private Dictionary<string, IElement> currentCollection = null;
        private Dictionary<string, IElement> currentBlock = null;
        private Dictionary<string, IElement> currentEntry = null;
        private Dictionary<string, IElement> propertiesInEvent = null;
        private Variables variables;
 
        public ExportToLambda(ILambdaExpression Lambda)
        {
            this.lambda = Lambda;
        }
 
        public Variables Variables
        {
            get => this.variables;
            internal set => this.variables = value;
        }
 
        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) }
            };
 
            return Task.FromResult(true);
        }
 
        public Task<bool> EndCollection()
        {
            return Task.FromResult(true);
        }
 
        public Task<bool> StartBlock(string BlockID)
        {
            this.currentBlock = new Dictionary<string, IElement>()
            {
                { "Id", new StringValue(BlockID) }
            };
 
            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()
        {
            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 async Task<bool> EndEntry()
        {
            Dictionary<string, IElement> Data = new Dictionary<string, IElement>();
 
            foreach (KeyValuePair<string, IElement> P in this.currentCollection)
                Data[P.Key] = P.Value;
 
            foreach (KeyValuePair<string, IElement> P in this.currentBlock)
                Data[P.Key] = P.Value;
 
            foreach (KeyValuePair<string, IElement> P in this.currentEntry)
                Data[P.Key] = P.Value;
 
            foreach (KeyValuePair<string, IElement> P in this.propertiesInEvent)
                Data[P.Key] = P.Value;
 
            try
            {
                this.arguments[0] = new ObjectValue(Data);
 
                if (this.lambda.IsAsynchronous)
                    await this.lambda.EvaluateAsync(this.arguments, this.variables);
                else
                    this.lambda.Evaluate(this.arguments, this.variables);
 
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }
 
        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);
        }
    }
}