ResendVerificationCodes.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Content.Json;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Runtime.IO;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Account
{
    public class ResendVerificationCodes : AgentPostResource
    {
        public ResendVerificationCodes()
            : base("Account/ResendVerificationCodes",
                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(Create).Namespace + ".JSON.ResendVerificationCodes.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(Create).Namespace + ".XML.ResendVerificationCodes.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            await this.CheckBlocks(Request);
 
            AccountUser User = AssertUserAuthenticated(Request, false);
 
            string EMail = (string)Parameters["PEMail"]?.AssociatedObjectValue;
            string PhoneNr = (string)Parameters["PPhoneNr"]?.AssociatedObjectValue;
            string Language = (string)Parameters["PLanguage"].AssociatedObjectValue;
 
            if (!string.IsNullOrEmpty(PhoneNr) &&
                !Create.InternationalNumberFormat.IsMatch(PhoneNr))
            {
                await Response.SendResponse(new BadRequestException("Phone numbers must be provided using the international number format, starting with +, then the country code, then the number."));
                return;
            }
 
            DataStorage.Account Account = User.Account;
 
            if (Account.Enabled)
            {
                LoginAuditor.Fail("User tried to resend codes for an account that is already enabled.", User.UserName, Request.RemoteEndPoint, "HTTPS");
                await Response.SendResponse(new BadRequestException("Account already enabled. No verification code available to resend."));
                return;
            }
 
            if (!string.IsNullOrEmpty(PhoneNr) && PhoneNr != Account.PhoneNr)
            {
                LoginAuditor.Fail("User tried to change phone number when attempting to resend codes.", User.UserName, Request.RemoteEndPoint, "HTTPS");
                await Response.SendResponse(new ForbiddenException(Request, "Not permitted to change phone number."));
                return;
            }
 
            if (!string.IsNullOrEmpty(EMail) && EMail != Account.EMail)
            {
                LoginAuditor.Fail("User tried to change e-mail address when attempting to resend codes.", User.UserName, Request.RemoteEndPoint, "HTTPS");
                await Response.SendResponse(new ForbiddenException(Request, "Not permitted to change e-mail address."));
                return;
            }
 
            if (!string.IsNullOrEmpty(PhoneNr) && Account.PhoneNrVerified.HasValue)
            {
                LoginAuditor.Fail("User tried to resend phone number verification code when phone number is already verified.", User.UserName, Request.RemoteEndPoint, "HTTPS");
                await Response.SendResponse(new BadRequestException("Phone number has already been verified. No verification code available to resend."));
                return;
            }
 
            if (!string.IsNullOrEmpty(EMail) && Account.EMailVerified.HasValue)
            {
                LoginAuditor.Fail("User tried to resend e-mail address verification code when e-mail address is already verified.", User.UserName, Request.RemoteEndPoint, "HTTPS");
                await Response.SendResponse(new BadRequestException("E-Mail has already been verified. No verification code available to resend."));
                return;
            }
 
            string OnboardingDomainName = await LegalComponent.GetOnboardingNeuronDomainName();
 
            if (!string.IsNullOrEmpty(EMail))
            {
                ContentResponse ContentResponse = await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "EMail", EMail },
                        { "Resend", true },
                        { "Language", Language }
                    },
                    new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType));
 
                if (ContentResponse.HasError)
                {
                    await Response.SendResponse(ContentResponse.Error);
                    return;
                }
 
                if (!(ContentResponse.Decoded is Dictionary<string, object> EMailResult))
                {
                    await Response.SendResponse(new ServiceUnavailableException("Unable to send verification mail. Unexpected result"));
                    return;
                }
 
                if (!EMailResult.TryGetValue("Status", out object Obj) || !(Obj is bool Status) || !Status)
                {
                    if (EMailResult.TryGetValue("Message", out Obj) && Obj is string Message)
                        await Response.SendResponse(new ServiceUnavailableException("Unable to send verification mail. Error reported: " + Message));
                    else
                        await Response.SendResponse(new ServiceUnavailableException("Unable to send verification mail. Check e-mail address provided."));
 
                    return;
                }
            }
 
            if (!CaseInsensitiveString.IsNullOrEmpty(PhoneNr))
            {
                ContentResponse ContentResponse = await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "Nr", PhoneNr },
                        { "Resend", true },
                        { "Language", Language }
                    },
                    new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType));
 
                if (ContentResponse.HasError)
                {
                    await Response.SendResponse(ContentResponse.Error);
                    return;
                }
 
                if (!(ContentResponse.Decoded is Dictionary<string, object> SmsResult))
                {
                    await Response.SendResponse(new ServiceUnavailableException("Unable to send verification mail. Unexpected result"));
                    return;
                }
 
                if (!SmsResult.TryGetValue("Status", out object Obj) || !(Obj is bool Status2) || !Status2)
                {
                    if (SmsResult.TryGetValue("Message", out Obj) && Obj is string Message)
                        await Response.SendResponse(new ServiceUnavailableException("Unable to send verification SMS. Error reported: " + Message));
                    else
                        await Response.SendResponse(new ServiceUnavailableException("Unable to send verification SMS. Check phone number provided."));
 
                    return;
                }
            }
 
            await Response.Return(new NamedDictionary<string, object>("AckResponse", AgentNamespace));
        }
    }
}