LegalIdentityState.cs

using System;
using System.Text;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Inventory;
using Waher.Security.CallStack;
 
namespace Waher.Networking.XMPP.Contracts
{
    [CollectionName("LegalIdentityStates")]
    [TypeName(TypeNameSerialization.None)]
    [Index("BareJid", "LegalId")]
    [Index("BareJid", "State", "Timestamp")]
    [Singleton]
    public class LegalIdentityState : IEncryptedProperties
    {
        private static ICallStackCheck[] approvedSources = null;
 
        private string objectId = null;
        private CaseInsensitiveString bareJid = CaseInsensitiveString.Empty;
        private CaseInsensitiveString legalId = CaseInsensitiveString.Empty;
        private byte[] publicKey = null;
        private string keyName = null;
        private string keyNamespace = null;
        private byte[] privateKey = null;
        private IdentityState state = IdentityState.Created;
        private DateTime timestamp = DateTime.MinValue;
 
        public LegalIdentityState()
        {
        }
 
        public LegalIdentityState(string LegalId)
        {
            this.legalId = LegalId;
        }
 
        [ObjectId]
        public string ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        public CaseInsensitiveString BareJid
        {
            get => this.bareJid;
            set => this.bareJid = value;
        }
 
        public CaseInsensitiveString LegalId
        {
            get => this.legalId;
            set => this.legalId = value;
        }
 
        [DefaultValueNull]
        public byte[] PublicKey
        {
            get => this.publicKey;
            set => this.publicKey = value;
        }
 
        [DefaultValueNull]
        public string KeyName
        {
            get => this.keyName;
            set => this.keyName = value;
        }
 
        [DefaultValueNull]
        public string KeyNamespace
        {
            get => this.keyNamespace;
            set => this.keyNamespace = value;
        }
 
        public bool HasPrivateKey => !(this.privateKey is null);
 
        [DefaultValueNull]
        [Encrypted(32)]
        public byte[] PrivateKey
        {
            get
            {
                AssertAllowed();
                return this.privateKey;
            }
 
            set
            {
                if (!(this.privateKey is null))
                    AssertAllowed();
 
                this.privateKey = value;
            }
        }
 
        public IdentityState State
        {
            get => this.state;
            set => this.state = value;
        }
 
        public DateTime Timestamp
        {
            get => this.timestamp;
            set => this.timestamp = value;
        }
 
        public string[] EncryptedProperties => new string[]
        {
            nameof(this.PrivateKey)
        };
 
        public static void SetAllowedSources(ICallStackCheck[] ApprovedSources)
        {
            if (!(approvedSources is null))
                throw new NotSupportedException("Changing approved sources not permitted.");
 
            approvedSources = ApprovedSources;
        }
 
        private static void AssertAllowed()
        {
            if (!(approvedSources is null))
                Assert.CallFromSource(approvedSources);
        }
 
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
 
            sb.Append(this.bareJid);
            sb.Append(", ");
            sb.Append(this.legalId);
            sb.Append(", ");
            sb.Append(this.state.ToString());
            sb.Append(", ");
            sb.Append(this.timestamp.ToString());
 
            if (!(this.publicKey is null))
            {
                sb.Append(", ");
                sb.Append(Convert.ToBase64String(this.publicKey));
            }
 
            if (!string.IsNullOrEmpty(this.keyName))
            {
                sb.Append(", ");
                sb.Append(this.keyName);
            }
 
            if (!string.IsNullOrEmpty(this.keyNamespace))
            {
                sb.Append(", ");
                sb.Append(this.keyNamespace);
            }
 
            if (!(this.privateKey is null))
            {
                sb.Append(", PrivateKey");
            }
 
            return sb.ToString();
        }
    }
}