IdentityApplication.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Events.XMPP;
using Waher.Networking.SASL;
using Waher.Runtime.Collections;
 
namespace Paiwise
{
    public class IdentityApplication : IIdentityApplication
    {
        private readonly string legalId;
        private readonly Dictionary<string, ValidClaim> validatedClaims =
            new Dictionary<string, ValidClaim>();
        private readonly Dictionary<string, InvalidClaim> invalidatedClaims =
            new Dictionary<string, InvalidClaim>();
        private readonly Dictionary<string, bool> unvalidatedClaims =
            new Dictionary<string, bool>();
        private readonly Dictionary<string, ValidPhoto> validatedPhotos =
            new Dictionary<string, ValidPhoto>();
        private readonly Dictionary<string, InvalidPhoto> invalidatedPhotos =
            new Dictionary<string, InvalidPhoto>();
        private readonly Dictionary<string, IPhoto> unvalidatedPhotos =
            new Dictionary<string, IPhoto>();
        private readonly Dictionary<string, PotentialClaim> potentialClaims =
            new Dictionary<string, PotentialClaim>();
        private readonly ChunkedList<ValidationError> errors =
            new ChunkedList<ValidationError>();
        private readonly ChunkedList<object> services = new ChunkedList<object>();
        private readonly PersonalInformation personalInformation;
        private readonly KeyValuePair<string, object>[] claims;
        private readonly IEnumerable<IPhoto> photos;
        private readonly IEnumerable<XmlDocument> documents;
        private readonly IAccount account;
        private readonly object synchObj = new object();
        private readonly string @namespace;
        private readonly int nrPhotos;
        private readonly bool preview;
 
        public IdentityApplication(string LegalId, string Namespace, bool Preview,
            PersonalInformation PersonalInformation, KeyValuePair<string, object>[] Claims,
            IEnumerable<IPhoto> Photos, IAccount Account)
            : this(LegalId, Namespace, Preview, PersonalInformation, Claims, Photos,
                  Array.Empty<XmlDocument>(), Account)
        {
        }
 
        public IdentityApplication(string LegalId, string Namespace, bool Preview,
            PersonalInformation PersonalInformation, KeyValuePair<string, object>[] Claims,
            IEnumerable<IPhoto> Photos, IEnumerable<XmlDocument> Documents, IAccount Account)
        {
            this.legalId = LegalId;
            this.account = Account;
            this.@namespace = Namespace;
            this.preview = Preview;
            this.personalInformation = PersonalInformation;
            this.claims = Claims;
            this.photos = Photos;
            this.nrPhotos = 0;
            this.documents = Documents;
 
            foreach (IPhoto _ in Photos)
                this.nrPhotos++;
 
            foreach (KeyValuePair<string, object> Claim in Claims)
                this.unvalidatedClaims[Claim.Key] = true;
 
            foreach (IPhoto Photo in Photos)
                this.unvalidatedPhotos[Photo.Id] = Photo;
        }
 
        public IdentityApplication(IdentityApplication Application)
        {
            this.legalId = Application.legalId;
            this.account = Application.Account;
            this.@namespace = Application.@namespace;
            this.preview = Application.Preview;
            this.personalInformation = Application.PersonalInformation;
            this.claims = Application.Claims;
            this.photos = Application.Photos;
            this.nrPhotos = Application.NrPhotos;
            this.documents = Application.Documents;
 
            foreach (KeyValuePair<string, object> Claim in Application.Claims)
                this.unvalidatedClaims[Claim.Key] = true;
 
            foreach (IPhoto Photo in Application.Photos)
                this.unvalidatedPhotos[Photo.Id] = Photo;
        }
 
        public bool Preview => this.preview;
 
        public IAccount Account => this.account;
 
        public PersonalInformation PersonalInformation => this.personalInformation;
 
        public KeyValuePair<string, object>[] Claims => this.claims;
 
        public IEnumerable<IPhoto> Photos => this.photos;
 
        public int NrPhotos => this.nrPhotos;
 
        public IEnumerable<XmlDocument> Documents => this.documents;
 
        public void ClaimValid(string Claim, object Service)
        {
            lock (this.synchObj)
            {
                if (this.unvalidatedClaims.Remove(Claim))
                {
                    this.invalidatedClaims.Remove(Claim);
                    this.potentialClaims.Remove(Claim);
 
                    this.validatedClaims[Claim] = new ValidClaim(Claim, Service);
 
                    if (!this.services.Contains(Service))
                        this.services.Add(Service);
                }
            }
        }
 
