digicert 0.1.0 → 0.1.1

data/lib/digicert/errors.rb

@@ -0,0 +1,30 @@
+require "digicert/errors/request_error"
+require "digicert/errors/forbidden"
+require "digicert/errors/server_error"
+require "digicert/errors/unauthorized"
+
+module Digicert
+  module Errors
+    def self.server_errors
+      [
+        OpenSSL::SSL::SSLError,
+        Errno::ETIMEDOUT,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::ECONNRESET,
+        Net::OpenTimeout,
+        SocketError,
+        Net::HTTPServerError
+      ]
+    end
+
+    def self.error_klass_for(response)
+      case response
+      when *server_errors then Errors::ServerError
+      when Net::HTTPUnauthorized then Errors::Unauthorized
+      when Net::HTTPForbidden then Errors::Forbidden
+      else Errors::RequestError
+      end
+    end
+  end
+end

data/lib/digicert/errors/forbidden.rb

@@ -0,0 +1,9 @@
+module Digicert
+  module Errors
+    class Forbidden < RequestError
+      def explanation
+        "A request to Digicert API was considered forbidden by the server"
+      end
+    end
+  end
+end

data/lib/digicert/errors/request_error.rb

@@ -0,0 +1,37 @@
+require "digicert/config"
+
+module Digicert
+  module Errors
+    class RequestError < StandardError
+      def initialize(msg = {})
+        @msg = msg
+        super msg
+      end
+
+      def message
+        <<-MSG.gsub(/^ {8}/, '')
+        #{explanation}:
+        #{response_body}
+        MSG
+      end
+
+      def explanation
+        "A request to Digicert API failed"
+      end
+
+      def kind
+        response_body.fetch("code", {})
+      end
+
+      private
+
+      attr_reader :msg
+
+      def response_body
+        JSON[msg] rescue {}
+      end
+    end
+  end
+
+  Error = Errors::RequestError
+end

data/lib/digicert/errors/server_error.rb

@@ -0,0 +1,9 @@
+module Digicert
+  module Errors
+    class ServerError < RequestError
+      def explanation
+        "A request to Digicert API caused an unexpected server error"
+      end
+    end
+  end
+end

data/lib/digicert/errors/unauthorized.rb

@@ -0,0 +1,9 @@
+module Digicert
+  module Errors
+    class Unauthorized < RequestError
+      def explanation
+        "A request to Digicert API was sent without a valid authentication"
+      end
+    end
+  end
+end

data/lib/digicert/expiring_order.rb

@@ -0,0 +1,21 @@
+require "digicert/base"
+
+module Digicert
+  class ExpiringOrder < Digicert::Base
+    include Digicert::Actions::All
+
+    def self.all(container_id:, **filter_params)
+      new(resource_id: container_id, params: filter_params).all
+    end
+
+    private
+
+    def resources_key
+      "expiring_orders"
+    end
+
+    def resource_path
+      ["report", "order", resource_id, "expiring"].join("/")
+    end
+  end
+end

data/lib/digicert/findable.rb

@@ -0,0 +1,33 @@
+module Digicert
+  module Findable
+    # The `.find` interface is just an alternvatie to instantiate
+    # a new object, and please remeber this does not perform any
+    # actual API Request. Use this interface whenever you need to
+    # instantite an object from an existing id and then perform
+    # some operation throught the objec's instnace methods, like
+    # `#active`, `#reissue` and etc
+    #
+    # If you need an actual API response then use the `.fetch`
+    # API, that will perform an actual API Reqeust and will return
+    # the response from the Digicer API.
+    #
+    # We are not going to implement this right away, but in long
+    # run may be we cna add some sort to lazy evaluation on this
+    # interface, but that's not for sure.
+    #
+    def find(resource_id)
+      new(resource_id: resource_id)
+    end
+
+    # Find by object
+    #
+    # This `find_by_object` interface works more likely a wrapper
+    # around `find` interface, it expects the `object` to response
+    # to the `id` method. Then it delegates object initialization
+    # behavior to the `find` interface.
+    #
+    def find_by_object(object)
+      find(object.id)
+    end
+  end
+end

data/lib/digicert/order.rb

