public async Task <ActionResult <Protocol.HttpModel.Order> > CreateOrder(AcmePayload <CreateOrderRequest> payload)
        {
            var account = await _accountService.FromRequestAsync(HttpContext.RequestAborted);

            var orderRequest = payload.Value;

            if (orderRequest.Identifiers?.Any() != true)
            {
                throw new MalformedRequestException("No identifiers submitted");
            }

            foreach (var i in orderRequest.Identifiers)
            {
                if (string.IsNullOrWhiteSpace(i.Type) || string.IsNullOrWhiteSpace(i.Value))
                {
                    throw new MalformedRequestException($"Malformed identifier: (Type: {i.Type}, Value: {i.Value})");
                }
            }

            var identifiers = orderRequest.Identifiers.Select(x =>
                                                              new Protocol.Model.Identifier(x.Type !, x.Value !)
                                                              );

            var order = await _orderService.CreateOrderAsync(
                account, identifiers,
                orderRequest.NotBefore, orderRequest.NotAfter,
                HttpContext.RequestAborted);

            GetOrderUrls(order, out var authorizationUrls, out var finalizeUrl, out var certificateUrl);
            var orderResponse = new Protocol.HttpModel.Order(order, authorizationUrls, finalizeUrl, certificateUrl);

            var orderUrl = Url.RouteUrl("GetOrder", new { orderId = order.OrderId }, HttpContext.GetProtocol());

            return(new CreatedResult(orderUrl, orderResponse));
        }
        public async Task <ActionResult <Protocol.HttpModel.Order> > FinalizeOrder(string orderId, AcmePayload <FinalizeOrderRequest> payload)
        {
            var account = await _accountService.FromRequestAsync(HttpContext.RequestAborted);

            var order = await _orderService.ProcessCsr(account, orderId, payload.Value.Csr, HttpContext.RequestAborted);

            GetOrderUrls(order, out var authorizationUrls, out var finalizeUrl, out var certificateUrl);

            var orderResponse = new Protocol.HttpModel.Order(order, authorizationUrls, finalizeUrl, certificateUrl);

            return(orderResponse);
        }
        public async Task <ActionResult <Protocol.HttpModel.Order> > GetOrder(string orderId)
        {
            var account = await _accountService.FromRequestAsync(HttpContext.RequestAborted);

            var order = await _orderService.GetOrderAsync(account, orderId, HttpContext.RequestAborted);

            if (order == null)
            {
                return(NotFound());
            }

            GetOrderUrls(order, out var authorizationUrls, out var finalizeUrl, out var certificateUrl);
            var orderResponse = new Protocol.HttpModel.Order(order, authorizationUrls, finalizeUrl, certificateUrl);

            return(orderResponse);
        }