ExportCondition.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.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.Persistence.SQL.LedgerExports
{
    public class ExportCondition : CustomEntryExport
    {
        private readonly ChunkedList<KeyValuePair<string, object>> currentProperties = new ChunkedList<KeyValuePair<string, object>>();
        private readonly ChunkedList<KeyValuePair<string, ScriptNode>> additionalFields;
        private readonly ScriptNode condition;
        private readonly ObjectProperties properties = null;
        private readonly Variables contextVariables;
        private readonly Variables entryVariables;
        private readonly Variable variableObjectId;
        private readonly Variable variableTypeName;
        private readonly Variable variableEntryType;
        private readonly Variable variableTimestamp;
        private readonly Variable variableBlockId;
        private readonly Variable variableCollection;
        private string currentObjectId;
        private string currentTypeName;
        private EntryType currentEntryType;
        private DateTimeOffset currentEntryTimestamp;
 
        public ExportCondition(ILedgerExport Output, ScriptNode Condition, Variables Variables,
            ChunkedList<KeyValuePair<string, ScriptNode>> AdditionalFields)
            : base(Output)
        {
            this.condition = Condition;
            this.contextVariables = Variables;
            this.additionalFields = AdditionalFields;
 
            this.properties = new ObjectProperties(
                new GenericObject(string.Empty, string.Empty, Guid.Empty),
                this.contextVariables);
 
            this.entryVariables = new Variables()
            {
                ContextVariables = this.properties,
                ConsoleOut = Variables.ConsoleOut
            };
 
            this.variableObjectId = this.entryVariables.Add("ObjectId", this.currentObjectId);
            this.variableTypeName = this.entryVariables.Add("TypeName", this.currentTypeName);
            this.variableEntryType = this.entryVariables.Add("EntryType", this.currentEntryType);
            this.variableTimestamp = this.entryVariables.Add("Timestamp", this.currentEntryTimestamp);
            this.variableBlockId = this.entryVariables.Add("BlockId", this.StartedBlock);
            this.variableCollection = this.entryVariables.Add("Collection", this.StartedCollection);
        }
 
        public Variables EntryVariables => this.entryVariables;
 
        public override Task<bool> StartCollection(string CollectionName)
        {
            this.variableCollection.SetValue(CollectionName);
 
            return base.StartCollection(CollectionName);
        }
 
        public override Task<bool> StartBlock(string BlockID)
        {
            this.variableBlockId.SetValue(BlockID);
 
            return base.StartBlock(BlockID);
        }
 
        public override Task<bool> BlockMetaData(string Key, object Value)
        {
            this.entryVariables[Key] = Value;
 
            return base.BlockMetaData(Key, Value);
        }
 
        public override Task<bool> StartEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            this.currentObjectId = ObjectId;
            this.currentTypeName = TypeName;
            this.currentEntryType = EntryType;
            this.currentEntryTimestamp = EntryTimestamp;
 
            this.variableObjectId.SetValue(this.currentObjectId);
            this.variableTypeName.SetValue(this.currentTypeName);
            this.variableEntryType.SetValue(this.currentEntryType);
            this.variableTimestamp.SetValue(this.currentEntryTimestamp);
 
            this.currentProperties.Clear();
 
            return Task.FromResult(true);
        }
 
        public override Task<bool> ReportProperty(string PropertyName, object PropertyValue)
        {
            this.currentProperties.Add(new KeyValuePair<string, object>(PropertyName, PropertyValue));
            return Task.FromResult(true);
        }
 
        public override async Task<bool> EndEntry()
        {
            if (!Guid.TryParse(this.currentObjectId, out Guid ObjectId))
                ObjectId = Guid.Empty;
 
            this.properties.Object = new GenericObject(this.StartedCollection,
                this.currentTypeName, ObjectId, this.currentProperties);
 
            if (!(this.additionalFields is null))
            {
                foreach (KeyValuePair<string, ScriptNode> P in this.additionalFields)
                {
                    IElement E;
 
                    try
                    {
                        if (P.Value.IsAsynchronous)
                            E = await P.Value.EvaluateAsync(this.entryVariables);
                        else
                            E = P.Value.Evaluate(this.entryVariables);
                    }
                    catch (ScriptReturnValueException ex)
                    {
                        E = ex.ReturnValue;
                        //ScriptReturnValueException.Reuse(ex);
                    }
                    catch (ScriptBreakLoopException ex)
                    {
                        E = ex.LoopValue ?? ObjectValue.Null;
                        //ScriptBreakLoopException.Reuse(ex);
                    }
                    catch (ScriptContinueLoopException ex)
                    {
                        E = ex.LoopValue ?? ObjectValue.Null;
                        //ScriptContinueLoopException.Reuse(ex);
                    }
                    catch (Exception ex)
                    {
                        E = new ObjectValue(ex);
                    }
 
                    this.entryVariables[P.Key] = E;
                    this.currentProperties.Add(new KeyValuePair<string, object>(P.Key, E.AssociatedObjectValue));
                }
            }
 
            if (!(this.condition is null))
            {
                try
                {
                    IElement E;
 
                    if (this.condition.IsAsynchronous)
                        E = await this.condition.EvaluateAsync(this.entryVariables);
                    else
                        E = this.condition.Evaluate(this.entryVariables);
 
                    if (!(E.AssociatedObjectValue is bool B && B))
                        return true;
                }
                catch (Exception)
                {
                    return true;
                }
            }
 
            if (!await base.StartEntry(this.currentObjectId, this.currentTypeName, this.currentEntryType, this.currentEntryTimestamp))
                return false;
 
            foreach (KeyValuePair<string, object> P in this.currentProperties)
            {
                if (!await base.ReportProperty(P.Key, P.Value))
                    return false;
            }
 
            if (!await base.EndEntry())
                return false;
 
            return true;
        }
 
        public override bool IncludeEntry(string ObjectId, string TypeName, EntryType EntryType, DateTimeOffset EntryTimestamp)
        {
            return true;
        }
 
        public override bool IncludeNonEntryEvent()
        {
            return true;
        }
    }
}