AcmeOrder.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using Waher.Content.Xml;
using Waher.Security.PKCS;
 
namespace Waher.Security.ACME
{
    public enum AcmeOrderStatus
    {
        pending,
 
        ready,
 
        processing,
 
        valid,
 
        invalid
    };
 
    public class AcmeOrder : AcmeResource
    {
        private readonly AcmeOrderStatus status;
        private readonly DateTime? expires = null;
        private readonly DateTime? notBefore = null;
        private readonly DateTime? notAfter = null;
        private readonly AcmeIdentifier[] identifiers = null;
        private AcmeAuthorization[] authorizations = null;
        private readonly Uri[] authorizationUris = null;
        private readonly AcmeException error = null; // TODO: Problem document
        private readonly Uri finalize = null;
        private readonly Uri certificate = null;
 
        internal AcmeOrder(AcmeClient Client, Uri AccountLocation, Uri Location,
            IEnumerable<KeyValuePair<string, object>> Obj, HttpResponseMessage Response)
            : base(Client, AccountLocation, 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 order status: " + P.Value.ToString(), "status");
                        break;
 
                    case "expires":
                        if (XML.TryParse(P.Value as string, out DateTime TP))
                            this.expires = TP;
                        else
                            throw new ArgumentException("Invalid date and time value.", "expires");
                        break;
 
                    case "notBefore":
                        if (XML.TryParse(P.Value as string, out TP))
                            this.notBefore = TP;
                        else
                            throw new ArgumentException("Invalid date and time value.", "notBefore");
                        break;
 
                    case "notAfter":
                        if (XML.TryParse(P.Value as string, out TP))
                            this.notAfter = TP;
                        else
                            throw new ArgumentException("Invalid date and time value.", "notAfter");
                        break;
 
                    case "identifiers":
                        if (P.Value is Array A)
                        {
                            List<AcmeIdentifier> Identifiers = new List<AcmeIdentifier>();
 
                            foreach (object Obj2 in A)
                            {
                                if (Obj2 is IEnumerable<KeyValuePair<string, object>> Obj3)
                                    Identifiers.Add(new AcmeIdentifier(Client, Obj3));
                            }
 
                            this.identifiers = Identifiers.ToArray();
                        }
                        break;
 
                    case "authorizations":
                        if (P.Value is Array A2)
                        {
                            List<Uri> Authorizations = new List<Uri>();
 
                            foreach (object Obj2 in A2)
                            {
                                if (Obj2 is string s)
                                    Authorizations.Add(new Uri(s));
                            }
 
                            this.authorizationUris = Authorizations.ToArray();
                        }
                        break;
 
                    case "finalize":
                        this.finalize = new Uri(P.Value as string);
                        break;
 
                    case "certificate":
                        this.certificate = new Uri(P.Value as string);
                        break;
 
                    case "error":
                        if (P.Value is IEnumerable<KeyValuePair<string, object>> ErrorObj)
                            this.error = AcmeClient.CreateException(ErrorObj, Response);
                        break;
                }
            }
        }
 
        public AcmeIdentifier[] Identifiers => this.identifiers;
 
        public Uri[] AuthorizationUris => this.authorizationUris;
 
        public AcmeOrderStatus Status => this.status;
 
        public DateTime? Expires => this.expires;
 
        public DateTime? NotBefore => this.notBefore;
 
        public DateTime? NotAfter => this.notAfter;
 
        public Uri Finalize => this.finalize;
 
        public Uri Certificate => this.certificate;
 
        public AcmeException Error => this.error;
 
        public Task<AcmeOrder> Poll()
        {
            return this.Client.GetOrder(this.AccountLocation, this.Location);
        }
 
        public async Task<AcmeAuthorization[]> GetAuthorizations()
        {
            if (this.authorizations is null)
            {
                int i, c = this.authorizationUris.Length;
                AcmeAuthorization[] Result = new AcmeAuthorization[c];
 
                for (i = 0; i < c; i++)
                {
                    Uri Location = this.authorizationUris[i];
                    Result[i] = new AcmeAuthorization(this.Client, this.AccountLocation, Location, 
                        (await this.Client.POST_as_GET(Location, this.AccountLocation)).Payload);
                }
 
                this.authorizations = Result;
            }
 
            return this.authorizations;
        }
 
        public Task<AcmeAuthorization[]> Authorizations
        {
            get { return this.GetAuthorizations(); }
        }
 
        public Task<AcmeOrder> FinalizeOrder(CertificateRequest CertificateRequest)
        {
            return this.Client.FinalizeOrder(this.AccountLocation, this.finalize, CertificateRequest);
        }
 
        public Task<X509Certificate2[]> DownloadCertificate()
        {
            if (this.certificate is null)
                throw new Exception("No certificate URI available.");
 
            return this.Client.DownloadCertificate(this.AccountLocation, this.certificate);
        }
    }
}