digicert-cli 0.1.0 → 0.2.0

data/lib/digicert/cli/certificate_downloader.rb

@@ -0,0 +1,51 @@
+module Digicert
+  module CLI
+    class CertificateDownloader
+      def initialize(certificate_id:, path:, **options)
+        @path = path
+        @options = options
+        @certificate_id = certificate_id
+        @filename = options.fetch(:filename, certificate_id)
+      end
+
+      def download
+        if certificate_contents
+          write_certificate_contents(certificate_contents)
+        end
+      end
+
+      def self.download(attributes)
+        new(attributes).download
+      end
+
+      private
+
+      attr_reader :certificate_id, :path, :filename, :options
+
+      def certificate_contents
+        @certificate_contents ||=
+          Digicert::CertificateDownloader.fetch_content(certificate_id)
+      end
+
+      def write_certificate_contents(contents)
+        say("Downloaded certificate to:")
+
+        write_to_path("root", contents[:root_certificate])
+        write_to_path("certificate", contents[:certificate])
+        write_to_path("intermediate", contents[:intermediate_certificate])
+      end
+
+      def write_to_path(key, content)
+        certificate_name = [filename, key, "crt"].join(".")
+        certificate_path = [path, certificate_name].join("/")
+
+        say(certificate_path)
+        File.open(certificate_path, "w") { |file| file.write(content) }
+      end
+
+      def say(message)
+        Digicert::CLI::Util.say(message)
+      end
+    end
+  end
+end

data/lib/digicert/cli/command.rb

@@ -1,57 +1,23 @@
-require "optparse"
-require "digicert/cli/order"
+require "digicert/cli/rcfile"
+require "digicert/cli/commands/csr"
+require "digicert/cli/commands/order"
+require "digicert/cli/commands/certificate"
 
 module Digicert
   module CLI
-    module Command
-      def self.run(command, subcommand, args = {})
-        command_klass = command_handler(command)
-        attributes = parse_option_arguments(args)
+    class Command < Thor
+      desc "csr", "Fetch/generate Certificate CSR"
+      subcommand :csr, Digicert::CLI::Commands::Csr
 
-        command_klass.new(attributes).send(subcommand.to_sym)
-      end
-
-      def self.parse(command)
-        command_handlers[command.to_sym] || raise(ArgumentError)
-      end
-
-      def self.command_handlers
-        @commands ||= { order: "Order" }
-      end
-
-      def self.command_handler(command)
-        Object.const_get(
-          ["Digicert", "CLI", parse(command)].join("::")
-        )
-      end
-
-      def self.parse_option_arguments(args)
-        attributes = {}
-
-        option_parser = OptionParser.new do |parser|
-          parser.banner = "Usage: digicert resource:action [options]"
+      desc "order", "Manage Digicert Orders"
+      subcommand :order, Digicert::CLI::Commands::Order
 
-          global_options.each do |option|
-            attribute_name = option[1].split.first.gsub("--", "").to_sym
-            parser.on(*option) { |value| attributes[attribute_name] = value}
-          end
-        end
-
-        if args.first
-          option_parser.parse!(args)
-        end
-
-        attributes
-      end
+      desc "certificate", "Manage Digicert Certificates"
+      subcommand :certificate, Digicert::CLI::Commands::Certificate
 
-      def self.global_options
-        [
-          ["-o", "--order_id ORDER_ID",  "The Digicert Order Id"],
-          ["-q", "--quiet",  "Flag to return resource Id only"],
-          ["-s", "--status STATUS", "Use to specify the order status"],
-          ["-c", "--common_name COMMON_NAME", "The common name for the order"],
-          ["-p", "--product_type NAME_ID", "The Digicert product name Id"],
-        ]
+      desc "config API_KEY", "Configure The CLI Client"
+      def config(api_key)
+        Digicert::CLI::RCFile.set_key(api_key)
       end
     end
   end

data/lib/digicert/cli/commands/certificate.rb

