aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/cli/plugin.rb

@@ -1,97 +1,120 @@
+# frozen_string_literal: true
+
 module Aspera
   module Cli
     # base class for plugins modules
     class Plugin
       # operation without id
-      GLOBAL_OPS=[:create,:list]
+      GLOBAL_OPS = %i[create list].freeze
       # operation on specific instance
-      INSTANCE_OPS=[:modify,:delete,:show]
-      ALL_OPS=[GLOBAL_OPS,INSTANCE_OPS].flatten
+      INSTANCE_OPS = %i[modify delete show].freeze
+      ALL_OPS = [GLOBAL_OPS,INSTANCE_OPS].flatten.freeze
       # max number of items for list command
-      MAX_ITEMS='max'
+      MAX_ITEMS = 'max'
       # max number of pages for list command
-      MAX_PAGES='pmax'
+      MAX_PAGES = 'pmax'
+
+      #AGENTS=%i[options transfer config formater persistency].freeze
 
-      @@done=false
+      # global for inherited classes
+      @@options_created = false # rubocop:disable Style/ClassVars
 
       def initialize(env)
-        @agents=env
-        raise StandardError,"execute_action shall be redefined by subclass #{self.class}" unless respond_to?(:execute_action)
-        raise StandardError,"ACTIONS shall be redefined by subclass" unless self.class.constants.include?(:ACTIONS)
-        unless env[:skip_option_header]
-          self.options.parser.separator ""
-          self.options.parser.separator "COMMAND: #{self.class.name.split('::').last.downcase}"
-          self.options.parser.separator "SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map{ |p| p.to_s}.join(' ')}"
-          self.options.parser.separator "OPTIONS:"
-        end
-        unless @@done
-          self.options.add_opt_simple(:value,"extended value for create, update, list filter")
-          self.options.add_opt_simple(:property,"name of property to set")
-          self.options.add_opt_simple(:id,"resource identifier (#{INSTANCE_OPS.join(",")})")
-          self.options.parse_options!
-          @@done=true
-        end
+        raise 'must be Hash' unless env.is_a?(Hash)
+        #env.each_key {|k| raise "wrong agent key #{k}" unless AGENTS.include?(k)}
+        @agents = env
+        # check presence in descendant of mandatory method and constant
+        raise StandardError,"missing method 'execute_action' in #{self.class}" unless respond_to?(:execute_action)
+        raise StandardError,'ACTIONS shall be redefined by subclass' unless self.class.constants.include?(:ACTIONS)
+        options.parser.separator('')
+        options.parser.separator("COMMAND: #{self.class.name.split('::').last.downcase}")
+        options.parser.separator("SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map(&:to_s).join(' ')}")
+        options.parser.separator('OPTIONS:')
+        return if @@options_created
+        options.add_opt_simple(:value,'extended value for create, update, list filter')
+        options.add_opt_simple(:property,'name of property to set')
+        options.add_opt_simple(:id,"resource identifier (#{INSTANCE_OPS.join(',')})")
+        options.parse_options!
+        @@options_created = true # rubocop:disable Style/ClassVars
       end
 
       # must be called AFTER the instance action
-      def instance_identifier()
-        res_id=self.options.get_option(:id)
-        res_id=self.options.get_next_argument('identifier') if res_id.nil?
+      def instance_identifier
+        res_id = options.get_option(:id)
+        res_id = options.get_next_argument('identifier') if res_id.nil?
         return res_id
       end
 
-      def entity_command(command,rest_api,res_class_path,display_fields,id_symb,id_default=nil,use_subkey=false)
-        raise "not id" unless :id.eql?(id_symb)
+      # TODO
+      def get_next_id_command(instance_ops: INSTANCE_OPS,global_ops: GLOBAL_OPS)
+        return get_next_argument('command',expected: command_list)
+      end
+
+      # @param command [Symbol] command to execute: create show list modify delete
+      # @param rest_api [Rest] api to use
+      # @param res_class_path [String] sub path in URL to resource relative to base url
+      # @param display_fields [Array] fields to display by default
+      # @param id_default [String] default identifier to use for existing entity commands (show, modify)
+      # @param item_list_key [String] result is in a subkey of the json
+      def entity_command(command,rest_api,res_class_path,display_fields: nil,id_default: nil,item_list_key: false)
         if INSTANCE_OPS.include?(command)
           begin
-            one_res_id=instance_identifier()
-          rescue => e
+            one_res_id = instance_identifier
+          rescue StandardError => e
             raise e if id_default.nil?
