BlockEvent.cs

using System;
using System.Text;
using System.Xml;
using Waher.Content.Xml;
using Waher.Persistence.NeuroLedger;
 
namespace Waher.Networking.XMPP.NeuroLedger.PepEvents
{
    public abstract class BlockEvent : NeuroLedgerPepEvent
    {
        private byte[] digest = null;
        private byte[] signature = null;
        private byte[] link = null;
        private string collection = string.Empty;
        private string creator = string.Empty;
        private string url = string.Empty;
        private ulong bytes = 0;
        private DateTime created = DateTime.MinValue;
        private DateTime updated = DateTime.MinValue;
        private DateTime expires = DateTime.MaxValue;
        private BlockStatus status = BlockStatus.Valid;
 
        public BlockEvent()
            : base()
        {
        }
 
        public byte[] Digest
        {
            get => this.digest;
            set => this.digest = value;
        }
 
        public byte[] Signature
        {
            get => this.signature;
            set => this.signature = value;
        }
 
        public byte[] Link
        {
            get => this.link;
            set => this.link = value;
        }
 
        public string Collection
        {
            get => this.collection;
            set => this.collection = value;
        }
 
        public string Creator
        {
            get => this.creator;
            set => this.creator = value;
        }
 
        public string Url
        {
            get => this.url;
            set => this.url = value;
        }
 
        public DateTime Created
        {
            get => this.created;
            set => this.created = value;
        }
 
        public DateTime Updated
        {
            get => this.updated;
            set => this.updated = value;
        }
 
        public DateTime Expires
        {
            get => this.expires;
            set => this.expires = value;
        }
 
        public BlockStatus Status
        {
            get => this.status;
            set => this.status = value;
        }
 
        public ulong Bytes
        {
            get => this.bytes;
            set => this.bytes = value;
        }
 
        protected void AddAttributes(StringBuilder Xml)
        {
            Xml.Append(" xmlns='");
            Xml.Append(NeuroLedgerClient.NeuroLedgerNamespace);
            Xml.Append("' d='");
            Xml.Append(Convert.ToBase64String(this.digest));
            Xml.Append("' s='");
            Xml.Append(Convert.ToBase64String(this.signature));
 
            if (!(this.link is null))
            {
                Xml.Append("' l='");
                Xml.Append(Convert.ToBase64String(this.link));
            }
 
            Xml.Append("' cn='");
            Xml.Append(XML.Encode(this.collection));
            Xml.Append("' cr='");
            Xml.Append(XML.Encode(this.creator));
            Xml.Append("' ct='");
            Xml.Append(XML.Encode(this.created));
 
            if (this.updated != DateTime.MinValue)
            {
                Xml.Append("' u='");
                Xml.Append(XML.Encode(this.updated));
            }
 
            if (this.expires != DateTime.MaxValue)
            {
                Xml.Append("' x='");
                Xml.Append(XML.Encode(this.expires));
            }
 
            if (this.status != BlockStatus.Valid)
            {
                Xml.Append("' t='");
                Xml.Append(this.status.ToString());
            }
 
            Xml.Append("' r='");
            Xml.Append(this.url);
            Xml.Append("' b='");
            Xml.Append(this.bytes.ToString());
            Xml.Append("'");
        }
 
        protected void Parse(XmlElement E, BlockEvent Event)
        {
            foreach (XmlAttribute Attr in E.Attributes)
            {
                switch (Attr.Name)
                {
                    case "d":
                        Event.digest = Convert.FromBase64String(Attr.Value);
                        break;
 
                    case "s":
                        Event.signature = Convert.FromBase64String(Attr.Value);
                        break;
 
                    case "l":
                        Event.link = Convert.FromBase64String(Attr.Value);
                        break;
 
                    case "cn":
                        Event.collection = Attr.Value;
                        break;
 
                    case "cr":
                        Event.creator = Attr.Value;
                        break;
 
                    case "ct":
                        if (!XML.TryParse(Attr.Value, out DateTime DT))
                            throw new InvalidOperationException("Invalid creation time.");
 
                        Event.created = DT;
                        break;
 
                    case "u":
                        if (!XML.TryParse(Attr.Value, out DT))
                            throw new InvalidOperationException("Invalid update time.");
 
                        Event.updated = DT;
                        break;
 
                    case "x":
                        if (!XML.TryParse(Attr.Value, out DT))
                            throw new InvalidOperationException("Invalid expires time.");
 
                        Event.expires = DT;
                        break;
 
                    case "t":
                        if (!Enum.TryParse<BlockStatus>(Attr.Value, out BlockStatus Status))
                            throw new InvalidOperationException("Invalid block status.");
 
                        Event.status = Status;
                        break;
 
                    case "r":
                        Event.url = Attr.Value;
                        break;
 
                    case "b":
                        if (!ulong.TryParse(Attr.Value, out ulong Bytes))
                            throw new InvalidOperationException("Invalid block size.");
 
                        Event.bytes = Bytes;
                        break;
 
                    case "xmlns":
                    case "id":
                        break;
 
                    default:
                        if (Attr.Prefix != "xmlns")
                            throw new InvalidOperationException("Invalid attribute: " + Attr.Name);
                        break;
                }
            }
        }
    }
}