d2/d39/_add_id_attachment_8cs_source.html

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;

using Waher.IoTGateway;

using Waher.Networking.HTTP;

using Waher.Networking.XMPP.P2P.E2E;

using Waher.Networking.XMPP.Server;

using Waher.Persistence;

using Waher.Persistence.Filters;

using Waher.Runtime.Temporary;

using Waher.Runtime.Threading;

using Waher.Script;

using Waher.Script.Abstraction.Elements;

using Waher.Security;

using Waher.Service.IoTBroker.DataStorage;

using Waher.Service.IoTBroker.Legal;

using Waher.Service.IoTBroker.Legal.Attachments;

using Waher.Service.IoTBroker.Legal.Identity;

using Waher.Service.IoTBroker.Setup;

using Waher.Service.IoTBroker.WebServices.Agent.Crypto;

using static Waher.Service.IoTBroker.Legal.LegalComponent;


namespace Waher.Service.IoTBroker.WebServices.Agent.Legal

{

    public class AddIdAttachment : AgentPostResource

    {

        public AddIdAttachment()

            : base("Legal/AddIdAttachment",

                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),

                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))

        {

        }


        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(AddIdAttachment).Namespace + ".JSON.AddIdAttachment.req");

        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(AddIdAttachment).Namespace + ".XML.AddIdAttachment.req");


        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)

        {

            AccountUser User = AssertUserAuthenticated(Request);


            string KeyId = (string)Parameters["PKeyId"].AssociatedObjectValue;

            string Nonce = (string)Parameters["PNonce"].AssociatedObjectValue;

            string KeySignature = (string)Parameters["PKeySignature"].AssociatedObjectValue;

            string RequestSignature = (string)Parameters["PRequestSignature"].AssociatedObjectValue;

            CaseInsensitiveString LegalId = (string)Parameters["PLegalId"].AssociatedObjectValue;

            string AttachmentBase64 = (string)Parameters["PAttachmentBase64"].AssociatedObjectValue;

            string AttachmentFileName = (string)Parameters["PAttachmentFileName"].AssociatedObjectValue;

            string AttachmentContentType = (string)Parameters["PAttachmentContentType"].AssociatedObjectValue;

            StringBuilder sb = new StringBuilder();

            byte[] Attachment;

            object DecodedAttachment;


            if (string.IsNullOrEmpty(KeyId))

                throw new BadRequestException("Key ID cannot be empty.");


            if (string.IsNullOrEmpty(Nonce) || Nonce.Length < 32)

                throw new ForbiddenException("Nonce too short.");


            using (Semaphore Semaphore = await Semaphores.BeginWrite("iotid:" + LegalId.LowerCase))

            {

                LegalIdentity Identity = await LegalComponent.GetLocalLegalIdentity(LegalId)

                    ?? throw new NotFoundException("Legal identity not found.");


                if (Identity.Account != User.UserName)

                    throw new ForbiddenException("Only allowed to add attachments to your own legal identities.");


                if (Identity.State != IdentityState.Created)

                    throw new ForbiddenException("Attachments can only be added to newly created identities before they are approved.");


                IAccount Account = await XmppServerModule.GetAccountAsync(Identity.Account)

                    ?? throw new ForbiddenException("Account has been removed.");


                if (!Account.Enabled)

                    throw new ForbiddenException("Account has been disabled.");


                AgentKey AgentKey = await Database.FindFirstDeleteRest<AgentKey>(new FilterAnd(

                    new FilterFieldEqualTo("Account", User.UserName),

                    new FilterFieldEqualTo("Id", KeyId)))

                    ?? throw new NotFoundException("Key not found.");


                sb.Append(User.UserName);

                sb.Append(':');

                sb.Append(Request.Header.Host.Value);

                sb.Append(':');

                sb.Append(AgentKey.LocalName);

                sb.Append(':');

                sb.Append(AgentKey.Namespace);

                sb.Append(':');

                sb.Append(KeyId);


                //string s1 = sb.ToString();


                sb.Append(':');

                sb.Append(KeySignature);


                string s2 = sb.ToString();


                sb.Append(':');

                sb.Append(Nonce);

                sb.Append(':');

                sb.Append(AttachmentBase64);

                sb.Append(':');

                sb.Append(AttachmentFileName);

                sb.Append(':');

                sb.Append(AttachmentContentType);


                string s3 = sb.ToString();


                string s = Convert.ToBase64String(

                    Hashes.ComputeHMACSHA256Hash(

                        Encoding.UTF8.GetBytes(User.Account.Password),

                        Encoding.UTF8.GetBytes(s3)));


                if (s != RequestSignature)

                {

                    string Msg = "Request Signature invalid.";

                    throw new ForbiddenException(Msg);

                }


                if (await this.Api.HasNonceBeenUsed(Nonce))

                {

                    string Msg = "Nonce value has already been used.";

                    throw new ForbiddenException(Msg);

                }


                await this.Api.RegisterNonceValue(Nonce);


                try

                {

                    Attachment = Convert.FromBase64String(AttachmentBase64);

                    DecodedAttachment = await InternetContent.DecodeAsync(AttachmentContentType, Attachment, null);

                }

                catch (Exception)

                {

                    throw new BadRequestException("Invalid attachment.");

                }


                try

                {

                    EllipticCurveEndpoint KeyEndpoint = ApplyId.GetEndpoint(AgentKey, s2);

                    byte[] AttachmentSignature = KeyEndpoint.Sign(Attachment);


                    if (!(Identity.Attachments is null))

                    {

                        string AttachmentSignatureBase64 = Convert.ToBase64String(AttachmentSignature);


                        foreach (AttachmentReference Ref in Identity.Attachments)

                        {

                            if (Convert.ToBase64String(Ref.Signature) == s)

                                throw new BadRequestException("Attachment already assigned to identity.");

                        }

                    }


                    bool IncNrPeerReviews = false;

                    List<LegalIdentity> Reviewers = null;

                    string LegalNamespace = NamespaceLegalIdentity(Identity.Version);


                    if (DecodedAttachment is XmlDocument Doc)

                    {

                        if (Doc.DocumentElement.LocalName == "peerReview" && Doc.DocumentElement.NamespaceURI == LegalNamespace)

                        {

                            LegalIdentity ReviewedIdentity = null;

                            LegalIdentity ReviewerIdentity = null;

                            CaseInsensitiveString ReviewedJid = CaseInsensitiveString.Empty;

                            CaseInsensitiveString ReviewerJid = CaseInsensitiveString.Empty;

                            bool ReviewedHasStatus = false;

                            bool ReviewerHasStatus = false;

                            byte[] PeerSignature = Convert.FromBase64String(XML.Attribute(Doc.DocumentElement, "s"));

                            DateTime TP = XML.Attribute(Doc.DocumentElement, "tp", DateTime.Now);

                            byte[] SignedIdentity = null;

                            DateTime Now = DateTime.Now;


                            foreach (XmlNode N in Doc.DocumentElement.ChildNodes)

                            {

                                if (!(N is XmlElement E) || N.NamespaceURI != LegalNamespace)

                                    continue;


                                foreach (XmlNode N2 in E.ChildNodes)

                                {

                                    if (N2 is XmlElement E2 &&

                                        E2.LocalName == "identity" &&

                                        E2.NamespaceURI == LegalNamespace)

                                    {

                                        switch (E.LocalName)

                                        {

                                            case "reviewed":

                                                ReviewedIdentity = LegalIdentity.Parse(E2, out ReviewedHasStatus,

                                                    out Dictionary<string, string> ReviewedIdentityAttachmentsUrls);


                                                sb.Clear();

                                                ReviewedIdentity.Serialize(sb, true, true, true, false, false, false, false, null, XmppServerModule.Legal);

                                                string s1 = sb.ToString();


                                                sb.Clear();

                                                Identity.Serialize(sb, true, true, true, false, false, false, false, null, XmppServerModule.Legal);

                                                s2 = sb.ToString();


                                                if (s1 != s2)

                                                    throw new ForbiddenException("Reviewed identity mismatch.");


                                                sb.Clear();

                                                ReviewedIdentity.Serialize(sb, true, true, true, true, true, true, true, ReviewedIdentityAttachmentsUrls, XmppServerModule.Legal);

                                                SignedIdentity = Encoding.UTF8.GetBytes(sb.ToString());

                                                break;


                                            case "reviewer":

                                                ReviewerIdentity = LegalIdentity.Parse(E2, out ReviewerHasStatus,

                                                    out Dictionary<string, string> ReviewerIdentityAttachmentsUrls);


                                                sb.Clear();

                                                ReviewerIdentity.Serialize(sb, false, false, false, false, false, false, false, null, XmppServerModule.Legal);

                                                byte[] Data = Encoding.UTF8.GetBytes(sb.ToString());

                                                ReviewerJid = ReviewerIdentity["JID"];


                                                if (!CaseInsensitiveString.IsNullOrEmpty(ReviewerJid))

                                                {

                                                    (ReviewerIdentity, _) = await XmppServerModule.Legal.ValidateSignature(new XmppAddress(ReviewerJid), TP, Data, ReviewerIdentity.ClientSignature);

                                                    if (ReviewerIdentity is null || ReviewerJid != ReviewerIdentity["JID"])

                                                        throw new ForbiddenException("Peer identity signature invalid.");

                                                }


                                                if (ReviewerIdentity.State != IdentityState.Approved)

                                                    throw new ForbiddenException("Reviewer identity not approved.");


                                                if (Now.Date.AddDays(1) < ReviewerIdentity.From ||

                                                    Now.Date.AddDays(-1) > ReviewerIdentity.To)

                                                {

                                                    throw new ForbiddenException("Reviewer identity not valid.");

                                                }


                                                if (CaseInsensitiveString.IsNullOrEmpty(ReviewerIdentity.Provider))

                                                    throw new ForbiddenException("Reviewer identity lacks a provider.");


                                                if (string.IsNullOrEmpty(ReviewerIdentity.ClientKeyName) ||

                                                    ReviewerIdentity.ClientPubKey is null ||

                                                    ReviewerIdentity.ClientPubKey.Length == 0)

                                                {

                                                    throw new ForbiddenException("Reviewer identity lacks a key.");

                                                }


                                                if (ReviewerIdentity.ClientSignature is null ||

                                                    ReviewerIdentity.ClientSignature.Length == 0)

                                                {

                                                    throw new ForbiddenException("Reviewer identity lacks a signature.");

                                                }


                                                if (CaseInsensitiveString.IsNullOrEmpty(ReviewerJid))

                                                {

                                                    throw new ForbiddenException("Reviewer identity not trusted for reviewing.");

                                                }


                                                break;

                                        }

                                    }

                                }

                            }


                            if (ReviewedIdentity is null || !ReviewedHasStatus ||

                                ReviewerIdentity is null || !ReviewerHasStatus ||

                                SignedIdentity is null)

                            {

                                throw new ForbiddenException("Attachment not a correctly formed peer-review document.");

                            }


                            CaseInsensitiveString Pnr = ReviewedIdentity["PNR"];


                            if (Pnr == ReviewerIdentity["PNR"] && !CaseInsensitiveString.IsNullOrEmpty(Pnr))

                                throw new ForbiddenException("Reviewer cannot be the same person as the reviewed person.");


                            if (!ReviewerIdentity.ValidateSignature(SignedIdentity, PeerSignature))

                                throw new ForbiddenException("Peer signature invalid.");


                            if (PeerReviewConfiguration.Instance?.AllowPeerReview ?? false)

                            {

                                int NrPhotos = 0;


                                if (!(Identity.Attachments is null))

                                {

                                    foreach (AttachmentReference Ref in Identity.Attachments)

                                    {

                                        if (Ref.ContentType.StartsWith("image/"))

                                            NrPhotos++;

                                    }

                                }


                                if (NrPhotos < PeerReviewConfiguration.Instance.NrPhotosRequired)

                                {

                                    throw new ForbiddenException("Peer review not accepted: Identity lacks sufficient photos (" +

                                        PeerReviewConfiguration.Instance.NrPhotosRequired.ToString() + ").");

                                }


                                PersonalInfo RI = GetPersonalInfo(ReviewerIdentity);


                                if (PeerReviewConfiguration.Instance.RequireFirstName && CaseInsensitiveString.IsNullOrEmpty(RI.FirstName))

                                    throw new BadRequestException("Reviewer identity lacks a First name. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireMiddleName && CaseInsensitiveString.IsNullOrEmpty(RI.MiddleNames))

                                    throw new BadRequestException("Reviewer identity lacks a Middle name. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireLastName && CaseInsensitiveString.IsNullOrEmpty(RI.LastNames))

                                    throw new BadRequestException("Reviewer identity lacks a Last name. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequirePersonalNumber && CaseInsensitiveString.IsNullOrEmpty(RI.PersonalNumber))

                                    throw new BadRequestException("Reviewer identity lacks a Personal number. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireAddress && CaseInsensitiveString.IsNullOrEmpty(RI.Address))

                                    throw new BadRequestException("Reviewer identity lacks an address. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequirePostalCode && CaseInsensitiveString.IsNullOrEmpty(RI.PostalCode))

                                    throw new BadRequestException("Reviewer identity lacks a Postal Code (ZIP). Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireArea && CaseInsensitiveString.IsNullOrEmpty(RI.Area))

                                    throw new BadRequestException("Reviewer identity lacks an Area. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireCity && CaseInsensitiveString.IsNullOrEmpty(RI.City))

                                    throw new BadRequestException("Reviewer identity lacks a City. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireRegion && CaseInsensitiveString.IsNullOrEmpty(RI.Region))

                                    throw new BadRequestException("Reviewer identity lacks a Region. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireCountry && CaseInsensitiveString.IsNullOrEmpty(RI.Country))

                                    throw new BadRequestException("Reviewer identity lacks a Country. Peer review not accepted.");


                                if (!CaseInsensitiveString.IsNullOrEmpty(RI.Country))

                                {

                                    if (PeerReviewConfiguration.Instance.RequireIso3166Compliance && !Iso3166.TryGetCountry(RI.Country, out string _))

                                        throw new BadRequestException("Reviewer Country is not an ISO 3166-1 Country Code. Peer review not accepted.");


                                    if (!CaseInsensitiveString.IsNullOrEmpty(RI.PersonalNumber))

                                    {

                                        bool? Valid = await PersonalNumberSchemes.IsValid(RI.Country, RI.PersonalNumber);

                                        if (Valid.HasValue && !Valid.Value)

                                            throw new BadRequestException("The personal number format used by the reviewer does not comply with regulations.");

                                    }

                                }


                                if (PeerReviewConfiguration.Instance.RequireNationality && CaseInsensitiveString.IsNullOrEmpty(RI.Nationality))

                                    throw new BadRequestException("Reviewer identity lacks a Nationality. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireGender && !RI.Gender.HasValue)

                                    throw new BadRequestException("Reviewer identity lacks a Gender. Peer review not accepted.");


                                if (PeerReviewConfiguration.Instance.RequireBirthDate && !RI.BirthDate.HasValue)

                                    throw new BadRequestException("Reviewer identity lacks a Birth Date. Peer review not accepted.");


                                if (RI.HasOrg)

                                {

                                    if (CaseInsensitiveString.IsNullOrEmpty(RI.OrgName))    // TODO: Configurable

                                        throw new BadRequestException("Reviewer identity lacks an organization name. Peer review not accepted.");


                                    if (CaseInsensitiveString.IsNullOrEmpty(RI.OrgDepartment))  // TODO: Configurable

                                        throw new BadRequestException("Reviewer identity lacks a department. Peer review not accepted.");


                                    if (CaseInsensitiveString.IsNullOrEmpty(RI.OrgRole))    // TODO: Configurable

                                        throw new BadRequestException("Reviewer identity lacks a role. Peer review not accepted.");


                                    if (CaseInsensitiveString.IsNullOrEmpty(RI.OrgNumber))  // TODO: Configurable

                                        throw new BadRequestException("Reviewer identity lacks an organization number. Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequireAddress && CaseInsensitiveString.IsNullOrEmpty(RI.OrgAddress))

                                        throw new BadRequestException("Reviewer identity lacks an organization address. Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequirePostalCode && CaseInsensitiveString.IsNullOrEmpty(RI.OrgPostalCode))

                                        throw new BadRequestException("Reviewer identity lacks an organization Postal Code (ZIP). Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequireArea && CaseInsensitiveString.IsNullOrEmpty(RI.OrgArea))

                                        throw new BadRequestException("Reviewer identity lacks an organization Area. Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequireCity && CaseInsensitiveString.IsNullOrEmpty(RI.OrgCity))

                                        throw new BadRequestException("Reviewer identity lacks an organization City. Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequireRegion && CaseInsensitiveString.IsNullOrEmpty(RI.OrgRegion))

                                        throw new BadRequestException("Reviewer identity lacks an organization Region. Peer review not accepted.");


                                    if (PeerReviewConfiguration.Instance.RequireCountry && CaseInsensitiveString.IsNullOrEmpty(RI.OrgCountry))

                                        throw new BadRequestException("Reviewer identity lacks an organization Country. Peer review not accepted.");


                                    if (!CaseInsensitiveString.IsNullOrEmpty(RI.Country))

                                    {

                                        if (PeerReviewConfiguration.Instance.RequireIso3166Compliance && !Iso3166.TryGetCountry(RI.Country, out string _))

                                            throw new BadRequestException("Reviewer organization Country is not an ISO 3166-1 Country Code. Peer review not accepted.");

                                    }

                                }


                                await CheckPeerReviewFields(ReviewedIdentity);


                                PersonalInfo PI = GetPersonalInfo(ReviewedIdentity);


                                if (PI.HasOrg)

                                {

                                    if (!RI.HasOrg)

                                        throw new BadRequestException("Peer reviewer lacks organization information. Peer review not accepted.");


                                    if (PI.OrgName != RI.OrgName ||

                                        PI.OrgNumber != RI.OrgNumber ||

                                        PI.OrgCountry != RI.OrgCountry)

                                    {

                                        throw new BadRequestException("Peer reviewer must be from same company. Peer review not accepted.");

                                    }

                                }


                                if (!(Identity.Attachments is null))

                                {

                                    LegalIdentity[] Reviewers2 = await GetPeerReviewers(Identity);


                                    foreach (LegalIdentity ReviewerID in Reviewers2)

                                    {

                                        if (ReviewerID["PNR"] == Pnr)

                                            throw new BadRequestException("A reviewer can only review the application once.");

                                    }


                                    if (Reviewers is null)

                                        Reviewers = new List<LegalIdentity>();


                                    Reviewers.AddRange(Reviewers2);

                                }

                            }


                            if (Reviewers is null)

                                Reviewers = new List<LegalIdentity>();


                            Reviewers.Add(ReviewerIdentity);

                            IncNrPeerReviews = true;


                            sb.Clear();

                        }

                    }


                    using (TemporaryStream TempFile = new TemporaryStream())

                    {

                        await TempFile.WriteAsync(Attachment, 0, Attachment.Length);


                        KeyValuePair<Attachment, AttachmentReference> A =

                            await LegalComponent.CreateAttachment(AttachmentFileName, Identity,

                                AttachmentSignature, TempFile, AttachmentContentType,

                                User.UserName, null, XmppServerModule.Legal?.AttachmentsFolder ?? "Attachments");


                        List<AttachmentReference> References = new List<AttachmentReference>();

                        bool Approved = false;


                        if (!(Identity.Attachments is null))

                            References.AddRange(Identity.Attachments);


                        References.Add(A.Value);

                        Identity.Attachments = References.ToArray();

                        Identity.Updated = LegalComponent.NowSecond;


                        if (IncNrPeerReviews)

                        {

                            Identity.NrPeerReviews++;


                            if ((PeerReviewConfiguration.Instance?.AllowPeerReview ?? true) &&

                                Identity.NrPeerReviews >= (PeerReviewConfiguration.Instance?.NrReviewersToApprove ?? 2) &&

                                Identity.State == IdentityState.Created)

                            {

                                Identity.State = IdentityState.Approved;

                                Approved = true;


                                StringBuilder Markdown = new StringBuilder();


                                Markdown.AppendLine("Peer reviewed Legal ID approved");

                                Markdown.AppendLine("===================================");

                                Markdown.AppendLine();


                                XmppServerModule.Legal.AppendMarkdown(Markdown, Identity, "Applicant");


                                int Index = 0;


                                foreach (LegalIdentity Reviewer in Reviewers)

                                {

                                    Index++;

                                    XmppServerModule.Legal.AppendMarkdown(Markdown, Reviewer, "Reviewer " + Index.ToString());

                                }


                                await Gateway.SendNotification(Markdown.ToString());

                            }

                        }


                        Identity.Sign(XmppServerModule.Legal);

                        await Database.Update(Identity);


                        if (Identity.State == IdentityState.Approved)

                            await CopyPropertiesFromApprovedIdentity(Identity, Account as DataStorage.Account);


                        string BareJid = User.UserName + "@" + Gateway.Domain;


                        Log.Informational("Attachment added to Legal Identity registration.",

                            Identity.Id.Value, BareJid, "LegalIdUpdated", Identity.GetTags());


                        sb.Clear();

                        Identity.Serialize(sb, true, true, true, true, true, true, true, null, XmppServerModule.Legal);

                        string IdentityXml = sb.ToString();


                        if (Approved)

                        {

                            await LegalComponent.AddLegalIdentityReference(Identity);


                            XmppAddress IdentityAddress = new XmppAddress(Identity.Id);

                            int i = IdentityAddress.Domain.IndexOf('.');

                            string JidDomain = i < 0 ? XmppServerModule.Server.Domain : IdentityAddress.Domain.Substring(i + 1);


                            await XmppServerModule.Server.SendMessage(string.Empty, string.Empty, XmppServerModule.Legal.MainDomain,

                                new XmppAddress(Identity.Account + "@" + XmppServerModule.Server.Domain), string.Empty, IdentityXml);

                        }


                        XmlDocument IdentityDoc = new XmlDocument()

                        {

                            PreserveWhitespace = true

                        };

                        IdentityDoc.LoadXml(IdentityXml);


                        await Response.Return(new NamedDictionary<string, object>("IdentityResponse", AgentNamespace)

                        {

                            { "Identity", IdentityDoc },

                        });

                    }


                }

                finally

                {

                    if (DecodedAttachment is IDisposable Disposable)

                        Disposable.Dispose();

                }

            }

        }


        internal static async Task CheckPeerReviewFields(LegalIdentity ReviewedIdentity)

        {

            if (PeerReviewConfiguration.Instance?.AllowPeerReview ?? false)

            {

                PersonalInfo PI = GetPersonalInfo(ReviewedIdentity);


                if (PeerReviewConfiguration.Instance.RequireFirstName && CaseInsensitiveString.IsNullOrEmpty(PI.FirstName))

                    throw new BadRequestException("First name (FIRST) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireMiddleName && CaseInsensitiveString.IsNullOrEmpty(PI.MiddleNames))

                    throw new BadRequestException("Middle name (MIDDLE) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireLastName && CaseInsensitiveString.IsNullOrEmpty(PI.LastNames))

                    throw new BadRequestException("Last name (LAST) is a required field.");


                if (PeerReviewConfiguration.Instance.RequirePersonalNumber && CaseInsensitiveString.IsNullOrEmpty(PI.PersonalNumber))

                    throw new BadRequestException("Personal Number (PNR) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireAddress && CaseInsensitiveString.IsNullOrEmpty(PI.Address))

                    throw new BadRequestException("Address (ADDR) is a required field.");


                if (PeerReviewConfiguration.Instance.RequirePostalCode && CaseInsensitiveString.IsNullOrEmpty(PI.PostalCode))

                    throw new BadRequestException("Postal Code (ZIP) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireArea && CaseInsensitiveString.IsNullOrEmpty(PI.Area))

                    throw new BadRequestException("Area (AREA) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireCity && CaseInsensitiveString.IsNullOrEmpty(PI.City))

                    throw new BadRequestException("City (CITY) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireRegion && CaseInsensitiveString.IsNullOrEmpty(PI.Region))

                    throw new BadRequestException("Region (REGION) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireCountry && CaseInsensitiveString.IsNullOrEmpty(PI.Country))

                    throw new BadRequestException("Country (COUNTRY) is a required field.");


                if (!CaseInsensitiveString.IsNullOrEmpty(PI.Country))

                {

                    if (PeerReviewConfiguration.Instance.RequireIso3166Compliance &&

                        !Iso3166.TryGetCountry(PI.Country, out string _))

                    {

                        throw new BadRequestException("Country must be a ISO 3166-1 Country Code.");

                    }


                    if (!CaseInsensitiveString.IsNullOrEmpty(PI.PersonalNumber))

                    {

                        bool? Valid = await PersonalNumberSchemes.IsValid(PI.Country, PI.PersonalNumber);

                        if (Valid.HasValue && !Valid.Value)

                            throw new BadRequestException("The personal number format does not comply with regulations in your country.");

                    }

                }


                if (PeerReviewConfiguration.Instance.RequireNationality && CaseInsensitiveString.IsNullOrEmpty(PI.Nationality))

                    throw new BadRequestException("Nationality (NATIONALITY) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireGender && !PI.Gender.HasValue)

                    throw new BadRequestException("Gender (GENDER) is a required field.");


                if (PeerReviewConfiguration.Instance.RequireBirthDate && !PI.BirthDate.HasValue)

                    throw new BadRequestException("Birth Date (BDAY, BMONTH & BYEAR) are required fields.");


                if (PI.HasOrg)

                {

                    if (CaseInsensitiveString.IsNullOrEmpty(PI.OrgName))    // TODO: Make configurable

                        throw new BadRequestException("Organization name is a required field for work identities.");


                    if (CaseInsensitiveString.IsNullOrEmpty(PI.OrgDepartment)) // TODO: Make configurable

                        throw new BadRequestException("Department is a required field for work identities.");


                    if (CaseInsensitiveString.IsNullOrEmpty(PI.OrgRole))   // TODO: Make configurable

                        throw new BadRequestException("Role is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequirePersonalNumber && CaseInsensitiveString.IsNullOrEmpty(PI.OrgNumber))

                        throw new BadRequestException("Organization Number is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequireAddress && CaseInsensitiveString.IsNullOrEmpty(PI.OrgAddress))

                        throw new BadRequestException("Organization Address is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequirePostalCode && CaseInsensitiveString.IsNullOrEmpty(PI.OrgPostalCode))

                        throw new BadRequestException("Organization Postal Code (ZIP) is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequireArea && CaseInsensitiveString.IsNullOrEmpty(PI.OrgArea))

                        throw new BadRequestException("Organization Area is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequireCity && CaseInsensitiveString.IsNullOrEmpty(PI.OrgCity))

                        throw new BadRequestException("Organization City is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequireRegion && CaseInsensitiveString.IsNullOrEmpty(PI.OrgRegion))

                        throw new BadRequestException("Organization Region is a required field for work identites.");


                    if (PeerReviewConfiguration.Instance.RequireCountry && CaseInsensitiveString.IsNullOrEmpty(PI.OrgCountry))

                        throw new BadRequestException("Organization Country is a required field for work identites.");


                    if (!CaseInsensitiveString.IsNullOrEmpty(PI.OrgCountry))

                    {

                        if (PeerReviewConfiguration.Instance.RequireIso3166Compliance && !Iso3166.TryGetCountry(PI.OrgCountry, out string _))

                            throw new BadRequestException("Organization Country must be a ISO 3166-1 Country Code.");

                    }

                }

            }

        }


    }

}

Waher.Content.InternetContent
Static class managing encoding and decoding of internet content.
Definition: InternetContent.cs:17

Waher.Content.InternetContent.DecodeAsync
static Task< object > DecodeAsync(string ContentType, byte[] Data, Encoding Encoding, KeyValuePair< string, string >[] Fields, Uri BaseUri)
Decodes an object.
Definition: InternetContent.cs:547

Waher.Content.NamedDictionary
A Named dictionary is a dictionary, with a local name and a namespace. Use it to return content that ...
Definition: NamedDictionary.cs:13

Waher.Content.Resources
Static class managing loading of resources stored as embedded resources or in content files.
Definition: Resources.cs:15

Waher.Content.Resources.LoadResourceAsText
static string LoadResourceAsText(string ResourceName)
Loads a text resource from an embedded resource.
Definition: Resources.cs:96

Waher.Content.Xml.XML
Helps with common XML-related tasks.
Definition: XML.cs:19

Waher.Content.Xml.XML.Attribute
static string Attribute(XmlElement E, string Name)
Gets the value of an XML attribute.
Definition: XML.cs:914

Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:13

Waher.Events.Log.Informational
static void Informational(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs an informational event.
Definition: Log.cs:334

Waher.IoTGateway.Gateway
Static class managing the runtime environment of the IoT Gateway.
Definition: Gateway.cs:126

Waher.IoTGateway.Gateway.Domain
static CaseInsensitiveString Domain
Domain name.
Definition: Gateway.cs:2354

Waher.IoTGateway.Gateway.SendNotification
static Task SendNotification(Graph Graph)
Sends a graph as a notification message to configured notification recipients.
Definition: Gateway.cs:3826

Waher.Networking.HTTP.BadRequestException
The request could not be understood by the server due to malformed syntax. The client SHOULD NOT repe...
Definition: BadRequestException.cs:9

Waher.Networking.HTTP.ForbiddenException
The server understood the request, but is refusing to fulfill it. Authorization will not help and the...
Definition: ForbiddenException.cs:13

Waher.Networking.HTTP.HttpRequestHeader.Host
HttpFieldHost Host
Host HTTP Field header. (RFC 2616, §14.23)
Definition: HttpRequestHeader.cs:302

Waher.Networking.HTTP.HttpRequest
Represents an HTTP request.
Definition: HttpRequest.cs:18

Waher.Networking.HTTP.HttpRequest.Header
HttpRequestHeader Header
Request header.
Definition: HttpRequest.cs:134

Waher.Networking.HTTP.HttpResponse
Represets a response of an HTTP client request.
Definition: HttpResponse.cs:21

Waher.Networking.HTTP.HttpResponse.Return
async Task Return(object Object)
Returns an object to the client. This method can only be called once per response,...
Definition: HttpResponse.cs:895

Waher.Networking.HTTP.NotFoundException
The server has not found anything matching the Request-URI. No indication is given of whether the con...
Definition: NotFoundException.cs:9

Waher.Networking.XMPP.P2P.E2E.EllipticCurveEndpoint
Abstract base class for Elliptic Curve endpoints.
Definition: EllipticCurveEndpoint.cs:13

Waher.Networking.XMPP.P2P.E2E.EllipticCurveEndpoint.Sign
override byte[] Sign(byte[] Data)
Signs binary data using the local private key.
Definition: EllipticCurveEndpoint.cs:114

Waher.Networking.XMPP.Server.Component.MainDomain
XmppAddress MainDomain
Main/principal domain address
Definition: Component.cs:86

Waher.Networking.XMPP.Server.XmppAddress
Contains information about one XMPP address.
Definition: XmppAddress.cs:9

Waher.Networking.XMPP.Server.XmppAddress.Domain
CaseInsensitiveString Domain
Domain
Definition: XmppAddress.cs:97

Waher.Networking.XMPP.Server.XmppAddress.Empty
static readonly XmppAddress Empty
Empty address.
Definition: XmppAddress.cs:31

Waher.Networking.XMPP.Server.XmppServer.SendMessage
Task< bool > SendMessage(string Type, string Id, string From, string To, string Language, string ContentXml)
Sends a Message stanza to a recipient.
Definition: XmppServer.cs:3412

Waher.Networking.XMPP.Server.XmppServer.Domain
CaseInsensitiveString Domain
Domain name.
Definition: XmppServer.cs:882

Waher.Persistence.CaseInsensitiveString
Represents a case-insensitive string.
Definition: CaseInsensitiveString.cs:10

Waher.Persistence.CaseInsensitiveString.Value
string Value
String-representation of the case-insensitive string. (Representation is case sensitive....
Definition: CaseInsensitiveString.cs:27

Waher.Persistence.CaseInsensitiveString.Empty
static readonly CaseInsensitiveString Empty
Empty case-insensitive string
Definition: CaseInsensitiveString.cs:304

Waher.Persistence.CaseInsensitiveString.LowerCase
string LowerCase
Lower-case representation of the case-insensitive string.
Definition: CaseInsensitiveString.cs:32

Waher.Persistence.CaseInsensitiveString.IndexOf
int IndexOf(CaseInsensitiveString value, StringComparison comparisonType)
Reports the zero-based index of the first occurrence of the specified string in the current System....
Definition: CaseInsensitiveString.cs:1334

Waher.Persistence.CaseInsensitiveString.IsNullOrEmpty
static bool IsNullOrEmpty(CaseInsensitiveString value)
Indicates whether the specified string is null or an CaseInsensitiveString.Empty string.
Definition: CaseInsensitiveString.cs:1029

Waher.Persistence.CaseInsensitiveString.Substring
CaseInsensitiveString Substring(int startIndex, int length)
Retrieves a substring from this instance. The substring starts at a specified character position and ...
Definition: CaseInsensitiveString.cs:2561

Waher.Persistence.Database
Static interface for database persistence. In order to work, a database provider has to be assigned t...
Definition: Database.cs:19

Waher.Persistence.Database.Update
static async Task Update(object Object)
Updates an object in the database.
Definition: Database.cs:626

Waher.Persistence.Filters.FilterAnd
This filter selects objects that conform to all child-filters provided.
Definition: FilterAnd.cs:10

Waher.Persistence.Filters.FilterFieldEqualTo
This filter selects objects that have a named field equal to a given value.
Definition: FilterFieldEqualTo.cs:7

Waher.Runtime.Temporary.TemporaryStream
Manages a temporary stream. Contents is kept in-memory, if below a memory threshold,...
Definition: TemporaryStream.cs:14

Waher.Runtime.Temporary.TemporaryStream.WriteAsync
override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
Asynchronously writes a sequence of bytes to the current stream, advances the current position within...
Definition: TemporaryStream.cs:294

Waher.Runtime.Threading.Semaphore
Represents a named semaphore, i.e. an object, identified by a name, that allows single concurrent wri...
Definition: Semaphore.cs:19

Waher.Runtime.Threading.Semaphores
Static class of application-wide semaphores that can be used to order access to editable objects.
Definition: Semaphores.cs:16

Waher.Runtime.Threading.Semaphores.BeginWrite
static async Task< Semaphore > BeginWrite(string Key)
Waits until the semaphore identified by Key  is ready for writing. Each call to BeginWrite must be fo...
Definition: Semaphores.cs:90

Waher.Script.Expression
Class managing a script expression.
Definition: Expression.cs:39

Waher.Security.Hashes
Contains methods for simple hash calculations.
Definition: Hashes.cs:59

Waher.Security.Hashes.ComputeHMACSHA256Hash
static byte[] ComputeHMACSHA256Hash(byte[] Key, byte[] Data)
Computes the HMAC-SHA-256 hash of a block of binary data.
Definition: Hashes.cs:585

Waher.Service.IoTBroker.DataStorage.Account
Contains information about a broker account.
Definition: Account.cs:28

Waher.Service.IoTBroker.DataStorage.Account.Enabled
bool Enabled
If account is enabled
Definition: Account.cs:287

Waher.Service.IoTBroker.DataStorage.Account.Password
string Password
Password of account
Definition: Account.cs:109

Waher.Service.IoTBroker.DataStorage.Account.Account
Account()
Contains information about a broker account.
Definition: Account.cs:72

Waher.Service.IoTBroker.DataStorage.AccountUser
Account user object.
Definition: AccountUser.cs:16

Waher.Service.IoTBroker.DataStorage.AccountUser.Account
Account Account
Account object.
Definition: AccountUser.cs:31

Waher.Service.IoTBroker.DataStorage.AccountUser.UserName
string UserName
User Name.
Definition: AccountUser.cs:36

Waher.Service.IoTBroker.Legal.Attachments.Attachment
Represents an attachment to a document.
Definition: Attachment.cs:17

Waher.Service.IoTBroker.Legal.Attachments.AttachmentReference
Represents an attachment to a document.
Definition: AttachmentReference.cs:11

Waher.Service.IoTBroker.Legal.Attachments.AttachmentReference.ContentType
string ContentType
Internet Content Type of binary attachment.
Definition: AttachmentReference.cs:48

Waher.Service.IoTBroker.Legal.Attachments.AttachmentReference.Signature
byte[] Signature
Binary signature of the attachment, generated by an approved legal identity of the account-holder....
Definition: AttachmentReference.cs:68

Waher.Service.IoTBroker.Legal.Identity.Iso3166
Data in accordance with ISO 3166
Definition: Iso3166.cs:15

Waher.Service.IoTBroker.Legal.Identity.Iso3166.TryGetCountry
static bool TryGetCountry(string Code, out string Country)
Tries to get the Country Name from a ISO 3166-1 Country Code. String comparisons are case-insensitive...
Definition: Iso3166.cs:80

Waher.Service.IoTBroker.Legal.Identity.LegalIdentity
Definition: LegalIdentity.cs:27

Waher.Service.IoTBroker.Legal.Identity.PersonalNumberSchemes
Personal Number Schemes available in different countries.
Definition: PersonalNumberSchemes.cs:18

Waher.Service.IoTBroker.Legal.Identity.PersonalNumberSchemes.IsValid
static async Task< bool?> IsValid(string CountryCode, string PersonalNumber)
Checks if a personal number is valid, in accordance with registered personal number schemes.
Definition: PersonalNumberSchemes.cs:129

Waher.Service.IoTBroker.Legal.LegalComponent
Provisioning and registry service component.
Definition: LegalComponent.cs:55

Waher.Service.IoTBroker.Legal.LegalComponent.AttachmentsFolder
string AttachmentsFolder
Attachments folder.
Definition: LegalComponent.cs:462

Waher.Service.IoTBroker.Legal.LegalComponent.NowSecond
static DateTime NowSecond
Current Date & Time, to a precision of one second.
Definition: LegalComponent.cs:987

Waher.Service.IoTBroker.Setup.PeerReviewConfiguration
Provides the user configuration options regarding peer-review of new legal identities.
Definition: PeerReviewConfiguration.cs:25

Waher.Service.IoTBroker.Setup.PeerReviewConfiguration.Instance
static PeerReviewConfiguration Instance
Current instance of configuration.
Definition: PeerReviewConfiguration.cs:168

Waher.Service.IoTBroker.WebServices.Agent.AgentApi.HasNonceBeenUsed
Task< bool > HasNonceBeenUsed(string Nonce)
Checks if a Nonce value has been used.
Definition: AgentApi.cs:113

Waher.Service.IoTBroker.WebServices.Agent.AgentApi.RegisterNonceValue
Task RegisterNonceValue(string Nonce)
Registers a nonce value.
Definition: AgentApi.cs:122

Waher.Service.IoTBroker.WebServices.Agent.AgentPostResource
Abstract base class for agent resources supporting the POST method.
Definition: AgentPostResource.cs:15

Waher.Service.IoTBroker.WebServices.Agent.AgentResource.AssertUserAuthenticated
static AccountUser AssertUserAuthenticated(HttpRequest Request)
Makes sure the request is made by an authenticated API user.
Definition: AgentResource.cs:211

Waher.Service.IoTBroker.WebServices.Agent.AgentResource.Api
AgentApi Api
Reference to Agent API.
Definition: AgentResource.cs:141

Waher.Service.IoTBroker.WebServices.Agent.AgentResource.AgentNamespace
const string AgentNamespace
https://waher.se/Schema/BrokerAgent.xsd
Definition: AgentResource.cs:28

Waher.Service.IoTBroker.WebServices.Agent.Crypto.AgentKey
Contains an encrypted key for an agent.
Definition: AgentKey.cs:13

Waher.Service.IoTBroker.WebServices.Agent.Crypto.AgentKey.Namespace
string Namespace
Namespace of algorithm
Definition: AgentKey.cs:45

Waher.Service.IoTBroker.WebServices.Agent.Crypto.AgentKey.LocalName
string LocalName
Local Name of algorithm
Definition: AgentKey.cs:40

Waher.Service.IoTBroker.WebServices.Agent.Legal.AddIdAttachment
Adds an attachment to a new Legal ID
Definition: AddIdAttachment.cs:34

Waher.Service.IoTBroker.WebServices.Agent.Legal.AddIdAttachment.AddIdAttachment
AddIdAttachment()
Adds an attachment to a new Legal ID
Definition: AddIdAttachment.cs:38

Waher.Service.IoTBroker.WebServices.Agent.Legal.AddIdAttachment.POST
override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary< string, IElement > Parameters)
Executes the POST method on the resource.
Definition: AddIdAttachment.cs:56

Waher.Service.IoTBroker.WebServices.Agent.Legal.ApplyId
Applies for a new Legal ID
Definition: ApplyId.cs:31

Waher.Service.IoTBroker.XmppServerModule
Service Module hosting the XMPP broker and its components.
Definition: XmppServerModule.cs:109

Waher.Networking.XMPP.Server.IAccount
Interface for XMPP user accounts.
Definition: IAccount.cs:9

Waher.Content.Xml
Definition: XmlCodec.cs:11

Waher.Content
Definition: Array.cs:6

Waher.Events
Definition: ConsoleEventSink.cs:8

Waher.IoTGateway
Definition: App.xaml.cs:23

Waher.Networking.HTTP
Definition: Page.cs:6

Waher.Networking.XMPP.P2P.E2E
Definition: Curve25519Endpoint.cs:6

Waher.Networking.XMPP.Server
Definition: AccountRecipient.cs:5

Waher.Persistence.Filters
Definition: Filter.cs:2

Waher.Persistence
Definition: Bookmark.cs:4

Waher.Runtime.Temporary
Definition: TemporaryFile.cs:6

Waher.Runtime.Threading
Definition: AsyncMutex.cs:6

Waher.Script.Abstraction.Elements
Definition: AbelianGroupElement.cs:5

Waher.Script
Definition: Duration.cs:8

Waher.Security
Definition: AcmeAccount.cs:8

Waher.Service.IoTBroker.DataStorage
Definition: Account.cs:15

Waher.Service.IoTBroker.Legal.Attachments
Definition: Attachment.cs:6

Waher.Service.IoTBroker.Legal.Identity
Definition: Enumerations.cs:4

Waher.Service.IoTBroker.Legal.Identity.IdentityState
IdentityState
Lists recognized legal identity states.
Definition: Enumerations.cs:9

Waher.Service.IoTBroker.Legal
Definition: Attachment.cs:6

Waher.Service.IoTBroker.Setup
Definition: DnsConfiguration.cs:19

Waher.Service.IoTBroker.WebServices.Agent.Crypto
Definition: AgentKey.cs:5

Waher.Service.IoTBroker.WebServices.Agent.Legal
Definition: AddIdAttachment.cs:29

Waher.Service.IoTBroker
Definition: CreateAccount.cs:10

Waher.Service
Definition: App.xaml.cs:43

Waher
Definition: App.xaml.cs:4