-            one_res_id=id_default
+            one_res_id = id_default
           end
-          one_res_path="#{res_class_path}/#{one_res_id}"
+          one_res_path = "#{res_class_path}/#{one_res_id}"
         end
         # parameters mandatory for create/modify
-        if [:create,:modify].include?(command)
-          parameters=self.options.get_option(:value,:mandatory)
+        if %i[create modify].include?(command)
+          parameters = options.get_option(:value,is_type: :mandatory)
         end
         # parameters optional for list
         if [:list].include?(command)
-          parameters=self.options.get_option(:value,:optional)
+          parameters = options.get_option(:value)
         end
         case command
         when :create
-          return {:type => :single_object, :data=>rest_api.create(res_class_path,parameters)[:data], :fields=>display_fields}
+          return {type: :single_object, data: rest_api.create(res_class_path,parameters)[:data], fields: display_fields}
         when :show
-          return {:type => :single_object, :data=>rest_api.read(one_res_path)[:data], :fields=>display_fields}
+          return {type: :single_object, data: rest_api.read(one_res_path)[:data], fields: display_fields}
         when :list
-          resp=rest_api.read(res_class_path,parameters)
-          data=resp[:data]
+          resp = rest_api.read(res_class_path,parameters)
+          data = resp[:data]
           # TODO: not generic : which application is this for ?
           if resp[:http]['Content-Type'].start_with?('application/vnd.api+json')
-            data=data[res_class_path]
+            data = data[res_class_path]
           end
-          data=data[res_class_path] if use_subkey
-          return {:type => :object_list, :data=>data, :fields=>display_fields}
+          if item_list_key
+            item_list=data[item_list_key]
+            total_count=data['total_count']
+            if !total_count.nil?
+              count_msg = "Items: #{item_list.length}/#{total_count}"
+              count_msg = count_msg.bg_red unless item_list.length.eql?(total_count.to_i)
+              self.format.display_status(count_msg)
+            end
+            data = item_list
+          end
+          return {type: :object_list, data: data, fields: display_fields}
         when :modify
-          property=self.options.get_option(:property,:optional)
-          parameters={property => parameters} unless property.nil?
+          property = options.get_option(:property)
+          parameters = {property => parameters} unless property.nil?
           rest_api.update(one_res_path,parameters)
           return Main.result_status('modified')
         when :delete
           rest_api.delete(one_res_path)
-          return Main.result_status("deleted")
+          return Main.result_status('deleted')
         else
           raise "unknown action: #{command}"
         end
-        raise "internal error should not reach here"
       end
 
       # implement generic rest operations on given resource path
-      def entity_action(rest_api,res_class_path,display_fields,id_symb,id_default=nil,use_subkey=false)
+      def entity_action(rest_api,res_class_path,**opts)
         #res_name=res_class_path.gsub(%r{^.*/},'').gsub(%r{s$},'').gsub('_',' ')
-        command=self.options.get_next_command(ALL_OPS)
-        return entity_command(command,rest_api,res_class_path,display_fields,id_symb,id_default,use_subkey)
+        command = options.get_next_command(ALL_OPS)
+        return entity_command(command,rest_api,res_class_path,**opts)
       end
 
       # shortcuts for plugin environment
@@ -104,7 +127,6 @@ module Aspera
       def format; return @agents[:formater];end
 
       def persistency; return @agents[:persistency];end
-
     end # Plugin
   end # Cli
 end # Aspera

data/lib/aspera/cli/plugins/alee.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/rest'
 require 'aspera/aoc'
 
@@ -5,17 +7,16 @@ module Aspera
   module Cli
     module Plugins
       class Alee < BasicAuthPlugin
-
-        ACTIONS=[ :entitlement ]
+        ACTIONS = %i[entitlement].freeze
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS)
           case command
           when :entitlement
-            entitlement_id = self.options.get_option(:username,:mandatory)
-            customer_id = self.options.get_option(:password,:mandatory)
-            api_metering=AoC.metering_api(entitlement_id,customer_id)
-            return {:type=>:single_object, :data=>api_metering.read('entitlement')[:data]}
+            entitlement_id = options.get_option(:username,is_type: :mandatory)
+            customer_id = options.get_option(:password,is_type: :mandatory)
+            api_metering = AoC.metering_api(entitlement_id,customer_id)
+            return {type: :single_object, data: api_metering.read('entitlement')[:data]}
           end
         end
       end # Aspera