@@ -0,0 +1,37 @@
+require "digicert/cli/certificate"
+
+module Digicert
+  module CLI
+    module Commands
+      class Certificate < Thor
+        desc "fetch ORDER_ID", "Find an order's certificate"
+        option :quiet, type: :boolean, aliases: "-q", desc: "Retrieve only id"
+        option :output, aliases: "-o", desc: "Path to download the certificate"
+
+        def fetch(order_id)
+          say(certificate_instance(order_id: order_id).fetch)
+        end
+
+        desc "download [RSOURCE_OPTION]", "Download a certificate"
+        option :order_id, aliases: "-i", desc: "Digicert order ID"
+        option :certificate_id, aliases: "-c", desc: "The certificate ID"
+        option :output, aliases: "-o", desc: "Path to download the certificate"
+
+        def download
+          say(certificate_instance.download)
+        end
+
+        desc "duplicates ORDER_ID", "List duplicate certificates"
+        def duplicates(order_id)
+          say(certificate_instance(order_id: order_id).duplicates)
+        end
+
+        private
+
+        def certificate_instance(id_attribute = {})
+          Digicert::CLI::Certificate.new(options.merge(id_attribute))
+        end
+      end
+    end
+  end
+end

data/lib/digicert/cli/commands/csr.rb

@@ -0,0 +1,31 @@
+require "digicert/cli/csr"
+
+module Digicert
+  module CLI
+    module Commands
+      class Csr < Thor
+        desc "fetch ORDER_ID", "Fetch an existing CSR"
+
+        def fetch(order_id)
+          say(csr_instance(order_id: order_id).fetch)
+        end
+
+        desc "generate", "Generate certificate CSR"
+        option :common_name, aliases: "-c", desc: "The common name"
+        option :san, type: :array, desc: "The subject alternative names"
+        option :key, aliases: "-k", desc: "Complete path to the rsa key file"
+        option :order_id, required: true, aliases: "-o", desc: "An Order ID"
+
+        def generate
+          say(csr_instance.generate)
+        end
+
+        private
+
+        def csr_instance(id_attribute = {})
+          Digicert::CLI::CSR.new(options.merge(id_attribute))
+        end
+      end
+    end
+  end
+end

data/lib/digicert/cli/commands/order.rb

@@ -0,0 +1,45 @@
+require "digicert/cli/order"
+require "digicert/cli/order_reissuer"
+
+module Digicert
+  module CLI
+    module Commands
+      class Order < Thor
+        desc "list", "List digicert orders"
+        method_option :filter, type: :hash, desc: "Specify filter options"
+
+        def list
+          say(order_instance.list)
+        end
+
+        desc "find", "Find a digicert order"
+        method_option :filter, type: :hash, desc: "Specify filter options"
+        option :quiet, type: :boolean, aliases: "-q", desc: "Retrieve only id"
+
+        def find
+          say(order_instance.find)
+        end
+
+        desc "reissue ORDER_ID", "Reissue digicert order"
+        option :crt, desc: "The CSR content from a file"
+        option :output, aliases: "-o", desc: "Path to download certificates"
+
+        def reissue(order_id)
+          say(reissue_an_order(order_id))
+        end
+
+        private
+
+        def order_instance
+          Digicert::CLI::Order.new(options)
+        end
+
+        def reissue_an_order(order_id)
+          Digicert::CLI::OrderReissuer.new(
+            options.merge(order_id: order_id),
+          ).create
+        end
+      end
+    end
+  end
+end

data/lib/digicert/cli/csr.rb

@@ -0,0 +1,48 @@
+module Digicert
+  module CLI
+    class CSR < Digicert::CLI::Base
+      def fetch
+        if order
+          order.certificate.csr
+        end
+      end
+
+      def generate
+        if order
+          generate_csr_for(order)
+        end
+      end
+
+      private
+
+      attr_reader :rsa_key
+
+      def extract_local_attributes(options)
+        @rsa_key = options.fetch(:key, nil)
+      end
+
+      def order
+        @order ||= Digicert::Order.fetch(order_id)
+      end
+
+      def generate_csr_for(order)
+        if rsa_key && File.exists?(rsa_key)
+          Digicert::CSRGenerator.generate(csr_attributes(order))
+        end
+      end
+
+      def csr_attributes(order)
+        Hash.new.tap do |csr|
+          csr[:rsa_key] = File.read(rsa_key)
+          csr[:organization] = order.organization
+          csr[:common_name] =
+            options[:common_name] || order.certificate.common_name
+
+          if options[:san]
+            csr[:san_names] = options[:san]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/digicert/cli/filter_builder.rb

