AgentApi.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Counters;
using Waher.Runtime.Inventory;
using Waher.Security.JWT;
using Waher.Security.LoginMonitor;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal;
 
namespace Waher.Service.IoTBroker.WebServices.Agent
{
    public class AgentApi : IModule
    {
        private IAgentResource[] resources;
        private readonly LoginAuditor auditor;
 
        public AgentApi()
            : this(null, null)
        {
        }
 
        public AgentApi(JwtFactory Factory, LoginAuditor Auditor)
        {
            AgentResource.Factory = Factory;
            this.auditor = Auditor ?? Gateway.LoginAuditor;
        }
 
        public LoginAuditor Auditor => this.auditor;
 
        public Task Start()
        {
            return this.Start(Gateway.HttpServer);
        }
 
        public async Task Start(HttpServer WebServer)
        {
            List<IAgentResource> Resources = new List<IAgentResource>();
 
            foreach (Type T in Types.GetTypesImplementingInterface(typeof(IAgentResource)))
            {
                if (T.IsAbstract)
                    continue;
 
                try
                {
                    IAgentResource Resource = (IAgentResource)Types.Instantiate(T);
 
                    await Resource.Register(WebServer, this);
                }
                catch (Exception ex)
                {
                    Log.Exception(ex, T.FullName);
                }
            }
 
            this.resources = Resources.ToArray();
        }
 
        public Task Stop()
        {
            return this.Stop(Gateway.HttpServer);
        }
 
        public async Task Stop(HttpServer WebServer)
        {
            if (!(this.resources is null))
            {
                foreach (IAgentResource Resource in this.resources)
                    await Resource.Unregister(WebServer);
            }
        }
 
        public async Task<ApiKey> GetApiKey(string ApiKey)
        {
            PersistenceLayer PersistenceLayer = XmppServerModule.PersistenceLayer ?? new PersistenceLayer();
            return await PersistenceLayer.GetApiKey(ApiKey);
        }
 
        public static async Task<ApiKey> GetAgentApiApiKey()
        {
            return await Database.FindFirstDeleteRest<ApiKey>(
                new FilterFieldEqualTo("Owner", "Agent API"));
        }
 
        public class CreateAccountResult
        {
            public CreateAccountResult(int Code)
                : this(Code, string.Empty)
            {
            }
            public CreateAccountResult(int Code, string Message)
            {
                this.Code = Code;
                this.Account = null;
                this.ErrorMessage = Message;
                this.Token = null;
            }
 
            public CreateAccountResult(Exception ex)
            {
                this.Code = 4;
                this.Account = null;
                this.ErrorMessage = ex.Message;
                this.Token = null;
            }
 
            public CreateAccountResult(DataStorage.Account Account, string Token,
                int IssuedAt, int Expires)
            {
                this.Code = 0;
                this.Account = Account;
                this.ErrorMessage = null;
                this.Token = Token;
                this.IssuedAt = IssuedAt;
                this.Expires = Expires;
            }
 
            public int Code;
 
            public DataStorage.Account Account;
 
            public string ErrorMessage;
 
            public string Token;
 
            public int IssuedAt;
 
            public int Expires;
        }
 
        public static async Task<CreateAccountResult> CreateAccount(
            string UserName, string Password, string EMail, string PhoneNr, string Language,
            int Seconds, HttpRequest Request)
        {
            DataStorage.Account Account = await Database.FindFirstIgnoreRest<DataStorage.Account>(
                new FilterFieldEqualTo("UserName", UserName));
 
            if (!(Account is null))
                return new CreateAccountResult(1);
 
            ApiKey ApiKey = await GetAgentApiApiKey();
            if (ApiKey is null)
                return new CreateAccountResult(2);
 
            if (ApiKey.NrCreated - ApiKey.NrDeleted >= ApiKey.MaxAccounts)
                return new CreateAccountResult(3);
 
            Account = new DataStorage.Account()
            {
                ApiKey = ApiKey.Key,
                UserName = UserName,
                Password = Password,
                EMail = EMail,
                EMailVerified = null,
                PhoneNr = PhoneNr,
                PhoneNrVerified = null,
                Enabled = false,
                CanRelayMessages = false,
                Created = DateTime.UtcNow
            };
 
            await Database.Insert(Account);
            await RuntimeCounters.IncrementCounter(DataStorage.Account.AccountCreatedCounterName);
 
            ApiKey.NrCreated++;
            await Database.Update(ApiKey);
 
            await PersistenceLayer.AccountCreated(Account, ApiKey, Request.Host,
                Request.RemoteEndPoint);
 
            try
            {
                string OnboardingDomainName = await LegalComponent.GetOnboardingNeuronDomainName();
 
                // Sending verification e-mail
 
                ContentResponse OnboardingResponse = await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "EMail", EMail },
                        { "Language", Language }
                    },
                    new KeyValuePair<string, string>("Accept", "application/json"));
 
                if (OnboardingResponse.HasError)
                    return new CreateAccountResult(OnboardingResponse.Error);
 
                if (!(OnboardingResponse.Decoded is Dictionary<string, object> Response))
                    return new CreateAccountResult(4);
 
                if (!Response.TryGetValue("Status", out object Obj) || 
                    !(Obj is bool Status) ||
                    !Status)
                {
                    if (Response.TryGetValue("Message", out Obj) && Obj is string Message)
                        return new CreateAccountResult(4, Message);
                    else
                        return new CreateAccountResult(4);
                }
 
                // Sending verification SMS
 
                OnboardingResponse = await InternetContent.PostAsync(
                    new Uri("https://" + OnboardingDomainName + "/ID/SendVerificationMessage.ws"),
                    new Dictionary<string, object>()
                    {
                        { "Nr", PhoneNr },
                        { "Language", Language }
                    },
                    new KeyValuePair<string, string>("Accept", "application/json"));
 
                if (OnboardingResponse.HasError)
                    return new CreateAccountResult(OnboardingResponse.Error);
 
                if (!(OnboardingResponse.Decoded is Dictionary<string, object> Response2))
                    return new CreateAccountResult(5);
 
                if (!Response2.TryGetValue("Status", out Obj) || 
                    !(Obj is bool Status2) ||
                    !Status2)
                {
                    if (Response2.TryGetValue("Message", out Obj) && Obj is string Message)
                        return new CreateAccountResult(5, Message);
                    else
                        return new CreateAccountResult(5);
                }
 
                int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);
                int Expires = IssuedAt + (int)Seconds;
 
                if (Seconds < 60)
                    Seconds = 60;
                else if (Seconds > 3600)
                    Seconds = 3600;
 
                string Token = AgentResource.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));
 
                return new CreateAccountResult(Account, Token, IssuedAt, Expires);
            }
            catch (Exception ex)
            {
                return new CreateAccountResult(ex);
            }
        }
    }
}