RecordSet.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Markdown.Model;
using Waher.Content.Xml;
using Waher.Persistence.Attributes;
using Waher.Runtime.Collections;
using Waher.Runtime.Profiling;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Objects;
using Waher.Script.Objects.VectorSpaces;
using Waher.Service.IoTBroker.Legal.HumanReadable;
using Waher.Service.IoTBroker.Legal.HumanReadable.BlockElements;
 
namespace Waher.Service.IoTBroker.Legal.Contracts
{
    public class RecordSet : Parameter
    {
        private Parameter[] recordDefinition = null;
        private Parameter[][] records = null;
        private int? minRecords = null;
        private int? maxRecords = null;
 
        [DefaultValueNull]
        public int? MinRecords
        {
            get => this.minRecords;
            set => this.minRecords = value;
        }
 
        [DefaultValueNull]
        public int? MaxRecords
        {
            get => this.maxRecords;
            set => this.maxRecords = value;
        }
 
        public override object ObjectValue => string.Empty;
 
        public override string StringValue
        {
            get => string.Empty;
            set => throw new Exception("Record set parameters are set via the records or the record definition.");
        }
 
        public override void ClearValue()
        {
            ClearValues(this.recordDefinition);
 
            if (this.records is null)
                return;
 
            foreach (Parameter[] Record in this.records)
                ClearValues(Record);
        }
 
        private static void ClearValues(Parameter[] Parameters)
        {
            if (Parameters is null)
                return;
 
            foreach (Parameter P in Parameters)
                P.ClearValue();
        }
 
 
        public override async Task ToMarkdown(MarkdownOutput Markdown, MarkdownOutputState State)
        {
            Markdown.AppendLine();
            Markdown.AppendLine();
 
            Table.NotesRef NotesRef = new Table.NotesRef();
            MarkdownOutputState State2 = new MarkdownOutputState()
            {
                Language = State.Language,
                Contract = State.Contract,
                Level = 1,
                Indentation = 0
            };
 
            if (!(this.recordDefinition is null))
            {
                foreach (Parameter P in this.recordDefinition)
                    await Table.ToMarkdownCell(Markdown, State2, P.Descriptions, NotesRef);
 
                Markdown.AppendLine(" |");
                Markdown.Append('|');
 
                foreach (Parameter P in this.recordDefinition)
                    Table.ToMarkdown(Markdown, P.CellAlignment, false);
 
                Markdown.AppendLine();
            }
 
            if (!(this.records is null))
            {
                foreach (Parameter[] Record in this.records)
                {
                    foreach (Parameter P in Record)
                    {
                        await Table.ToMarkdownCell(Markdown, State2, P, NotesRef);
                        Markdown.Append(' ');
                    }
 
                    Markdown.AppendLine("|");
                }
            }
 
            Table.ToMarkdown(Markdown, State, NotesRef.Notes);
        }
 
        public override void Serialize(StringBuilder Xml)
        {
            Xml.Append("<recordSet");
 
            if (!string.IsNullOrEmpty(this.Expression))
            {
                Xml.Append(" exp=\"");
                Xml.Append(XML.Encode(this.Expression.Normalize(NormalizationForm.FormC)));
                Xml.Append('"');
            }
 
            if (this.maxRecords.HasValue)
            {
                Xml.Append(" maxRecords=\"");
                Xml.Append(this.maxRecords.Value.ToString());
                Xml.Append('"');
            }
 
            if (this.minRecords.HasValue)
            {
                Xml.Append(" minRecords=\"");
                Xml.Append(this.minRecords.Value.ToString());
                Xml.Append('"');
            }
 
            Xml.Append(" name=\"");
            Xml.Append(XML.Encode(this.Name.Value.Normalize(NormalizationForm.FormC)));
            Xml.Append("\">");
 
            if (!(this.Descriptions is null))
            {
                foreach (HumanReadableText Description in this.Descriptions)
                    Description.Serialize(Xml, "description", null);
            }
 
            Xml.Append("<recordDefinition>");
 
            if (!(this.recordDefinition is null))
            {
                foreach (Parameter P in this.recordDefinition)
                    P.Serialize(Xml);
            }
 
            Xml.Append("</recordDefinition>");
 
            if (!(this.records is null))
            {
                foreach (Parameter[] Record in this.records)
                {
                    Xml.Append("<record>");
 
                    foreach (Parameter P in Record)
                    {
                        P.ClearValidationRules();
                        P.Serialize(Xml);
                    }
 
                    Xml.Append("</record>");
                }
            }
 
            Xml.Append("</recordSet>");
        }
 