@@ -0,0 +1,54 @@
+module Digicert
+  module CLI
+    class FilterBuilder
+      attr_reader :options, :filters_hash
+
+      def initialize(options)
+        @options = options
+        @filters_hash = {}
+      end
+
+      def build
+        build_filters
+        filters_hash
+      end
+
+      def self.build(options)
+        new(options).build
+      end
+
+      private
+
+      def build_filters
+        options.each do |key, value|
+          add_to_filters(key.to_s, value)
+        end
+      end
+
+      def add_to_filters(key, value)
+        if supported_filters.include?(key) && !value.empty?
+          @filters_hash[key] = prepare_filter_value(value)
+        end
+      end
+
+      def prepare_filter_value(value)
+        values = value.split(",")
+        build_nested_values(values) || values.first
+      end
+
+      def build_nested_values(values)
+        if values.length > 1
+          Hash.new.tap do |value_hash|
+            values.length.times do |num|
+              value_hash[num.to_s] = values[num].strip
+            end
+          end
+        end
+      end
+
+      def supported_filters
+        %w(date_created valid_till status search common_name product_name_id)
+      end
+    end
+  end
+end

data/lib/digicert/cli/order.rb

@@ -1,44 +1,30 @@
-require "digicert/cli/order_filterer"
-require "digicert/cli/order_reissuer"
+require "digicert/cli/filter_builder"
 
 module Digicert
   module CLI
-    class Order
-      attr_reader :order_id, :options
-
-      def initialize(attributes = {})
-        @options = attributes
-        @order_id = options.delete(:order_id)
-      end
-
+    class Order < Digicert::CLI::Base
       def list
-        filtered_orders = apply_filters(orders)
-        display_orders_in_table(filtered_orders)
+        display_orders_in_table(orders)
       end
 
       def find
-        filtered_orders = apply_filters(orders)
-        apply_ouput_flag(filtered_orders.first)
-      end
-
-      def reissue
-        Digicert::CLI::OrderReissuer.new(
-          order_id: order_id, **options
-        ).create
+        apply_ouput_flag(orders.first)
       end
 
       private
 
       def orders
-        @orders ||= order_api.all
+        @orders ||= order_api.all(filter_options)
       end
 
       def order_api
         Digicert::Order
       end
 
-      def apply_filters(orders)
-        Digicert::CLI::OrderFilterer.filter(orders, options)
+      def filter_options
+        if options[:filter]
+          { filters: Digicert::CLI::FilterBuilder.build(options[:filter]) }
+        end
       end
 
       def apply_ouput_flag(order)

data/lib/digicert/cli/order_reissuer.rb

@@ -1,26 +1,75 @@
+require "date"
+
+require "digicert/cli/order_retriever"
+require "digicert/cli/certificate_downloader"
+
 module Digicert
   module CLI
-    class OrderReissuer
-      attr_reader :order_id, :options
-
-      def initialize(order_id:, **options)
-        @order_id = order_id
-        @options = options
+    class OrderReissuer < Digicert::CLI::Base
+      def create
+        apply_output_options(reissue_an_order)
       end
 
-      def create
-        reissue = Digicert::OrderReissuer.create(order_id: order_id)
-        apply_output_options(reissue)
+      def self.create(attributes)
+        new(attributes).create
       end
 
       private
 
+      attr_reader :csr_file, :output_path
+
+      def extract_local_attributes(options)
+        @csr_file = options.fetch(:crt, nil)
+        @output_path = options.fetch(:output, "/tmp")
+      end
+
+      def reissue_an_order
+        Digicert::OrderReissuer.create(order_params)
+      end
+
+      def order_params
+        Hash.new.tap do |order_params|
+          order_params[:order_id] = order_id
+
+          if csr_file && File.exists?(csr_file)
+            order_params[:certificate] = { csr: File.read(csr_file) }
+          end
+        end
+      end
+
       def apply_output_options(reissue)
         if reissue
-          request_id = reissue.requests.first.id
-          "Reissue request #{request_id} created for order - #{order_id}"
+          print_request_details(reissue.requests.first)
+          fetch_and_download_certificate(reissue.id)
         end
       end
+
+      def print_request_details(request)
+        Digicert::CLI::Util.say(
+          "Reissue request #{request.id} created for order - #{order_id}",
+        )
+      end
+
+      def fetch_and_download_certificate(reissued_order_id)
+        if options[:output]
+          order = fetch_reissued_order(reissued_order_id)
+          download_certificate_order(order.certificate.id)
+        end
+      end
+
+      def fetch_reissued_order(reissued_order_id)
+        Digicert::CLI::OrderRetriever.fetch(
+          reissued_order_id,
+          wait_time: options[:wait_time],
+          number_of_times: options[:number_of_times]
+        )
+      end
+
+      def download_certificate_order(certificate_id)
+        Digicert::CLI::CertificateDownloader.download(
+          filename: order_id, path: output_path, certificate_id: certificate_id
+        )
+      end
     end
   end
 end