VerifyEMail.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.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Account
{
    public class VerifyEMail : AgentPostResource
    {
        public VerifyEMail()
            : base("Account/VerifyEMail",
                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(VerifyEMail).Namespace + ".JSON.VerifyEMail.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(VerifyEMail).Namespace + ".XML.VerifyEMail.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request, false);
            string EMail = (string)Parameters["PEMail"].AssociatedObjectValue;
            double Code = (double)Parameters["PCode"].AssociatedObjectValue;
 
            if (User.Account.EMail != EMail)
            {
                await Response.SendResponse(new BadRequestException("E-mail mismatch."));
                return;
            }
 
            if (User.Account.EMailVerified.HasValue)
            {
                await Response.SendResponse(new BadRequestException("E-mail already verified."));
                return;
            }
 
            string OnboardingDomainName = await LegalComponent.GetOnboardingNeuronDomainName();
            ContentResponse ContentResponse = await InternetContent.PostAsync(
                new Uri("https://" + OnboardingDomainName + "/ID/VerifyNumber.ws"),
                new Dictionary<string, object>()
                {
                    { "EMail", EMail },
                    { "Code", (int)Code }
                },
                new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType));
 
            if (ContentResponse.HasError)
            {
                await Response.SendResponse(ContentResponse.Error);
                return;
            }
 
            if (!(ContentResponse.Decoded is Dictionary<string, object> Result))
            {
                await Response.SendResponse(new ServiceUnavailableException("Unable to verify mail. Unexpected result"));
                return;
            }
 
            if (!Result.TryGetValue("Status", out object Obj) || !(Obj is bool Status) || !Status)
            {
                if (Result.TryGetValue("Message", out Obj) && Obj is string Message)
                    await Response.SendResponse(new BadRequestException("Unable to verify mail. Error reported: " + Message));
                else
                    await Response.SendResponse(new ServiceUnavailableException("Unable to verify mail."));
 
                return;
            }
 
            User.Account.EMailVerified = DateTime.UtcNow;
 
            if (CaseInsensitiveString.IsNullOrEmpty(User.Account.PhoneNr) ||
                User.Account.PhoneNrVerified.HasValue)
            {
                User.Account.Enabled = true;
            }
 
            await Database.Update(User.Account);
 
            await Response.Return(new NamedDictionary<string, object>("EMailVerified", AgentNamespace)
            {
                { "eMail", EMail },
                { "userName", User.UserName }
            });
        }
    }
}