        public override async Task<string> IsParameterValid(Variables Variables, 
            LegalComponent Legal, ProfilerThread Profiler)
        {
            if (!this.minRecords.HasValue)
                return "Minimum number of records missing.";
 
            if (!this.maxRecords.HasValue)
                return "Maximum number of records missing.";
 
            if (this.minRecords.Value > 0 && (this.records is null || this.records.Length < this.minRecords.Value))
                return "Too few records defined.";
 
            if (!(this.records is null) && this.records.Length > this.maxRecords.Value)
                return "Too many records defined.";
 
            if (!(this.records is null))
            {
                foreach (Parameter[] Record in this.records)
                {
                    if (Record.Length != (this.recordDefinition?.Length ?? 0))
                        return "Record length mismatch.";
 
                    int i, c = Record.Length;
 
                    for (i = 0; i < c; i++)
                    {
                        Parameter Item = Record[i];
 
                        if (!Item.CopyValidationRules(this.recordDefinition[i]))
                            return "Record element type mismatch.";
 
                        string Error = await Item.IsParameterValid(Variables, Legal, Profiler);
 
                        if (!string.IsNullOrEmpty(Error))
                            return Error;
                    }
                }
            }
 
            return await base.IsParameterValid(Variables, Legal, Profiler);
        }
 
        public override void Populate(Variables Variables, ProfilerThread Profiler)
        {
            ChunkedList<IElement> Records = new ChunkedList<IElement>();
 
            if (!(this.records is null))
            {
                Variables RecordVariables = null;
 
                foreach (Parameter[] Record in this.records)
                {
                    if (RecordVariables is null)
                        RecordVariables = new Variables();
                    else
                        RecordVariables.Clear();
 
                    foreach (Parameter P in Record)
                        P.Populate(RecordVariables, Profiler);
 
                    Dictionary<string, IElement> Items = new Dictionary<string, IElement>();
 
                    foreach (Variable Variable in RecordVariables)
                        Items[Variable.Name] = Variable.ValueElement;
 
                    Records.Add(new ObjectValue(Items));
                }
            }
 
            Variables[this.Name] = new ObjectVector(Records.ToArray());
        }
 
        public override bool UpdateRequiresReview(Parameter UpdatedParameter)
        {
            if (!(UpdatedParameter is RecordSet UpdatedRecordSet))
                return true;
 
            int i, j, c, d;
 
            if (this.minRecords != UpdatedRecordSet.minRecords ||
                this.maxRecords != UpdatedRecordSet.maxRecords ||
                (c = this.recordDefinition?.Length ?? 0) != (UpdatedRecordSet.recordDefinition?.Length ?? 0) ||
                (d = this.records?.Length ?? 0) != (UpdatedRecordSet.records?.Length ?? 0) ||
                base.UpdateRequiresReview(UpdatedParameter))
            {
                return true;
            }
 
            for (i = 0; i < c; i++)
            {
                if (this.recordDefinition[i].UpdateRequiresReview(UpdatedRecordSet.recordDefinition[i]))
                    return true;
            }
 
            for (j = 0; j < d; j++)
            {
                Parameter[] Record = this.records[j];
                if (Record.Length != c)
                    return true;
 
                Parameter[] UpdatedRecord = UpdatedRecordSet.records[j];
                if (UpdatedRecord.Length != c)
                    return true;
 
                for (i = 0; i < c; i++)
                {
                    if (Record[i].UpdateRequiresReview(UpdatedRecord[i]))
                        return true;
                }
            }
 
            return false;
        }
 
        public override Parameter TryCreateNew(object NewValue)
        {
            return null;
        }
 
        public override async Task<bool> Import(XmlElement Xml)
        {
            this.minRecords = Xml.HasAttribute("minRecords") ? XML.Attribute(Xml, "minRecords", 0) : (int?)null;
            this.maxRecords = Xml.HasAttribute("maxRecords") ? XML.Attribute(Xml, "maxRecords", 0) : (int?)null;
 
            ChunkedList<Parameter> RecordDefinitions = new ChunkedList<Parameter>();
            ChunkedList<Parameter[]> Records = new ChunkedList<Parameter[]>();
            ChunkedList<Parameter> Record = null;
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (!(N is XmlElement E))
                    continue;
 
                switch (E.LocalName)
                {
                    case "recordDefinition":
                        if (!await Contract.ParseParameters(E, RecordDefinitions))
                            return false;
                        break;
 
                    case "record":
                        if (Record is null)
                            Record = new ChunkedList<Parameter>();
                        else
                            Record.Clear();
 
                        if (!await Contract.ParseParameters(E, Record))
                            return false;
 
                        Records.Add(Record.ToArray());
                        break;
                }
            }
 
            return await base.Import(Xml);
        }
 
        protected override bool IsChildLocalNameRecognized(string LocalName)
        {
            switch (LocalName)
            {
                case "recordDefinition":
                case "record":
                    return true;
 
                default:
                    return base.IsChildLocalNameRecognized(LocalName);
            }
        }
 
        public override TextAlignment CellAlignment => TextAlignment.Left;
 
        public override bool CopyValidationRules(Parameter From)
        {
            if (!(From is RecordSet Typed))
                return false;
 
            this.recordDefinition = Typed.recordDefinition;
            this.records = Typed.records;
            this.minRecords = Typed.minRecords;
            this.maxRecords = Typed.maxRecords;
 
            return base.CopyValidationRules(From);
        }
 
        public override void ClearValidationRules()
        {
            this.recordDefinition = null;
            this.records = null;
            this.minRecords = null;
            this.maxRecords = null;
 
            base.ClearValidationRules();
        }
 
    }
}