LegalIdentityUser.cs

using Paiwise;
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.IoTGateway;
using Waher.Networking.XMPP.Server;
using Waher.Security;
using Waher.Security.JWT;
using Waher.Service.IoTBroker.Legal.MFA;
using Waher.Things;
 
namespace Waher.Service.IoTBroker.Legal.Identity
{
    public class LegalIdentityUser : IUserWithClaims, ILegalIdentityUser, 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);
                Xml = sb.ToString();
 
                Networking.XMPP.Contracts.LegalIdentity Identity2 = Networking.XMPP.Contracts.LegalIdentity.Parse(Xml);
 
                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 ILegalIdentity LegalIdentity => this.identity;
 
        public LegalIdentity Identity => this.identity;
 
        public XmppAddress From => this.from;
 
        public IUser User => (IUser)this.user ?? this;
 
        public string UserName
        {
            get
            {
                string s = this.user?.UserName;
                if (!string.IsNullOrEmpty(s))
                    return s;
 
                s = this.identity[PersonalInformation.JidTag];
                if (string.IsNullOrEmpty(s))
                    s = this.identity.Id;
 
                int i = s.IndexOf('@');
                if (i > 0 && Gateway.IsDomain(s[(i + 1)..], true))
                    return s[..i];
 
                return s;
            }
        }
 
        public string FederatedUserName
        {
            get
            {
                string s = this.user?.FederatedUserName;
                if (!string.IsNullOrEmpty(s))
                    return s;
 
                s = this.identity[PersonalInformation.JidTag];
                return string.IsNullOrEmpty(s) ? this.identity.Id.Value : s;
            }
        }
 
        public string FriendlyName
        {
            get
            {
                string s = this.user?.FriendlyName;
                if (!string.IsNullOrEmpty(s))
                    return s;
 
                s = this.identity[PersonalInformation.FullNameTag];
                if (!string.IsNullOrEmpty(s))
                    return s;
 
                return this.UserName;
            }
        }
 
        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[6..]);
            else if (Privilege.StartsWith("iotsc:"))
                return this.legalComponent.IsAccessToContractAuthorized(this.from.BareJid, Privilege[6..]);
            else
                return false;
        }
 
        public Task<RequestOrigin> GetOrigin()
        {
            return Task.FromResult(new RequestOrigin(this.from.BareJid, null, null, null, this));
        }
 
        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,
            params KeyValuePair<string, object>[] AdditionalClaims)
        {
            if (this.user is null)
                return Task.FromResult<string>(null);
            else
                return this.user.CreateToken(Factory, Encrypted, AdditionalClaims);
        }
 
    }
}