QuickLoginUser.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Xml;
using Waher.Events.XMPP;
using Waher.IoTGateway;
using Waher.Networking.XMPP.Contracts;
using Waher.Persistence;
using Waher.Runtime.Collections;
using Waher.Security;
using Waher.Security.JWT;
using Waher.Security.Users;
using Waher.Things;
 
namespace Waher.Service.IoTBroker.Legal.MFA
{
    public class QuickLoginUser : IUserWithClaims, ILegalIdentityUser, 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 ILegalIdentity LegalIdentity => this.id;
 
        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 Networking.XMPP.Contracts.IdentityState State => this.id.State;
 
        public string UserName
        {
            get
            {
                string s = this.id[PersonalInformation.JidTag];
                if (string.IsNullOrEmpty(s))
                    s = this.id.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.id[PersonalInformation.JidTag];
                return string.IsNullOrEmpty(s) ? this.id.Id : s;
            }
        }
 
        public string FriendlyName
        {
            get
            {
                if (this.properties.ContainsKey(PersonalInformation.FirstNameTag) && 
                    this.properties.ContainsKey(PersonalInformation.LastNamesTag))
                {
                    StringBuilder sb = null;
 
                    this.Append(ref sb, PersonalInformation.FirstNameTag, " ");
                    this.Append(ref sb, PersonalInformation.MiddleNamesTag, " ");
                    this.Append(ref sb, PersonalInformation.LastNamesTag, " ");
 
                    return sb?.ToString() ?? "N/A";
                }
                else if (this.properties.TryGetValue(PersonalInformation.FullNameTag, out object FullName))
                    return FullName?.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[..i];
 
                    if (Guid.TryParse(LocalPart, out _) && !(this.id is null))
                    {
                        string EMail = this.id[PersonalInformation.EMailTag];
                        if (!string.IsNullOrEmpty(EMail))
                            return EMail;
 
                        string PhoneNr = this.id[PersonalInformation.PhoneTag];
                        if (!string.IsNullOrEmpty(PhoneNr))
                            return PhoneNr;
                    }
 
                    string Domain = s[(i + 1)..];
 
                    if (Gateway.IsDomain(Domain, true))
                        return LocalPart;
                    else
                        return s;
                }
            }
        }
 
        public string FullAddress
        {
            get
            {
                StringBuilder sb = null;
 
                this.Append(ref sb, PersonalInformation.AddressTag, ", ");
                this.Append(ref sb, PersonalInformation.Address2Tag, ", ");
                this.Append(ref sb, PersonalInformation.AreaTag, ", ");
                this.Append(ref sb, PersonalInformation.PostalCodeTag, ", ");
                this.Append(ref sb, PersonalInformation.CityTag, ", ");
                this.Append(ref sb, PersonalInformation.RegionTag, ", ");
                this.Append(ref sb, PersonalInformation.CountryTag, ", ");
 
                if (!(sb is null))
                    return sb.ToString();
 
                this.Append(ref sb, PersonalInformation.OrganizationNameTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationDepartmentTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationAddressTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationAddress2Tag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationAreaTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationPostalCodeTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationCityTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationRegionTag, ", ");
                this.Append(ref sb, PersonalInformation.OrganizationCountryTag, ", ");
 
                return sb?.ToString() ?? "N/A";
            }
        }
 
        public string Jid
        {
            get
            {
                if (this.properties.TryGetValue(PersonalInformation.JidTag, 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, this));
        }
 
        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 != Networking.XMPP.Contracts.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[PersonalInformation.AgentTag]);
 
            if (Encrypted)
            {
                CaseInsensitiveString FirstName = this[PersonalInformation.FirstNameTag]?.ToString() ?? string.Empty;
                CaseInsensitiveString MiddleNames = this[PersonalInformation.MiddleNamesTag]?.ToString() ?? string.Empty;
                CaseInsensitiveString LastNames = this[PersonalInformation.LastNamesTag]?.ToString() ?? string.Empty;
                CaseInsensitiveString FullName = this[PersonalInformation.FullNameTag]?.ToString() ?? string.Empty;
 
                if (CaseInsensitiveString.IsNullOrEmpty(FullName))
                    FullName = Networking.XMPP.Contracts.LegalIdentity.JoinNames(FirstName, MiddleNames, LastNames);
                else
                    Networking.XMPP.Contracts.LegalIdentity.SeparateNames(FullName, out FirstName, out MiddleNames, out LastNames);
 
                AddClaim(Claims, JwtClaims.Name, FullName);
                AddClaim(Claims, JwtClaims.GivenName, FirstName);
                AddClaim(Claims, JwtClaims.MiddleName, MiddleNames);
                AddClaim(Claims, JwtClaims.FamilyName, LastNames);
                AddClaim(Claims, JwtClaims.Address, this.FullAddress);
 
                string BDay = null;
                string BMonth = null;
                string BYear = null;
 
                foreach (KeyValuePair<string, object> P in this.properties)
                {
                    switch (P.Key)
                    {
                        case PersonalInformation.AgentTag:
                        case PersonalInformation.FirstNameTag:
                        case PersonalInformation.MiddleNamesTag:
                        case PersonalInformation.LastNamesTag:
                        case PersonalInformation.FullNameTag:
                        case PersonalInformation.AddressTag:
                        case PersonalInformation.Address2Tag:
                        case PersonalInformation.FullAddressTag:
                        case PersonalInformation.JidTag:
                            break;
 
                        case PersonalInformation.EMailTag:
                            AddClaim(Claims, JwtClaims.EMail, P.Value);
                            AddClaim(Claims, JwtClaims.EMailVerified, "true");
                            break;
 
                        case PersonalInformation.PhoneTag:
                            AddClaim(Claims, JwtClaims.PhoneNumber, P.Value);
                            AddClaim(Claims, JwtClaims.PhoneNumberVerified, "true");
                            break;
 
                        case PersonalInformation.GenderTag:
                            AddClaim(Claims, JwtClaims.Gender, P.Value);
                            break;
 
                        case PersonalInformation.NationalityTag:
                            AddClaim(Claims, JwtClaims.Nationalities, P.Value);
                            break;
 
                        case PersonalInformation.BirthDayTag:
                            BDay = P.Value?.ToString();
                            break;
 
                        case PersonalInformation.BirthMonthTag:
                            BMonth = P.Value?.ToString();
                            break;
 
                        case PersonalInformation.BirthYearTag:
                            BYear = P.Value?.ToString();
                            break;
 
                        case PersonalInformation.AgeAboveTag:
                            AddClaim(Claims, "age_above", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationNameTag: 
                            AddClaim(Claims, "org_name", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationNumberTag:
                            AddClaim(Claims, "org_nr", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationDepartmentTag:
                            AddClaim(Claims, "org_dept", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationRoleTag:
                            AddClaim(Claims, "org_role", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationAddressTag:
                            AddClaim(Claims, "org_addr", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationAddress2Tag:
                            AddClaim(Claims, "org_addr2", P.Value);
                            break;
 
                        case "ORGZIP ":
                            AddClaim(Claims, "org_zip", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationAreaTag:
                            AddClaim(Claims, "org_area", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationCityTag:
                            AddClaim(Claims, "org_city", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationRegionTag:
                            AddClaim(Claims, "org_region", P.Value);
                            break;
 
                        case PersonalInformation.OrganizationCountryTag:
                            AddClaim(Claims, "org_country", P.Value);
                            break;
                    }
                }
 
                if (!string.IsNullOrEmpty(BDay) &&
                    !string.IsNullOrEmpty(BMonth) &&
                    !string.IsNullOrEmpty(BYear) &&
                    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)));
                }
            }
 
            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,
            params KeyValuePair<string, object>[] AdditionalClaims)
        {
            IEnumerable<KeyValuePair<string, object>> Claims = await this.CreateClaims(Encrypted);
            Claims = JwtFactory.JoinClaims(Claims, AdditionalClaims);
            return Factory.Create(Claims);
        }
 
        public string ExportXml()
        {
            StringBuilder Xml = new StringBuilder();
            this.ExportXml(Xml);
            return Xml.ToString();
        }
 
        public void ExportXml(StringBuilder Xml)
        {
            Xml.Append("<quickLoginUser xmlns='");
            Xml.Append(QuickLogin.NamespaceTagSignature);
            Xml.Append("' key='");
            Xml.Append(XML.Encode(this.petitionId));
            Xml.Append("'>");
 
            this.id.Serialize(Xml, true, true, true, true, true, true, true);
 
            if (!(this.properties is null))
            {
                Xml.Append("<properties>");
                Waher.Events.XMPP.XmppEventSink.AppendTags(Xml, this.properties);
                Xml.Append("</properties>");
            }
 
            if (!(this.attachments is null))
            {
                Xml.Append("<attachments>");
 
                foreach (Dictionary<string, object> Attachment in this.attachments)
                {
                    Xml.Append("<attachment>");
                    XmppEventSink.AppendTags(Xml, Attachment);
                    Xml.Append("</attachment>");
                }
 
                Xml.Append("</attachments>");
            }
 
            Xml.Append("</quickLoginUser>");
        }
 
        public static bool TryParse(XmlElement Xml, out QuickLoginUser User, out string Reason)
        {
            User = null;
 
            if (Xml is null)
            {
                Reason = new ArgumentNullException(nameof(Xml)).Message;
                return false;
            }
 
            if (Xml.LocalName != "quickLoginUser" || Xml.NamespaceURI != QuickLogin.NamespaceTagSignature)
            {
                Reason = "Not a quick-login user element.";
                return false;
            }
 
            string PetitionId = XML.Attribute(Xml, "key");
            if (string.IsNullOrEmpty(PetitionId))
            {
                Reason = "Missing or empty key.";
                return false;
            }
 
            LegalIdentity Id = null;
            Dictionary<string, object> Properties = null;
            ChunkedList<Dictionary<string, object>> Attachments = new ChunkedList<Dictionary<string, object>>();
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                if (!(N is XmlElement E))
                    continue;
 
                switch (E.LocalName)
                {
                    case "identity":
                        try
                        {
                            Id = Networking.XMPP.Contracts.LegalIdentity.Parse(E);
                        }
                        catch (Exception ex)
                        {
                            Reason = ex.Message;
                            return false;
                        }
                        break;
 
                    case "properties":
                        Properties = ParseTags(E);
                        break;
 
                    case "attachments":
                        foreach (XmlNode N2 in E.ChildNodes)
                        {
                            if (N2 is XmlElement E2 && E2.LocalName == "attachment")
                                Attachments.Add(ParseTags(E2));
                        }
                        break;
                }
            }
 
            if (Id is null)
            {
                Reason = "Missing legal identity.";
                return false;
            }
 
            Reason = null;
            User = new QuickLoginUser(Id, PetitionId, 
                Properties ?? new Dictionary<string, object>(), 
                Attachments.ToArray());
 
            return true;
        }
 
        private static Dictionary<string, object> ParseTags(XmlElement E)
        {
            Dictionary<string, object> Tags = new Dictionary<string, object>();
 
            foreach (XmlNode N2 in E.ChildNodes)
            {
                if (N2 is XmlElement E2 && E2.LocalName == "tag")
                {
                    string TagName = XML.Attribute(E2, "name");
                    string TagValue = XML.Attribute(E2, "value");
                    string TagType = XML.Attribute(E2, "type");
 
                    if (!XmppEventReceptor.TryParse(TagValue, TagType, out object TagValueParsed))
                        TagValueParsed = TagValue;
 
                    Tags[TagName] = TagValueParsed;
                }
            }
 
            return Tags;
        }
    }
}