IdentityReviewEventArgs.cs

using System;
using Waher.Networking.XMPP.Events;
 
namespace Waher.Networking.XMPP.Contracts.EventArguments
{
    public class IdentityReviewEventArgs : MessageEventArgs
    {
        private readonly string legalId;
        private InvalidClaim[] invalidClaims;
        private InvalidPhoto[] invalidPhotos;
        private ValidationError[] validationErrors;
        private ValidClaim[] validClaims;
        private ValidPhoto[] validPhotos;
        private PotentialClaim[] potentialClaims;
        private string[] unvalidatedClaims;
        private string[] unvalidatedPhotos;
 
        public IdentityReviewEventArgs(MessageEventArgs e, string LegalId)
            : this(e, LegalId, null, null, null, null, null, null, null, null)
        {
        }
 
        public IdentityReviewEventArgs(MessageEventArgs e, string LegalId,
            InvalidClaim[] InvalidClaims, InvalidPhoto[] InvalidPhotos,
            ValidationError[] ValidationErrors, ValidClaim[] ValidClaims,
            ValidPhoto[] ValidPhotos, string[] UnvalidatedClaims, 
            string[] UnvalidatedPhotos)
            : this(e, LegalId, InvalidClaims, InvalidPhotos, ValidationErrors,
                  ValidClaims, ValidPhotos, null, UnvalidatedClaims, UnvalidatedPhotos) 
        {
        }
 
        public IdentityReviewEventArgs(MessageEventArgs e, string LegalId, 
            InvalidClaim[] InvalidClaims, InvalidPhoto[] InvalidPhotos, 
            ValidationError[] ValidationErrors, ValidClaim[] ValidClaims, 
            ValidPhoto[] ValidPhotos, PotentialClaim[] PotentialClaims,
            string[] UnvalidatedClaims, string[] UnvalidatedPhotos)
            : base(e)
        {
            this.legalId = LegalId;
            this.invalidClaims = InvalidClaims ?? Array.Empty<InvalidClaim>();
            this.invalidPhotos = InvalidPhotos ?? Array.Empty<InvalidPhoto>();
            this.validationErrors = ValidationErrors ?? Array.Empty<ValidationError>();
            this.validClaims = ValidClaims ?? Array.Empty<ValidClaim>();
            this.validPhotos = ValidPhotos ?? Array.Empty<ValidPhoto>();
            this.potentialClaims = PotentialClaims ?? Array.Empty<PotentialClaim>();
            this.unvalidatedClaims = UnvalidatedClaims ?? Array.Empty<string>();
            this.unvalidatedPhotos = UnvalidatedPhotos ?? Array.Empty<string>();
        }
 
        public string LegalId => this.legalId;
 
        public InvalidClaim[] InvalidClaims
        {
            get => this.invalidClaims;
            internal set => this.invalidClaims = value ?? Array.Empty<InvalidClaim>();
        }
 
        public InvalidPhoto[] InvalidPhotos
        {
            get => this.invalidPhotos;
            internal set => this.invalidPhotos = value ?? Array.Empty<InvalidPhoto>();
        }
 
        public ValidationError[] ValidationErrors
        {
            get => this.validationErrors;
            internal set => this.validationErrors = value ?? Array.Empty<ValidationError>();
        }
 
        public ValidClaim[] ValidClaims
        {
            get => this.validClaims;
            internal set => this.validClaims = value ?? Array.Empty<ValidClaim>();
        }
 
        public ValidPhoto[] ValidPhotos
        {
            get => this.validPhotos;
            internal set => this.validPhotos = value ?? Array.Empty<ValidPhoto>();
        }
 
        public PotentialClaim[] PotentialClaims
        {
            get => this.potentialClaims;
            internal set => this.potentialClaims = value ?? Array.Empty<PotentialClaim>();
        }
 
        public string[] UnvalidatedClaims
        {
            get => this.unvalidatedClaims;
            internal set => this.unvalidatedClaims = value ?? Array.Empty<string>();
        }
 
        public string[] UnvalidatedPhotos
        {
            get => this.unvalidatedPhotos;
            internal set => this.unvalidatedPhotos = value ?? Array.Empty<string>();
        }
 
        public bool? IsValid
        {
            get
            {
                if (this.invalidClaims.Length > 0 || this.invalidPhotos.Length > 0)
                    return false;
 
                if (this.validationErrors.Length > 0)
                {
                    foreach (ValidationError Error in this.validationErrors)
                    {
                        if (Error.ErrorType == ValidationErrorType.Client)
                            return false;
                    }
                }
 
                if (this.unvalidatedClaims.Length > 0 ||
                    this.unvalidatedPhotos.Length > 0 ||
                    this.validationErrors.Length > 0)
                {
                    return null;
                }
 
                return true;
            }
        }
 
        public bool HasErrors => this.validationErrors.Length > 0;
 
        public int NrErrors => this.validationErrors.Length;
 
        public bool HasValidatedClaims => this.validClaims.Length > 0;
 
        public bool HasValidatedPhotos => this.validPhotos.Length > 0;
 
        public bool HasPotentialClaims => this.potentialClaims.Length > 0;
    }
}