3scale_toolbox 0.10.0 → 0.11.0

data/lib/3scale_toolbox/commands/activedocs_command/create_command.rb

@@ -0,0 +1,65 @@
+module ThreeScaleToolbox
+  module Commands
+    module ActiveDocsCommand
+      module Create
+        class CreateSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+          include ThreeScaleToolbox::ResourceReader
+
+          def self.command
+            Cri::Command.define do
+              name        'create'
+              usage       'create <remote> <activedocs-name> <spec>'
+              summary     'Create an ActiveDocs'
+              description 'Create an ActiveDocs'
+              runner CreateSubcommand
+
+              param   :remote
+              param   :activedocs_name
+              param   :activedocs_spec
+
+              option :i, :'service-id', "Specify the Service ID associated to the ActiveDocs", argument: :required
+              option :p, :'published', "Specify it to publish the ActiveDoc on the Developer Portal. Otherwise it will be hidden", argument: :forbidden
+              option nil, :'skip-swagger-validations', "Specify it to skip validation of the Swagger specification", argument: :forbidden
+              option :d, :'description', "Specify the description of the ActiveDocs", argument: :required
+              option :s, :'system-name', "Specify the system-name of the ActiveDocs", argument: :required
+            end
+          end
+
+          def run
+            res = Entities::ActiveDocs::create(remote: remote, attrs: activedocs_attrs)
+            puts "ActiveDocs '#{activedocs_name}' has been created with ID: #{res.id}"
+          end
+
+          private
+
+          def activedocs_name
+            arguments[:activedocs_name]
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def activedocs_json_spec
+            activedoc_spec = arguments[:activedocs_spec]
+            activedoc_spec_content = load_resource(arguments[:activedocs_spec])
+            JSON.pretty_generate(activedoc_spec_content)
+          end
+
+          def activedocs_attrs
+            {
+              "service_id" => options[:'service-id'],
+              "published" => options[:'published'],
+              "skip_swagger_validations" => options[:'skip-swagger-validations'],
+              "description" => options[:'description'],
+              "system_name" => options[:'system-name'],
+              "name" => activedocs_name,
+              "body" => activedocs_json_spec,
+            }.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/activedocs_command/delete_command.rb

@@ -0,0 +1,49 @@
+module ThreeScaleToolbox
+  module Commands
+    module ActiveDocsCommand
+      module Delete
+        class DeleteSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'delete'
+              usage       'delete <remote> <activedocs-id_or-system-name>'
+              summary     'Delete an ActiveDocs'
+              description 'Remove an ActiveDocs'
+              runner DeleteSubcommand
+
+              param   :remote
+              param   :activedocs_id_or_system_name
+            end
+          end
+
+          def run
+            activedocs.delete
+            puts "ActiveDocs with id: #{activedocs.id} deleted"
+          end
+
+          private
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def ref
+            arguments[:activedocs_id_or_system_name]
+          end
+
+          def activedocs
+            @activedocs ||= find_activedocs
+          end
+
+          def find_activedocs
+            Entities::ActiveDocs.find(remote: remote, ref: ref).tap do |activedoc|
+              raise ThreeScaleToolbox::Error, "ActiveDocs #{ref} does not exist" if activedoc.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/activedocs_command/list_command.rb

@@ -0,0 +1,54 @@
+module ThreeScaleToolbox
+  module Commands
+    module ActiveDocsCommand
+      module List
+        class ListSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'list'
+              usage       'list <remote>'
+              summary     'List ActiveDocs'
+              description 'List all defined ActiveDocs'
+              runner ListSubcommand
+
+              param :remote
+            end
+          end
+
+          def run
+            activedocs = remote.list_activedocs
+            print_activedocs_data(activedocs, ACTIVEDOCS_FIELDS_TO_SHOW)
+          end
+
+          private
+
+          ACTIVEDOCS_FIELDS_TO_SHOW = %w[
+            id name system_name service_id published
+            skip_swagger_validations created_at updated_at
+          ]
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def print_activedocs_data(activedocs, fields_to_show)
+            print_header(fields_to_show)
+            print_results(activedocs, fields_to_show)
+          end
+
+          def print_header(fields_to_show)
+            puts fields_to_show.map { |e| e.upcase }.join("\t")
+          end
+
+          def print_results(activedocs, fields_to_show)
+            activedocs.each do |activedoc|
+              puts fields_to_show.map { |field| activedoc.fetch(field, '(empty)') }.join("\t")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/application_command.rb

