CreateWebForm.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Json;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Security.JWT;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Account
{
    public class CreateWebForm : AgentResource, IHttpPostMethod
    {
        public CreateWebForm()
            : base("Account/CreateWebForm")
        {
        }
 
        public override HttpAuthenticationScheme[] GetAuthenticationSchemes(HttpRequest Request)
        {
            base.GetAuthenticationSchemes(Request);     // Initialize factory property.
            return null;
        }
 
        public override bool UserSessions => true;
 
        public virtual bool AllowsPOST => true;
 
        public async Task POST(HttpRequest Request, HttpResponse Response)
        {
            await this.CheckBlocks(Request);
 
            if (this.Api is null)
                throw new ServiceUnavailableException("API not available.");
 
            if (!Request.HasData)
                throw new BadRequestException("No content is request.");
 
            object Decoded = await Request.DecodeDataAsync();
 
            if (!(Decoded is Dictionary<string, string> Form))
                throw new UnsupportedMediaTypeException("Content does not match specification.");
 
            if (!Form.TryGetValue("UserName", out string UserName) || string.IsNullOrEmpty(UserName))
                throw new BadRequestException("Missing user name.");
 
            if (!Form.TryGetValue("EMail", out string EMail) || string.IsNullOrEmpty(EMail))
                throw new BadRequestException("Missing e-mail address.");
 
            if (!Form.TryGetValue("PhoneNr", out string PhoneNr))
                PhoneNr = string.Empty;
 
            if (!Form.TryGetValue("Password", out string Password) || string.IsNullOrEmpty(Password))
                throw new BadRequestException("Missing password.");
 
            if (!Form.TryGetValue("g-recaptcha-response", out string RecaptchaResponse) || string.IsNullOrEmpty(RecaptchaResponse))
                throw new BadRequestException("Missing reCaptcha-response.");
 
            if (!Form.TryGetValue("RedirectionUrl", out string RedirectionUrl) || string.IsNullOrEmpty(RedirectionUrl))
                throw new BadRequestException("Missing redirection URL.");
 
            if (!Form.TryGetValue("Seconds", out string s) || !int.TryParse(s, out int Seconds) || Seconds <= 0 || Seconds > 3600)
                throw new BadRequestException("Invalid number of seconds.");
 
            if (!string.IsNullOrEmpty(Gateway.Domain) &&
                !await Feedback.SiteVerify(RecaptchaResponse, Request.RemoteEndPoint))
            {
                throw new ForbiddenException("Bot?");
            }
 
            if (!string.IsNullOrEmpty(PhoneNr) && !Create.InternationalNumberFormat.IsMatch(PhoneNr))
                throw new BadRequestException("Phone numbers must be provided using the international number format, starting with +, then the country code, then the number.");
 
            Create.AssertUserNameValid(UserName);
 
            ApiKey Key = await this.Api.GetAgentApiApiKey();
            if (Key is null)
            {
                string Msg = "Resource disabled. No Agent API Key configured.";
                throw new ServiceUnavailableException(Msg);
            }
 
            DataStorage.Account Account = await Database.FindFirstIgnoreRest<DataStorage.Account>(
                new FilterFieldEqualTo("UserName", UserName));
 
            if (Account is null)
            {
                if (Key.NrCreated - Key.NrDeleted >= Key.MaxAccounts)
                    throw new ServiceUnavailableException("API Key account limit reached.");
 
                Account = new DataStorage.Account()
                {
                    ApiKey = Key.Key,
                    UserName = UserName,
                    Password = Password,
                    EMail = EMail,
                    EMailVerified = null,
                    PhoneNr = PhoneNr,
                    PhoneNrVerified = null,
                    Enabled = false,
                    CanRelayMessages = false,
                    Created = DateTime.Now
                };
 
                await Database.Insert(Account);
 
                Key.NrCreated++;
                await Database.Update(Key);
 
                await PersistenceLayer.AccountCreated(Account, Key, Gateway.Domain, Request.RemoteEndPoint);
            }
            else
            {
                if (Account.Password != Password)
                    throw new ForbiddenException("Account already exists.", await Create.GetAlterntiveNameSuggestions(UserName));
 
                bool Updated = false;
 
                if (Account.EMail != EMail)
                {
                    if (Account.Enabled && !CaseInsensitiveString.IsNullOrEmpty(Account.EMail))
                        throw new ForbiddenException("Not permitted to change e-mail address.");
 
                    Account.EMail = EMail;
                    Account.EMailVerified = null;
 
                    Updated = true;
                }
 
                if (Account.PhoneNr != PhoneNr)
                {
                    if (Account.Enabled && !CaseInsensitiveString.IsNullOrEmpty(Account.PhoneNr))
                        throw new ForbiddenException("Not permitted to change phone number.");
 
                    Account.PhoneNr = PhoneNr;
                    Account.PhoneNrVerified = null;
 
                    Updated = true;
                }
 
                if (Updated)
                    await Database.Update(Account);
 
                await Account.LoggedIn(Request.RemoteEndPoint);
            }
 
            LoginAuditor.Success("Successful Agent API account created.", UserName, Request.RemoteEndPoint, "HTTPS");
 
            if (!Account.Enabled)
            {
                string OnboardingDomainName = await LegalComponent.GetOnboardingNeuronDomainName();
 
                if (!(await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "EMail", Account.EMail.Value }
                    },
                    new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType))
                    is Dictionary<string, object> EMailResult))
                {
                    throw new ServiceUnavailableException("Unable to send verification mail. Unexpected result");
                }
 
                if (!EMailResult.TryGetValue("Status", out object Obj) || !(Obj is bool Status) || !Status)
                {
                    if (EMailResult.TryGetValue("Message", out Obj) && Obj is string Message)
                        throw new ServiceUnavailableException("Unable to send verification mail. Error reported: " + Message);
                    else
                        throw new ServiceUnavailableException("Unable to send verification mail. Check e-mail address provided.");
                }
 
                if (!CaseInsensitiveString.IsNullOrEmpty(Account.PhoneNr))
                {
                    if (!(await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "Nr", Account.PhoneNr.Value }
                    },
                    new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType))
                    is Dictionary<string, object> SmsResult))
                    {
                        throw new ServiceUnavailableException("Unable to send verification mail. Unexpected result");
                    }
 
                    if (!SmsResult.TryGetValue("Status", out Obj) || !(Obj is bool Status2) || !Status2)
                    {
                        if (SmsResult.TryGetValue("Message", out Obj) && Obj is string Message)
                            throw new ServiceUnavailableException("Unable to send verification SMS. Error reported: " + Message);
                        else
                            throw new ServiceUnavailableException("Unable to send verification SMS. Check phone number provided.");
                    }
                }
            }
 
            int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);
            int Expires = IssuedAt + (int)Seconds;
 
            string Token = Factory.Create(
                new KeyValuePair<string, object>(JwtClaims.JwtId, Convert.ToBase64String(Gateway.NextBytes(32))),
                new KeyValuePair<string, object>(JwtClaims.Issuer, Gateway.Domain?.Value ?? string.Empty),
                new KeyValuePair<string, object>(JwtClaims.Subject, Account.UserName.Value + "@" + (Gateway.Domain?.Value ?? string.Empty)),
                new KeyValuePair<string, object>(JwtClaims.IssueTime, IssuedAt),
                new KeyValuePair<string, object>(JwtClaims.ExpirationTime, Expires));
 
            Request.Session[SessionTokenInfoVariableName] = new SessionTokenInfo()
            {
                Account = Account,
                Token = Token,
                Expires = Expires,
                Seconds = Seconds
            };
 
            throw new TemporaryRedirectException(RedirectionUrl);
        }
 
        public const string SessionTokenInfoVariableName = " AgentAPI.SessionTokenInfo ";
    }
}