@@ -0,0 +1,81 @@
+require "digicert/base"
+require "digicert/findable"
+
+require "digicert/ssl_certificate/ssl_plus"
+require "digicert/ssl_certificate/ssl_ev_plus"
+require "digicert/ssl_certificate/ssl_wildcard"
+
+require "digicert/client_certificate/premium"
+require "digicert/client_certificate/email_security_plus"
+require "digicert/client_certificate/digital_signature_plus"
+
+module Digicert
+  class Order < Digicert::Base
+    extend Digicert::Findable
+
+    include Digicert::Actions::All
+    include Digicert::Actions::Fetch
+
+    def create
+      certificate_klass.create(attributes)
+    end
+
+    def self.create(name_id, attributes)
+      new(name_id: name_id, **attributes).create
+    end
+
+    def reissue(attributes = {})
+      Digicert::OrderReissuer.create(order_id: resource_id, **attributes)
+    end
+
+    def duplicate(attributes = {})
+      Digicert::OrderDuplicator.create(order_id: resource_id, **attributes)
+    end
+
+    def duplicate_certificates
+      Digicert::DuplicateCertificate.all(order_id: resource_id)
+    end
+
+    def email_validations
+      Digicert::EmailValidation.all(order_id: resource_id)
+    end
+
+    def cancel(note:, **attrs)
+      Digicert::OrderCancellation.create(
+        order_id: resource_id, note: note, **attrs,
+      )
+    end
+
+    private
+
+    attr_reader :name_id
+
+    def extract_local_attribute_ids
+      @name_id = attributes.delete(:name_id)
+    end
+
+    def resource_path
+      "order/certificate"
+    end
+
+    def resources_key
+      "orders"
+    end
+
+    def certificate_klass
+      certificate_klass_hash[name_id.to_sym] ||
+        Digicert::SSLCertificate::SSLPlus
+    end
+
+    def certificate_klass_hash
+      {
+        ssl_plus: Digicert::SSLCertificate::SSLPlus,
+        ssl_wildcard: Digicert::SSLCertificate::SSLWildcard,
+        ssl_ev_plus: Digicert::SSLCertificate::SSLEVPlus,
+        client_premium: Digicert::ClientCertificate::Premium,
+        email_security_plus: Digicert::ClientCertificate::EmailSecurityPlus,
+        digital_signature_plus: Digicert::ClientCertificate::DigitalSignaturePlus,
+      }
+    end
+  end
+end

data/lib/digicert/order_cancellation.rb

@@ -0,0 +1,25 @@
+require "digicert/base"
+
+module Digicert
+  class OrderCancellation < Digicert::Base
+    def create
+      request_klass.new(
+        :put, resource_path, default_attributes.merge(attributes),
+      ).run
+    end
+
+    def self.create(order_id:, note:, **attributes)
+      new(attributes.merge(resource_id: order_id, note: note)).create
+    end
+
+    private
+
+    def resource_path
+      ["order", "certificate", resource_id, "status"].join("/")
+    end
+
+    def default_attributes
+      { status: "CANCELED", send_emails: false }
+    end
+  end
+end

data/lib/digicert/order_duplicator.rb

@@ -0,0 +1,11 @@
+require "digicert/order_manager"
+
+module Digicert
+  class OrderDuplicator < Digicert::OrderManager
+    private
+
+    def resource_creation_path
+      ["order", "certificate", order_id, "duplicate"].join("/")
+    end
+  end
+end

data/lib/digicert/order_manager.rb

@@ -0,0 +1,39 @@
+require "digicert/base"
+
+module Digicert
+  class OrderManager < Digicert::Base
+    include Digicert::Actions::Create
+
+    def self.create(order_id:, **attributes)
+      new(resource_id: order_id, **attributes).create
+    end
+
+    private
+
+    def validate(attributes)
+      order_attributes.merge(attributes)
+    end
+
+    def order_attributes
+      {
+        certificate: {
+          common_name: order.certificate.common_name,
+          dns_names: order.certificate.dns_names,
+          csr: order.certificate.csr,
+          signature_hash: order.certificate.signature_hash,
+          server_platform: { id: order.certificate.server_platform.id },
+        }
+      }
+    end
+
+    def order
+      @order ||= Digicert::Order.fetch(order_id)
+    end
+
+    # Expose the resource_id as order_id, as it sounds
+    # more readable and all of it's subclasses are only
+    # gonna deal with order.
+    #
+    alias_method :order_id, :resource_id
+  end
+end

data/lib/digicert/order_reissuer.rb