@@ -0,0 +1,30 @@
+require '3scale_toolbox/commands/application_command/list_command'
+require '3scale_toolbox/commands/application_command/create_command'
+require '3scale_toolbox/commands/application_command/show_command'
+require '3scale_toolbox/commands/application_command/apply_command'
+require '3scale_toolbox/commands/application_command/delete_command'
+
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      include ThreeScaleToolbox::Command
+      def self.command
+        Cri::Command.define do
+          name        'application'
+          usage       'application <sub-command> [options]'
+          summary     'application super command'
+          description 'application commands'
+
+          run do |_opts, _args, cmd|
+            puts cmd.help
+          end
+        end
+      end
+      add_subcommand(List::ListSubcommand)
+      add_subcommand(Create::CreateSubcommand)
+      add_subcommand(Show::ShowSubcommand)
+      add_subcommand(Apply::ApplySubcommand)
+      add_subcommand(Delete::DeleteSubcommand)
+    end
+  end
+end

data/lib/3scale_toolbox/commands/application_command/apply_command.rb

@@ -0,0 +1,179 @@
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      module Apply
+        class ApplySubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'apply'
+              usage       'apply [opts] <remote> <application>'
+              summary     'update (or create) application'
+              description <<-HEREDOC
+              Update (create if it does not exist) application'
+              \n Application param allows:
+              \n * Application internal id
+              \n * User_key (API key)
+              \n * App_id (from app_id/app_key pair)
+              \n * Client ID (for OAuth and OpenID Connect authentication modes)
+              HEREDOC
+
+              option      nil, 'user-key', 'User Key (API Key) of the application to be created.', argument: :required
+              option      nil, 'application-key', 'App Key(s) or Client Secret (for OAuth and OpenID Connect authentication modes) of the application to be created. Only used when application does not exist.' , argument: :required
+              option      nil, :description, 'Application description', argument: :required
+              option      nil, :name, 'Application name', argument: :required
+              option      nil, :account, 'Application\'s account. Required when creating', argument: :required
+              option      nil, :service, 'Application\'s service. Required when creating', argument: :required
+              option      nil, :plan, 'Application\'s plan. Required when creating', argument: :required
+              flag        nil, :resume, 'Resume a suspended application'
+              flag        nil, :suspend, 'Suspends an application (changes the state to suspended)'
+              param       :remote
+              param       :application
+
+              runner ApplySubcommand
+            end
+          end
+
+          def run
+            validate_option_params
+
+            application = Entities::Application.find(remote: remote, ref: application_ref)
+            if application.nil?
+              validate_creation_option_params
+              application = Entities::Application.create(remote: remote,
+                                                         account_id: account.id,
+                                                         plan_id: plan.id,
+                                                         app_attrs: create_app_attrs)
+            else
+              application.update(app_attrs) unless app_attrs.empty?
+            end
+
+            application.resume if option_resume
+            application.suspend if option_suspend
+            output_msg_array = ["Applied application id: #{application.id}"]
+            output_msg_array << 'Resumed' if option_resume
+            output_msg_array << 'Suspended' if option_suspend
+            puts output_msg_array.join('; ')
+          end
+
+          private
+
+          def validate_option_params
+            raise ThreeScaleToolbox::Error, '--resume and --suspend are mutually exclusive' \
+              if option_resume && option_suspend
+          end
+
+          def validate_creation_option_params
+            raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist." \
+              '--account is required to create' if option_account.nil?
+            raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist." \
+              '--service is required to create' if option_service.nil?
+            raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist." \
+              '--plan is required to create' if option_plan.nil?
+            raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist." \
+              '--name is required to create' if option_name.nil?
+            raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist." \
+              '--user-key option forbidden' unless option_user_key.nil?
+          end
+
+          def create_app_attrs
+            {
+              'name' => option_name,
+              'description' => description,
+              'user_key' => application_ref,
+              'application_id' => application_ref,
+              'application_key' => option_app_key,
+            }.compact
+          end
+
+          def app_attrs
+            # This apply command does not update App Key (or Client Secret).
+            # Hence, not included.
+            {
+              'name' => option_name,
+              'description' => description,
+              'user_key' => option_user_key,
+            }.compact
+          end
+
+          def account
+            @account ||= find_account
+          end
+
+          def find_account
+            Entities::Account.find(remote: remote,
+                                   ref: option_account).tap do |acc|
+              raise ThreeScaleToolbox::Error, "Account #{option_account} does not exist" if acc.nil?
+            end
+          end
+
+          def service
+            @service ||= find_service
+          end
+
+          def find_service
+            Entities::Service.find(remote: remote,
+                                   ref: option_service).tap do |svc|
+              raise ThreeScaleToolbox::Error, "Service #{option_service} does not exist" if svc.nil?
+            end
+          end
+
+          def plan
+            @plan ||= find_plan
+          end
+
+          def find_plan
+            Entities::ApplicationPlan.find(service: service, ref: option_plan).tap do |pl|
+              raise ThreeScaleToolbox::Error, "Application plan #{option_plan} does not exist" if pl.nil?
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def option_name
+            options[:name]
+          end
+
+          def description
+            options[:description] || option_name
+          end
+
+          def option_user_key
+            options[:'user-key']
+          end
+
+          def option_app_key
+            options[:'application-key']
+          end
+
+          def option_account
+            options[:account]
+          end
+
+          def option_service
+            options[:service]
+          end
+
+          def option_plan
+            options[:plan]
+          end
+
+          def option_resume
+            options.fetch(:resume, false)
+          end
+
+          def option_suspend
+            options.fetch(:suspend, false)
+          end
+
+          def application_ref
+            arguments[:application]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/application_command/create_command.rb