        public void ClaimInvalid(string Claim, string Reason, string ReasonLanguage,
            string ReasonCode, object Service)
        {
            lock (this.synchObj)
            {
                if (this.unvalidatedClaims.Remove(Claim))
                {
                    this.validatedClaims.Remove(Claim);
                    this.potentialClaims.Remove(Claim);
 
                    this.invalidatedClaims[Claim] = new InvalidClaim(Claim, Reason, ReasonLanguage, ReasonCode, Service);
 
                    if (!this.services.Contains(Service))
                        this.services.Add(Service);
                }
            }
        }
 
        public void PhotoValid(IPhoto Photo, object Service)
        {
            lock (this.synchObj)
            {
                if (this.unvalidatedPhotos.Remove(Photo.Id))
                {
                    this.invalidatedPhotos.Remove(Photo.Id);
                    this.validatedPhotos[Photo.Id] = new ValidPhoto(Photo, Service);
 
                    if (!this.services.Contains(Service))
                        this.services.Add(Service);
                }
            }
        }
 
        public void PhotoInvalid(IPhoto Photo, string Reason, string ReasonLanguage,
            string ReasonCode, object Service)
        {
            lock (this.synchObj)
            {
                if (this.unvalidatedPhotos.Remove(Photo.Id))
                {
                    this.validatedPhotos.Remove(Photo.Id);
                    this.invalidatedPhotos[Photo.Id] = new InvalidPhoto(Photo, Reason, ReasonLanguage, ReasonCode, Service);
 
                    if (!this.services.Contains(Service))
                        this.services.Add(Service);
                }
            }
        }
 
        public void ReportError(string Error, string ErrorLanguage, string ErrorCode,
            ValidationErrorType ErrorType, object Service, params KeyValuePair<string, object>[] Tags)
        {
            lock (this.synchObj)
            {
                this.errors.Add(new ValidationError(ErrorType, Error, ErrorLanguage,
                    ErrorCode, Service, Tags));
 
                if (!this.services.Contains(Service))
                    this.services.Add(Service);
            }
        }
 
        public ValidClaim[] ValidatedClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    ValidClaim[] Result = new ValidClaim[this.validatedClaims.Count];
                    this.validatedClaims.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public InvalidClaim[] InvalidatedClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    InvalidClaim[] Result = new InvalidClaim[this.invalidatedClaims.Count];
                    this.invalidatedClaims.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public string[] UnvalidatedClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    string[] Result = new string[this.unvalidatedClaims.Count];
                    this.unvalidatedClaims.Keys.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public ValidPhoto[] ValidatedPhotos
        {
            get
            {
                lock (this.synchObj)
                {
                    ValidPhoto[] Result = new ValidPhoto[this.validatedPhotos.Count];
                    this.validatedPhotos.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public InvalidPhoto[] InvalidatedPhotos
        {
            get
            {
                lock (this.synchObj)
                {
                    InvalidPhoto[] Result = new InvalidPhoto[this.invalidatedPhotos.Count];
                    this.invalidatedPhotos.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public IPhoto[] UnvalidatedPhotos
        {
            get
            {
                lock (this.synchObj)
                {
                    IPhoto[] Result = new IPhoto[this.unvalidatedPhotos.Count];
                    this.unvalidatedPhotos.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public PotentialClaim[] PotentialClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    PotentialClaim[] Result = new PotentialClaim[this.potentialClaims.Count];
                    this.potentialClaims.Values.CopyTo(Result, 0);
                    return Result;
                }
            }
        }
 
        public ValidationError[] Errors
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.errors.ToArray();
                }
            }
        }
 
        public bool HasErrors
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.errors.Count > 0;
                }
            }
        }
 
