QuickLoginUser.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Contracts;
using Waher.Security.JWT;
using Waher.Security.Users;
using Waher.Things;
 
namespace Waher.Service.IoTBroker.Legal.MFA
{
    public class QuickLoginUser : IUserWithClaims, IRequestOrigin
    {
        private readonly LegalIdentity id;
        private readonly string petitionId;
        private readonly Dictionary<string, object> properties;
        private readonly Dictionary<string, object>[] attachments;
 
        public QuickLoginUser(LegalIdentity ID, string PetitionId, Dictionary<string, object> Properties,
            Dictionary<string, object>[] Attachments)
        {
            this.id = ID;
            this.petitionId = PetitionId;
            this.properties = Properties;
            this.attachments = Attachments;
        }
 
        public LegalIdentity LegalId => this.id;
 
        public string Id => this.id.Id;
 
        public string Key => this.petitionId;
 
        public string Provider => this.id.Provider;
 
        public string ClientKeyName => this.id.ClientKeyName;
 
        public DateTime Created => this.id.Created;
 
        public DateTime? Updated => this.id.Updated == DateTime.MinValue ? (DateTime?)null : this.id.Updated;
 
        public DateTime From => this.id.From;
 
        public DateTime To => this.id.To;
 
        public bool HasClientPublicKey => this.id.HasClientPublicKey;
 
        public string ClientPubKey => this.id.HasClientPublicKey ? Convert.ToBase64String(this.id.ClientSignature) : null;
 
        public Dictionary<string, object> Properties => this.properties;
 
        public Dictionary<string, object>[] Attachments => this.attachments;
 
        public string ServerSignature => Convert.ToBase64String(this.id.ServerSignature);
 
        public IdentityState State => this.id.State;
 
        public string UserName
        {
            get
            {
                if (this.properties.ContainsKey("FIRST") && this.properties.ContainsKey("LAST"))
                {
                    StringBuilder sb = null;
 
                    this.Append(ref sb, "FIRST", " ");
                    this.Append(ref sb, "MIDDLE", " ");
                    this.Append(ref sb, "LAST", " ");
 
                    return sb?.ToString() ?? "N/A";
                }
                else
                {
                    string s = this.Jid;
                    if (string.IsNullOrEmpty(s))
                        s = this.id?.Id;
 
                    if (string.IsNullOrEmpty(s))
                        return "N/A";
 
                    int i = s.IndexOf('@');
                    if (i < 0)
                        return s;
 
                    string LocalPart = s.Substring(0, i);
 
                    if (Guid.TryParse(LocalPart, out _) && !(this.id is null))
                    {
                        string EMail = this.id["EMAIL"];
                        if (!string.IsNullOrEmpty(EMail))
                            return EMail;
 
                        string PhoneNr = this.id["PHONE"];
                        if (!string.IsNullOrEmpty(PhoneNr))
                            return PhoneNr;
                    }
 
                    string Domain = s.Substring(i + 1);
 
                    if (Gateway.IsDomain(Domain, true))
                        return LocalPart;
                    else
                        return s;
                }
            }
        }
 
        public string FullAddress
        {
            get
            {
                StringBuilder sb = null;
 
                this.Append(ref sb, "ADDR", ", ");
                this.Append(ref sb, "ADDR2", ", ");
                this.Append(ref sb, "AREA", ", ");
                this.Append(ref sb, "ZIP", ", ");
                this.Append(ref sb, "CITY", ", ");
                this.Append(ref sb, "REGION", ", ");
                this.Append(ref sb, "COUNTRY", ", ");
 
                if (!(sb is null))
                    return sb.ToString();
 
                this.Append(ref sb, "ORGNAME", ", ");
                this.Append(ref sb, "ORGDEPT", ", ");
                this.Append(ref sb, "ORGADDR", ", ");
                this.Append(ref sb, "ORGADDR2", ", ");
                this.Append(ref sb, "ORGAREA", ", ");
                this.Append(ref sb, "ORGZIP", ", ");
                this.Append(ref sb, "ORGCITY", ", ");
                this.Append(ref sb, "ORGREGION", ", ");
                this.Append(ref sb, "ORGCOUNTRY", ", ");
 
                return sb?.ToString() ?? "N/A";
            }
        }
 
        public string Jid
        {
            get
            {
                if (this.properties.TryGetValue("JID", out object Obj) && Obj is string s)
                    return s;
                else
                    return null;
            }
        }
 
        private void Append(ref StringBuilder sb, string Name, string Delimiter)
        {
            if (this.properties.TryGetValue(Name, out object Obj))
                User.AppendValue(ref sb, Obj, Delimiter);
        }
 
        public string PasswordHash => string.Empty;
 
        public string PasswordHashType => string.Empty;
 
        public bool HasPrivilege(string Privilege)
        {
            return false;
        }
 
