AcmeAccount.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Xml;
 
namespace Waher.Security.ACME
{
    public enum AcmeAccountStatus
    {
        valid,
 
        deactivated,
 
        revoked
    };
 
    public class AcmeAccount : AcmeResource
    {
        private readonly AcmeAccountStatus status;
        private readonly string[] contact = null;
        private readonly string initialIp = null;
        private readonly Uri orders = null;
        private readonly DateTime? createdAt = null;
        private readonly bool? termsOfServiceAgreed = null;
 
        internal AcmeAccount(AcmeClient Client, Uri Location, IEnumerable<KeyValuePair<string, object>> Obj)
            : base(Client, Location, Location)
        {
            foreach (KeyValuePair<string, object> P in Obj)
            {
                switch (P.Key)
                {
                    case "status":
                        if (!Enum.TryParse(P.Value as string, out this.status))
                            throw new ArgumentException("Invalid ACME account status: " + P.Value.ToString(), "status");
                        break;
 
                    case "contact":
                        if (P.Value is Array A)
                        {
                            List<string> Contact = new List<string>();
 
                            foreach (object Obj2 in A)
                            {
                                if (Obj2 is string s)
                                    Contact.Add(s);
                            }
 
                            this.contact = Contact.ToArray();
                        }
                        break;
 
                    case "termsOfServiceAgreed":
                        if (CommonTypes.TryParse(P.Value as string, out bool b))
                            this.termsOfServiceAgreed = b;
                        else
                            throw new ArgumentException("Invalid boolean value.", "termsOfServiceAgreed");
                        break;
 
                    case "orders":
                        this.orders = new Uri(P.Value as string);
                        break;
 
                    case "initialIp":
                        this.initialIp = P.Value as string;
                        break;
 
                    case "createdAt":
                        if (XML.TryParse(P.Value as string, out DateTime TP))
                            this.createdAt = TP;
                        else
                            throw new ArgumentException("Invalid date and time value.", "createdAt");
                        break;
                }
            }
        }
 
        public string[] Contact => this.contact;
 
        public AcmeAccountStatus Status => this.status;
 
        public bool? TermsOfServiceAgreed => this.termsOfServiceAgreed;
 
        public Uri Orders => this.orders;
 
        public string InitialIp => this.initialIp;
 
        public DateTime? CreatedAt => this.createdAt;
 
        public Task<AcmeAccount> Update(string[] Contact)
        {
            return this.Client.UpdateAccount(this.Location, Contact);
        }
 
        public Task<AcmeAccount> Deactivate()
        {
            return this.Client.DeactivateAccount(this.Location);
        }
 
        public Task<AcmeAccount> NewKey()
        {
            return this.Client.NewKey(this.Location);
        }
 
        public Task<AcmeOrder> OrderCertificate(string[] Domains, DateTime? NotBefore, DateTime? NotAfter)
        {
            int i, c = Domains.Length;
            AcmeIdentifier[] Identifiers = new AcmeIdentifier[c];
 
            for (i = 0; i < c; i++)
                Identifiers[i] = new AcmeIdentifier(this.Client, "dns", Domains[i]);
 
            return this.OrderCertificate(Identifiers, NotBefore, NotAfter);
        }
 
        public Task<AcmeOrder> OrderCertificate(string Domain, DateTime? NotBefore, DateTime? NotAfter)
        {
            return this.OrderCertificate("dns", Domain, NotBefore, NotAfter);
        }
 
        public Task<AcmeOrder> OrderCertificate(string Type, string Value, DateTime? NotBefore, DateTime? NotAfter)
        {
            return this.OrderCertificate(new AcmeIdentifier(this.Client, Type, Value), NotBefore, NotAfter);
        }
 
        public Task<AcmeOrder> OrderCertificate(AcmeIdentifier Identifier,
            DateTime? NotBefore, DateTime? NotAfter)
        {
            return this.OrderCertificate(new AcmeIdentifier[] { Identifier }, NotBefore, NotAfter);
        }
 
        public Task<AcmeOrder> OrderCertificate(AcmeIdentifier[] Identifiers,
            DateTime? NotBefore, DateTime? NotAfter)
        {
            return this.Client.OrderCertificate(this.Location, Identifiers, NotBefore, NotAfter);
        }
 
        public Task<AcmeOrder[]> GetOrders()
        {
            if (this.orders is null)
                throw new Exception("Account object did not report a URI for the list of orders.");
 
            return this.Client.GetOrders(this.Location, this.orders);
        }
    }
}