        public int NrErrors
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.errors.Count;
                }
            }
        }
 
        public object[] Services
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.services.ToArray();
                }
            }
        }
 
        public bool HasServices
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.services.Count > 0;
                }
            }
        }
 
        public int NrServices
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.services.Count;
                }
            }
        }
 
        public bool? IsValid
        {
            get
            {
                lock (this.synchObj)
                {
                    if (this.invalidatedClaims.Count > 0 || this.invalidatedPhotos.Count > 0)
                        return false;
 
                    if (this.errors.Count > 0)
                    {
                        foreach (ValidationError Error in this.errors)
                        {
                            if (Error.ErrorType == ValidationErrorType.Client)
                                return false;
                        }
                    }
 
                    if (this.unvalidatedClaims.Count > 0 ||
                        this.unvalidatedPhotos.Count > 0 ||
                        this.errors.Count > 0)
                    {
                        return null;
                    }
 
                    return true;
                }
            }
        }
 
        public bool HasValidatedClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.validatedClaims.Count > 0;
                }
            }
        }
 
        public bool HasValidatedPhotos
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.validatedPhotos.Count > 0;
                }
            }
        }
 
        public bool HasPotentialClaims
        {
            get
            {
                lock (this.synchObj)
                {
                    return this.potentialClaims.Count > 0;
                }
            }
        }
 
        public KeyValuePair<string, object>[] Tags
        {
            get
            {
                lock (this.synchObj)
                {
                    ChunkedList<KeyValuePair<string, object>> Result =
                        new ChunkedList<KeyValuePair<string, object>>();
 
                    int NrServices = this.services.Count;
                    int NrErrors = this.invalidatedClaims.Count + this.invalidatedPhotos.Count + this.errors.Count;
                    int i;
 
                    if (!this.preview)
                    {
                        foreach (KeyValuePair<string, object> Claim in this.claims)
                            Result.Add(Claim);
                    }
                    else
                    if (NrServices > 0)
                    {
                        i = 0;
                        foreach (object Service in this.services)
                        {
                            Result.Add(new KeyValuePair<string, object>(
                                TagName("Authenticator", ++i, NrServices),
                                Service.GetType().Namespace));
                        }
                    }
 
                    if (NrErrors > 0)
                    {
                        i = 0;
 
                        foreach (InvalidClaim InvalidClaim in this.invalidatedClaims.Values)
                            AppendTags(Result, (ValidationError)InvalidClaim, ref i, NrErrors);
 
                        foreach (InvalidPhoto InvalidPhoto in this.invalidatedPhotos.Values)
                            AppendTags(Result, (ValidationError)InvalidPhoto, ref i, NrErrors);
 
                        foreach (ValidationError Error in this.errors)
                            AppendTags(Result, Error, ref i, NrErrors);
                    }
 
                    return Result.ToArray();
                }
            }
        }
 
        private static void AppendTags(ChunkedList<KeyValuePair<string, object>> Result,
            ValidationError Error, ref int i, int NrErrors)
        {
            i++;
 
            Result.Add(new KeyValuePair<string, object>(
                TagName("Error Type", i, NrErrors),
                Error.ErrorType.ToString()));
 
            Result.Add(new KeyValuePair<string, object>(
                TagName("Error Language", i, NrErrors),
                Error.ErrorLanguage));
 
            Result.Add(new KeyValuePair<string, object>(
                TagName("Error Code", i, NrErrors),
                Error.ErrorCode));
 
            Result.Add(new KeyValuePair<string, object>(
                TagName("Error", i, NrErrors),
                Error.ErrorMessage));
        }
 
        public void LogResults()
        {
            ChunkedList<KeyValuePair<string, object>> Result = new ChunkedList<KeyValuePair<string, object>>()
            {
                new KeyValuePair<string, object>("Result", this.IsValid),
                new KeyValuePair<string, object>("Contact", this.personalInformation.EMail)
            };
 
            lock (this.synchObj)
            {
                foreach (KeyValuePair<string, ValidClaim> Claim in this.validatedClaims)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Validator:" + Claim.Value.Service.GetType().FullName));
 
                foreach (KeyValuePair<string, ValidPhoto> Claim in this.validatedPhotos)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Validator:" + Claim.Value.Service.GetType().FullName));
 
                foreach (KeyValuePair<string, InvalidClaim> Claim in this.invalidatedClaims)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Invalidator:" + Claim.Value.Service.GetType().FullName));
 
                foreach (KeyValuePair<string, InvalidPhoto> Claim in this.invalidatedPhotos)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Invalidator:" + Claim.Value.Service.GetType().FullName));
 
                foreach (KeyValuePair<string, bool> Claim in this.unvalidatedClaims)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Unvalidated"));
 
                foreach (KeyValuePair<string, IPhoto> Claim in this.unvalidatedPhotos)
                    Result.Add(new KeyValuePair<string, object>(Claim.Key, "Unvalidated"));
            }
 
            Log.Informational("Automatic identity review concluded.", this.legalId,
                this.personalInformation.Jid, "IdReviewPerformed", Result.ToArray());
        }
 
        private static string TagName(string Base, int Index, int Nr)
        {
            if (Nr > 1)
                return Base + " " + Index.ToString();
            else
                return Base;
        }
 
        public IValidationError FirstError
        {
            get
            {
                lock (this.synchObj)
                {
                    foreach (InvalidClaim InvalidClaim in this.invalidatedClaims.Values)
                        return (ValidationError)InvalidClaim;
 
                    foreach (InvalidPhoto InvalidPhoto in this.invalidatedPhotos.Values)
                        return (ValidationError)InvalidPhoto;
 
                    foreach (ValidationError ValidationError in this.errors)
                        return ValidationError;
                }
 
                return null;
            }
        }
 
        public string GetClientErrorMessageXml(out string Language, string DefaultMessage,
            string DefaultMessageCode, string DefaultLanguage)
        {
            StringBuilder Xml = new StringBuilder();
            IValidationError Error = this.FirstError;
 
            Language = Error?.ErrorLanguage ?? DefaultLanguage;
 
            Xml.Append("<body>");
            Xml.Append(XML.Encode(Error?.ErrorMessage ?? DefaultMessage));
            Xml.Append("</body>");
            Xml.Append("<clientMessage xmlns='");
            Xml.Append(this.@namespace);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(this.legalId));
            Xml.Append("' code='");
            Xml.Append(XML.Encode(Error?.ErrorCode ?? DefaultMessageCode));
            Xml.Append("' type='");
            Xml.Append(Error?.ErrorType.ToString() ?? "Client");
            Xml.Append("'>");
 
            this.AppendApplicationStatus(Xml);
 
            Xml.Append("</clientMessage>");
 
            return Xml.ToString();
        }
 
        public string GetIdentityReviewXml()
        {
            StringBuilder Xml = new StringBuilder();
 
            Xml.Append("<identityReview xmlns='");
            Xml.Append(this.@namespace);
            Xml.Append("' id='");
            Xml.Append(XML.Encode(this.legalId));
            Xml.Append("'>");
 
            this.AppendApplicationStatus(Xml);
 
            Xml.Append("</identityReview>");
 
            return Xml.ToString();
        }
 
        private void AppendApplicationStatus(StringBuilder Xml)
        {
            lock (this.synchObj)
            {
                foreach (InvalidClaim InvalidClaim in this.invalidatedClaims.Values)
                {
                    Xml.Append("<invalidClaim claim='");
                    Xml.Append(XML.Encode(InvalidClaim.Claim));
                    Xml.Append("' message='");
                    Xml.Append(XML.Encode(InvalidClaim.Reason));
 
                    if (!string.IsNullOrEmpty(InvalidClaim.ReasonCode))
                    {
                        Xml.Append("' code='");
                        Xml.Append(XML.Encode(InvalidClaim.ReasonCode));
                    }
 
                    AppendService(Xml, InvalidClaim.Service);
 
                    if (!string.IsNullOrEmpty(InvalidClaim.ReasonLanguage))
                    {
                        Xml.Append("' xml:lang='");
                        Xml.Append(XML.Encode(InvalidClaim.ReasonLanguage));
                    }
 
                    Xml.Append("'/>");
                }
 
                foreach (InvalidPhoto InvalidPhoto in this.invalidatedPhotos.Values)
                {
                    Xml.Append("<invalidPhoto fileName='");
                    Xml.Append(XML.Encode(InvalidPhoto.Photo.FileName));
                    Xml.Append("' message='");
                    Xml.Append(XML.Encode(InvalidPhoto.Reason));
 
                    if (!string.IsNullOrEmpty(InvalidPhoto.ReasonCode))
                    {
                        Xml.Append("' code='");
                        Xml.Append(XML.Encode(InvalidPhoto.ReasonCode));
                    }
 
                    AppendService(Xml, InvalidPhoto.Service);
 
                    if (!string.IsNullOrEmpty(InvalidPhoto.ReasonLanguage))
                    {
                        Xml.Append("' xml:lang='");
                        Xml.Append(XML.Encode(InvalidPhoto.ReasonLanguage));
                    }
 
                    Xml.Append("'/>");
                }
 
                foreach (ValidationError ValidationError in this.errors)
                {
                    Xml.Append("<error message='");
                    Xml.Append(XML.Encode(ValidationError.ErrorMessage));
                    Xml.Append("' type='");
                    Xml.Append(XML.Encode(ValidationError.ErrorType.ToString()));
 
                    if (!string.IsNullOrEmpty(ValidationError.ErrorCode))
                    {
                        Xml.Append("' code='");
                        Xml.Append(XML.Encode(ValidationError.ErrorCode));
                    }
 
                    AppendService(Xml, ValidationError.Service);
 
                    if (!string.IsNullOrEmpty(ValidationError.ErrorLanguage))
                    {
                        Xml.Append("' xml:lang='");
                        Xml.Append(XML.Encode(ValidationError.ErrorLanguage));
                    }
 
                    if (ValidationError.Tags.Length == 0)
                        Xml.Append("'/>");
                    else
                    {
                        Xml.Append('>');
                        XmppEventSink.AppendTags(Xml, ValidationError.Tags);
                        Xml.Append("</error>");
                    }
                }
 
                foreach (ValidClaim ValidClaim in this.validatedClaims.Values)
                {
                    Xml.Append("<validatedClaim claim='");
                    Xml.Append(XML.Encode(ValidClaim.Claim));
                    AppendService(Xml, ValidClaim.Service);
                    Xml.Append("'/>");
                }
 
                foreach (ValidPhoto ValidPhoto in this.validatedPhotos.Values)
                {
                    Xml.Append("<validatedPhoto fileName='");
                    Xml.Append(XML.Encode(ValidPhoto.Photo.FileName));
                    AppendService(Xml, ValidPhoto.Service);
                    Xml.Append("'/>");
                }
 
                foreach (PotentialClaim PotentialClaim in this.potentialClaims.Values)
                {
                    if (PotentialClaim.InformUser)
                    {
                        Xml.Append("<potentialClaim claim='");
                        Xml.Append(XML.Encode(PotentialClaim.Claim));
                        Xml.Append("' value='");
                        Xml.Append(XML.Encode(PotentialClaim.Value?.ToString() ?? string.Empty));
                        AppendService(Xml, PotentialClaim.Service);
                        Xml.Append("'/>");
                    }
                }
 
                foreach (string UnvalidatedClaim in this.unvalidatedClaims.Keys)
                {
                    Xml.Append("<unvalidatedClaim claim='");
                    Xml.Append(XML.Encode(UnvalidatedClaim));
                    Xml.Append("'/>");
                }
 
                foreach (IPhoto UnvalidatedPhoto in this.unvalidatedPhotos.Values)
                {
                    Xml.Append("<unvalidatedPhoto fileName='");
                    Xml.Append(XML.Encode(UnvalidatedPhoto.FileName));
                    Xml.Append("'/>");
                }
            }
        }
 
        private static void AppendService(StringBuilder Xml, object Service)
        {
            if (!(Service is null))
            {
                Xml.Append("' service='");
 
                if (Service is Type T)
                    Xml.Append(XML.Encode(T.FullName));
                else
                    Xml.Append(XML.Encode(Service.GetType().FullName));
            }
        }
 
        public void ValidateAllClaims()
        {
            foreach (KeyValuePair<string, object> Claim in this.Claims)
                this.ClaimValid(Claim.Key, this);
        }
 
        public void ValidateAllPhotos()
        {
            foreach (IPhoto Photo in this.Photos)
                this.PhotoValid(Photo, this);
        }
 
        public void InvalidateAllClaims(string Reason, string ReasonLanguage,
            string ReasonCode)
        {
            foreach (KeyValuePair<string, object> Claim in this.Claims)
                this.ClaimInvalid(Claim.Key, Reason, ReasonLanguage, ReasonCode, this);
        }
 
 
        public void InvalidateAllPhotos(string Reason, string ReasonLanguage,
            string ReasonCode)
        {
            foreach (IPhoto Photo in this.Photos)
                this.PhotoInvalid(Photo, Reason, ReasonLanguage, ReasonCode, this);
        }
 
        public bool TryGetValue<T>(string Claim, object Value, object Service, out T TypedValue)
        {
            if (Value is T Typed)
            {
                TypedValue = Typed;
                return true;
            }
            else
            {
                this.ClaimInvalid(Claim, "Expected value of type " + typeof(T).FullName + ".",
                    "en", "InvalidType", Service);
 
                TypedValue = default;
                return false;
            }
        }
 
        public void AddPotentialClaims(string Claim, object Value, bool InformUser, object Service)
        {
            lock (this.synchObj)
            {
                if (!this.unvalidatedClaims.Remove(Claim))
                {
                    if (this.invalidatedClaims.ContainsKey(Claim) ||
                        this.validatedClaims.ContainsKey(Claim) ||
                        this.potentialClaims.ContainsKey(Claim))
                    {
                        return;
                    }
                }
 
                this.validatedClaims.Remove(Claim);
                this.invalidatedClaims.Remove(Claim);
 
                this.potentialClaims[Claim] = new PotentialClaim(Claim, Value, InformUser, Service);
                
                if (!this.services.Contains(Service))
                    this.services.Add(Service);
            }
        }
    }
}