@@ -0,0 +1,11 @@
+require "digicert/order_manager"
+
+module Digicert
+  class OrderReissuer < Digicert::OrderManager
+    private
+
+    def resource_creation_path
+      ["order", "certificate", order_id, "reissue"].join("/")
+    end
+  end
+end

data/lib/digicert/organization.rb

@@ -0,0 +1,43 @@
+require "digicert/base"
+
+module Digicert
+  class Organization < Digicert::Base
+    include Digicert::Actions::All
+    include Digicert::Actions::Fetch
+    include Digicert::Actions::Create
+
+    private
+
+    def resource_path
+      "organization"
+    end
+
+    def validate(name:, address:, zip:, city:, state:, country:,
+                 telephone:, container:, organization_contact:, **attributes)
+      required_attributes = {
+        name: name,
+        address: address,
+        zip: zip,
+        city: city,
+        state: state,
+        country: country,
+        telephone: telephone,
+        container: container,
+        organization_contact: validate_contact(organization_contact),
+      }
+
+      required_attributes.merge(attributes)
+    end
+
+    def validate_contact(first_name:, last_name:, email:, telephone:, **attrs)
+      required_attributes = {
+        first_name: first_name,
+        last_name: last_name,
+        email: email,
+        telephone: telephone
+      }
+
+      required_attributes.merge(attrs)
+    end
+  end
+end

data/lib/digicert/product.rb

@@ -0,0 +1,14 @@
+require "digicert/base"
+
+module Digicert
+  class Product < Digicert::Base
+    include Digicert::Actions::All
+    include Digicert::Actions::Fetch
+
+    private
+
+    def resource_path
+      "product"
+    end
+  end
+end

data/lib/digicert/request.rb

@@ -0,0 +1,123 @@
+require "uri"
+require "json"
+require "net/http"
+require "digicert/response"
+require "digicert/errors"
+
+module Digicert
+  class Request
+    def initialize(http_method, end_point, params: {}, **attributes)
+      @end_point = end_point
+      @http_method = http_method
+      @attributes = attributes
+      @query_params = params
+    end
+
+    def run
+      valid_response || raise_response_error
+    end
+
+    def parse
+      Digicert::Response.new(run).parse
+    end
+
+    private
+
+    attr_reader :attributes
+
+    def valid_response
+      log_details_in_debug_mode
+      return response if valid_response?
+    end
+
+    def valid_response?
+      response.is_a?(Net::HTTPSuccess)
+    end
+
+    def response
+      @response ||= send_http_request
+    rescue *server_errors => error
+      @response ||= error
+    end
+
+    def send_http_request
+      Net::HTTP.start(*net_http_options) do |http|
+        http.request(http_request)
+      end
+    end
+
+    def http_request
+      @http_request ||= constanize_net_http_class.new(uri).tap do |request|
+        set_request_body!(request)
+        set_request_headers!(request)
+      end
+    end
+
+    def raise_response_error
+      raise response_error, error_message
+    end
+
+    def net_http_options
+      [uri.host, uri.port, use_ssl: true]
+    end
+
+    def uri
+      URI::HTTPS.build(
+        host: Digicert.configuration.api_host,
+        path: digicert_api_path_with_base,
+        query: build_query_params
+      )
+    end
+
+    def constanize_net_http_class
+      Object.const_get("Net::HTTP::#{@http_method.capitalize}")
+    end
+
+    def set_request_body!(request)
+      unless attributes.empty?
+        request.body = attributes.to_json
+      end
+    end
+
+    def set_request_headers!(request)
+      request.initialize_http_header(
+        "Content-Type" => "application/json",
+        "X-DC-DEVKEY" => Digicert.configuration.api_key
+      )
+    end
+
+    def build_query_params
+      if @query_params
+        URI.encode_www_form(@query_params)
+      end
+    end
+
+    def digicert_api_path_with_base
+      ["", Digicert.configuration.base_path, @end_point].join("/").squeeze("/")
+    end
+
+    def response_error
+      Digicert::Errors.error_klass_for(response)
+    end
+
+    def error_message
+      JSON(response.body)["errors"]
+    rescue response.inspect
+    end
+
+    def server_errors
+      Digicert::Errors.server_errors
+    end
+
+    def debug_mode_on?
+      @debug_mode ||= Digicert.configuration.debug_mode?
+    end
+
+    def log_details_in_debug_mode
+      if debug_mode_on?
+        require "digicert/debugger"
+        Digicert::Debugger.new(request: http_request, response: response).debug
+      end
+    end
+  end
+end