        public string AvatarUrl
        {
            get
            {
                if (!(this.attachments is null))
                {
                    foreach (Dictionary<string, object> Attachment in this.attachments)
                    {
                        if (Attachment.TryGetValue("ContentType", out object Obj) &&
                            Obj is string ContentType &&
                            ContentType.StartsWith("image/") &&
                            Attachment.TryGetValue("BackEndUrl", out Obj) &&
                            Obj is string BackEndUrl)
                        {
                            return Gateway.GetUrl(BackEndUrl);
                        }
                    }
                }
 
                return Gateway.GetUrl("/Images/NeuroAccess.png");
            }
        }
 
        public bool IsUserAttachment(string Url, out string AttachmentId)
        {
            if (this.attachments is null)
            {
                AttachmentId = null;
                return false;
            }
 
            foreach (Dictionary<string, object> Attachment in this.attachments)
            {
                if (Attachment.TryGetValue("Url", out object Obj) &&
                    Obj is string s &&
                    string.Compare(s, Url, true) == 0 &&
                    Attachment.TryGetValue("Id", out Obj) &&
                    Obj is string Id)
                {
                    AttachmentId = Id;
                    return true;
                }
            }
 
            AttachmentId = null;
            return false;
        }
 
        public Task<RequestOrigin> GetOrigin()
        {
            return Task.FromResult(new RequestOrigin(this.Jid, null, null, null));
        }
 
        public object this[string Key]
        {
            get
            {
                if (this.properties.TryGetValue(Key, out object Obj))
                    return Obj;
                else
                    return null;
            }
        }
 
        public Task<IEnumerable<KeyValuePair<string, object>>> CreateClaims(bool Encrypted)
        {
            int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);
            int Expires = IssuedAt + 3600;
            DateTime Now = DateTime.Now;
 
            if (this.From > Now || this.To < Now || this.State != IdentityState.Approved)
                return Task.FromResult<IEnumerable<KeyValuePair<string, object>>>(null);
 
            List<KeyValuePair<string, object>> Claims = new List<KeyValuePair<string, object>>()
                {
                    new KeyValuePair<string, object>(JwtClaims.JwtId, Convert.ToBase64String(Gateway.NextBytes(32))),
                    new KeyValuePair<string, object>(JwtClaims.Issuer, Gateway.Domain.Value),
                    new KeyValuePair<string, object>(JwtClaims.Subject, this.Jid),
                    new KeyValuePair<string, object>(JwtClaims.SubjectIdentifier, this.Id),
                    new KeyValuePair<string, object>(JwtClaims.Name, this.UserName),
                    new KeyValuePair<string, object>(JwtClaims.IssueTime, IssuedAt),
                    new KeyValuePair<string, object>(JwtClaims.ExpirationTime, Expires),
                    new KeyValuePair<string, object>(JwtClaims.Picture, this.AvatarUrl)
                };
 
            AddClaim(Claims, JwtClaims.WebSite, this["AGENT"]);
 
            if (Encrypted)
            {
                AddClaim(Claims, JwtClaims.GivenName, this["FIRST"]);
                AddClaim(Claims, JwtClaims.MiddleName, this["MIDDLE"]);
                AddClaim(Claims, JwtClaims.FamilyName, this["LAST"]);
                AddClaim(Claims, JwtClaims.EMail, this["EMAIL"]);
                AddClaim(Claims, JwtClaims.EMailVerified, "true");
                AddClaim(Claims, JwtClaims.PhoneNumber, this["PHONE"]);
                AddClaim(Claims, JwtClaims.PhoneNumberVerified, "true");
                AddClaim(Claims, JwtClaims.Gender, this["GENDER"]);
                AddClaim(Claims, JwtClaims.Nationalities, this["NATIONALITY"]);
 
                string BDay = this["BDAY"]?.ToString() ?? string.Empty;
                string BMonth = this["BMONTH"]?.ToString() ?? string.Empty;
                string BYear = this["BYEAR"]?.ToString() ?? string.Empty;
 
                if (int.TryParse(BDay, out int BDayNr) && int.TryParse(BMonth, out int BMonthNr) && int.TryParse(BYear, out int BYearNr) &&
                    BMonthNr >= 1 && BMonthNr <= 12 && BYearNr >= 1900 && BYearNr <= 2100 && BDayNr >= 1 && BDayNr <= DateTime.DaysInMonth(BYearNr, BMonthNr))
                {
                    AddClaim(Claims, JwtClaims.BirthDate, XML.Encode(new DateTime(BYearNr, BMonthNr, BDayNr)));
                }
 
                AddClaim(Claims, JwtClaims.Address, this.FullAddress);
            }
 
            return Task.FromResult<IEnumerable<KeyValuePair<string, object>>>(Claims);
        }
 
        private static void AddClaim(List<KeyValuePair<string, object>> Claims, string Key, object Value)
        {
            if (!(Value is null))
            {
                if (Value is string s && s == "N/A")
                    return;
 
                Claims.Add(new KeyValuePair<string, object>(Key, Value));
            }
        }
 
        public async Task<string> CreateToken(JwtFactory Factory, bool Encrypted)
        {
            return Factory.Create(await this.CreateClaims(Encrypted));
        }
 
    }
}