@@ -0,0 +1,110 @@
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      module Create
+        class CreateSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'create'
+              usage       'create [opts] <remote> <account> <service> <application-plan> <name>'
+              summary     'create one application'
+              description 'create one application linked to given account and application plan'
+
+              option      nil, 'user-key', 'User Key (API Key) of the application to be created.', argument: :required
+              option      nil, 'application-id', 'App ID or Client ID (for OAuth and OpenID Connect authentication modes) of the application to be created. ', argument: :required
+              option      nil, 'application-key', 'App Key(s) or Client Secret (for OAuth and OpenID Connect authentication modes) of the application to be created.' , argument: :required
+              option      nil, :description, 'Application description', argument: :required
+              param       :remote
+              param       :account
+              param       :service
+              param       :plan
+              param       :name
+
+              runner CreateSubcommand
+            end
+          end
+
+          def run
+            application = ThreeScaleToolbox::Entities::Application.create(
+              remote: remote,
+              account_id: account.id,
+              plan_id: plan.id,
+              app_attrs: app_attrs
+            )
+
+            puts "Created application id: #{application.id}"
+          end
+
+          private
+
+          def app_attrs
+            {
+              'name' => name,
+              'description' => description,
+              'user_key' => options[:'user-key'],
+              'application_id' => options[:'application-id'],
+              'application_key' => options[:'application-key']
+            }.compact
+          end
+
+          def description
+            options[:description] || name
+          end
+
+          def name
+            arguments[:name]
+          end
+
+          def account_ref
+            arguments[:account]
+          end
+
+          def account
+            @account ||= find_account
+          end
+
+          def find_account
+            Entities::Account.find(remote: remote,
+                                   ref: account_ref).tap do |acc|
+              raise ThreeScaleToolbox::Error, "Account #{account_ref} does not exist" if acc.nil?
+            end
+          end
+
+          def service_ref
+            arguments[:service]
+          end
+
+          def service
+            @service ||= find_service
+          end
+
+          def find_service
+            Entities::Service.find(remote: remote, ref: service_ref).tap do |svc|
+              raise ThreeScaleToolbox::Error, "Service #{service_ref} does not exist" if svc.nil?
+            end
+          end
+
+          def plan_ref
+            arguments[:plan]
+          end
+
+          def plan
+            @plan ||= find_plan
+          end
+
+          def find_plan
+            Entities::ApplicationPlan.find(service: service, ref: plan_ref).tap do |plan|
+              raise ThreeScaleToolbox::Error, "Application plan #{plan_ref} does not exist" if plan.nil?
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+        end
+      end
+    end
+  end
+end