LegalIdentityUser.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Server;
using Waher.Security.JWT;
using Waher.Service.IoTBroker.Legal.MFA;
using Waher.Things;
 
namespace Waher.Service.IoTBroker.Legal.Identity
{
    public class LegalIdentityUser : IUserWithClaims, IRequestOrigin
    {
        private readonly LegalComponent legalComponent;
        private readonly LegalIdentity identity;
        private readonly QuickLoginUser user;
        private readonly XmppAddress from;
 
        private LegalIdentityUser(LegalIdentity Identity, XmppAddress From, LegalComponent LegalComponent, QuickLoginUser User)
        {
            this.identity = Identity;
            this.from = From;
            this.legalComponent = LegalComponent;
            this.user = User;
        }
 
        public static async Task<LegalIdentityUser> Create(LegalIdentity Identity, XmppAddress From, LegalComponent LegalComponent)
        {
            string Xml = null;
 
            try
            {
                Dictionary<string, string> AttachmentUrls = new Dictionary<string, string>();
                StringBuilder sb = new StringBuilder();
                Identity.Serialize(sb, true, true, true, true, true, true, true, AttachmentUrls, LegalComponent);
                XmlDocument Doc = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
 
                Doc.LoadXml(Xml = sb.ToString());
 
                Networking.XMPP.Contracts.LegalIdentity Identity2 = Networking.XMPP.Contracts.LegalIdentity.Parse(Doc.DocumentElement);
 
                LegalIdentityInfo IdentityInfo = await QuickLogin.PrepareQuickLoginIdentity(Identity2, "Session", true, null);
                QuickLoginUser User = new QuickLoginUser(Identity2, string.Empty, IdentityInfo.Properties, IdentityInfo.Attachments);
 
                return new LegalIdentityUser(Identity, From, LegalComponent, User);
            }
            catch (XmlException ex)
            {
                ex = XML.AnnotateException(ex, Xml);
                Log.Exception(ex);
                return new LegalIdentityUser(Identity, From, LegalComponent, null);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                return new LegalIdentityUser(Identity, From, LegalComponent, null);
            }
        }
 
        public LegalIdentity Identity => this.identity;
 
        public XmppAddress From => this.from;
 
        public QuickLoginUser User => this.user;
 
        public string UserName => this.identity.Id;
 
        public string PasswordHash => throw new InvalidOperationException();
 
        public string PasswordHashType => throw new InvalidOperationException();
 
        public bool HasPrivilege(string Privilege)
        {
            if (Privilege.StartsWith("iotid:"))
                return this.legalComponent.IsAccessToIdentityAuthorized(this.from.BareJid, Privilege.Substring(6));
            else if (Privilege.StartsWith("iotsc:"))
                return this.legalComponent.IsAccessToContractAuthorized(this.from.BareJid, Privilege.Substring(6));
            else
                return false;
        }
 
        public Task<RequestOrigin> GetOrigin()
        {
            return Task.FromResult(new RequestOrigin(this.from.BareJid, null, null, null));
        }
 
        public Task<IEnumerable<KeyValuePair<string, object>>> CreateClaims(bool Encrypted)
        {
            if (this.user is null)
                return Task.FromResult<IEnumerable<KeyValuePair<string, object>>>(null);
            else
                return this.user.CreateClaims(Encrypted);
        }
 
        public Task<string> CreateToken(JwtFactory Factory, bool Encrypted)
        {
            if (this.user is null)
                return Task.FromResult<string>(null);
            else
                return this.user.CreateToken(Factory, Encrypted);
        }
 
    }
}