aspera-cli 4.23.0 → 4.24.1

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

@@ -35,13 +35,40 @@ module Aspera
         PATH_AUTH = 'auth'
         PATH_HEALTH = 'configuration/ping'
         PATH_API_DETECT = "#{PATH_API_V5}/#{PATH_HEALTH}"
-        PER_PAGE_DEFAULT = 100
         # OAuth methods supported
         STD_AUTH_TYPES = %i[web jwt boot].freeze
         HEADER_ITERATION_TOKEN = 'X-Aspera-Next-Iteration-Token'
         HEADER_FASPEX_VERSION = 'X-IBM-Aspera'
-        private_constant(*%i[JOB_RUNNING RECIPIENT_TYPES PACKAGE_TERMINATED PATH_HEALTH API_LIST_MAILBOX_TYPES PACKAGE_SEND_FROM_REMOTE_SOURCE PER_PAGE_DEFAULT
-                             STD_AUTH_TYPES HEADER_ITERATION_TOKEN HEADER_FASPEX_VERSION])
+        EMAIL_NOTIF_LIST = %w[
+          welcome_email
+          forgot_password
+          package_received
+          package_received_cc
+          package_sent_cc
+          package_downloaded
+          package_downloaded_cc
+          workgroup_package
+          upload_result
+          upload_result_cc
+          relay_started_cc
+          relay_finished_cc
+          relay_error_cc
+          shared_inbox_invitation
+          shared_inbox_submit
+          personal_invitation
+          personal_submit
+          account_approved
+          account_denied
+          package_file_processing_failed_sender
+          package_file_processing_failed_recipient
+          relay_failed_admin
+          relay_failed
+          admin_sync_failed
+          sync_failed
+          account_exist
+          mfa_code
+        ]
+        private_constant :JOB_RUNNING, :RECIPIENT_TYPES, :PACKAGE_TERMINATED, :PATH_HEALTH, :API_LIST_MAILBOX_TYPES, :PACKAGE_SEND_FROM_REMOTE_SOURCE, :STD_AUTH_TYPES, :HEADER_ITERATION_TOKEN, :HEADER_FASPEX_VERSION, :EMAIL_NOTIF_LIST
         class << self
           def application_name
             'Faspex'
@@ -71,7 +98,7 @@ module Aspera
               Log.log.debug{"detect error: #{e}"}
             end
             raise error if error
-            return nil
+            return
           end
 
           # @param object [Plugin] An instance of this class
@@ -86,17 +113,18 @@ module Aspera
             raise "Username shall be an email in Faspex: #{wiz_username}" if !(wiz_username =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i)
             if options.get_option(:client_id).nil? || options.get_option(:client_secret).nil?
               formatter.display_status('Ask the ascli client id and secret to your Administrator.'.red)
-              formatter.display_status("Admin should login to: #{instance_url}")
+              formatter.display_status("Log in as an admin user at: #{instance_url}")
               Environment.instance.open_uri(instance_url)
               formatter.display_status('Navigate to: 𓃑  → Admin → Configurations → API clients')
               formatter.display_status('Create an API client with:')
               formatter.display_status('- name: ascli')
               formatter.display_status('- JWT: enabled')
-              formatter.display_status("Then, logged in as #{wiz_username.red} go to your profile:")
-              formatter.display_status('👤 → Account Settings → Preferences -> Public Key in PEM:')
+              formatter.display_status("Log in as user #{wiz_username.red}. Navigate to your profile:")
+              formatter.display_status('👤 → Account Settings → Preferences → Public Key in PEM:')
               formatter.display_status(pub_key_pem)
               formatter.display_status('Once set, fill in the parameters:')
             end
+            return {preset_value: {}, test_args: ''} if options.get_option(:test_mode)
             return {
               preset_value: {
                 url:           instance_url,
@@ -116,7 +144,7 @@ module Aspera
           end
         end
 
-        def initialize(**env)
+        def initialize(**_)
           super
           options.declare(:client_id, 'OAuth client identifier')
           options.declare(:client_secret, 'OAuth client secret')
@@ -140,10 +168,10 @@ module Aspera
             # resolve any redirect
             @faspex5_api_base_url = Rest.new(base_url: @faspex5_api_base_url, redirect_max: 3).call(operation: 'GET')[:http].uri.to_s
             encoded_context = Rest.query_to_h(URI.parse(@faspex5_api_base_url).query)['context']
-            raise 'Bad faspex5 public link, missing context in query' if encoded_context.nil?
+            raise BadArgument, 'Bad faspex5 public link, missing context in query' if encoded_context.nil?
             # public link information (allowed usage)
             @pub_link_context = JSON.parse(Base64.decode64(encoded_context))
-            Log.log.trace1{Log.dump(:@pub_link_context, @pub_link_context)}
+            Log.dump(:@pub_link_context, @pub_link_context, level: :trace1)
             # ok, we have the additional parameters, get the base url
             @faspex5_api_base_url = @faspex5_api_base_url.gsub(%r{/public/.*}, '').gsub(/\?.*/, '')
             @api_v5 = Rest.new(
@@ -166,7 +194,8 @@ module Aspera
                 grant_method: :web,
                 client_id:    options.get_option(:client_id, mandatory: true),
                 redirect_uri: options.get_option(:redirect_uri, mandatory: true)
-              })
+              }
+            )
           when :jwt
             app_client_id = options.get_option(:client_id, mandatory: true)
             @api_v5 = Rest.new(
@@ -183,7 +212,8 @@ module Aspera
                 },
                 private_key_obj: OpenSSL::PKey::RSA.new(options.get_option(:private_key, mandatory: true), options.get_option(:passphrase)),
                 headers:         {typ: 'JWT'}
-              })
+              }
+            )
           else Aspera.error_unexpected_value(auth_type)
           end
           # in case user wants to use HTTPGW tell transfer agent how to get address
@@ -223,7 +253,7 @@ module Aspera
             # user asked to not follow
             return status if status_list.nil?
             if status['upload_status'].eql?('submitted')
-              config.progress_bar&.event(:pre_start, session_id: nil, info: status['upload_status'])
+              config.progress_bar&.event(:sessions_init, session_id: nil, info: status['upload_status'])
             elsif !total_sent
               config.progress_bar&.event(:session_start, session_id: id)
               config.progress_bar&.event(:session_size, session_id: id, info: status['bytes_total'].to_i)
@@ -232,7 +262,8 @@ module Aspera
               config.progress_bar&.event(:transfer, session_id: id, info: status['bytes_written'].to_i)
             end
             if status_list.include?(status['upload_status'])
-              config.progress_bar&.event(:end, session_id: id)
+              config.progress_bar&.event(:session_end, session_id: id)
+              config.progress_bar&.event(:end)
               return status
             end
             sleep(1.0)
@@ -253,82 +284,25 @@ module Aspera
           return result
         end
 
-        # Get a (full or partial) list of all entities of a given type with query: offset/limit
-        # @param type [String] the type of entity to list (just a name)
-        # @param query [Hash,nil] additional query parameters
-        # @param real_path [String] real path if it's n ot just the type
-        # @param item_list_key [String] key in the result to get the list of items
-        def list_entities(type:, real_path: nil, item_list_key: nil, query: nil)
-          Log.log.trace1{"list_entities t=#{type} p=#{real_path} k=#{item_list_key} q=#{query}"}
-          type = type.to_s if type.is_a?(Symbol)
-          query = {} if query.nil?
-          Aspera.assert_type(type, String)
-          Aspera.assert_type(query, Hash)
-          item_list_key = type if item_list_key.nil?
-          real_path = type if real_path.nil?
-          result = []
-          offset = 0
-          max_items = query.delete(MAX_ITEMS)
-          remain_pages = query.delete(MAX_PAGES)
-          # merge default parameters, by default 100 per page
-          query = {'limit'=> PER_PAGE_DEFAULT}.merge(query)
-          loop do
-            query['offset'] = offset
-            page_result = @api_v5.read(real_path, query)
-            Aspera.assert_type(page_result[item_list_key], Array)
-            result.concat(page_result[item_list_key])
-            # reach the limit set by user ?
-            if !max_items.nil? && (result.length >= max_items)
-              result = result.slice(0, max_items)
-              break
-            end
-            break if result.length >= page_result['total_count']
-            remain_pages -= 1 unless remain_pages.nil?
-            break if remain_pages == 0
-            offset += page_result[item_list_key].length
-            formatter.long_operation_running
-          end
-          formatter.long_operation_terminated
-          return result
-        end
-
-        # lookup an entity id from its name
-        # @param type [String] the type of entity to lookup, by default it is the path, and it is also the field name in result
-        # @param value [String] the value to lookup
-        # @param field [String] the field to match, by default it is 'name'
-        # @param real_path [String] real path if it's not just the type (override type)
-        # @param item_list_key [String] key in the result to get the list of items (override type)
-        # @param query [Hash] additional query parameters
-        def lookup_entity_by_field(type:, value:, field: 'name', real_path: nil, item_list_key: nil, query: :default)
-          if query.eql?(:default)
-            Aspera.assert(field.eql?('name')){'Default query is on name only'}
-            query = {'q'=> value}
-          end
-          found = list_entities(type: type, real_path: real_path, query: query, item_list_key: item_list_key).select{ |i| i[field].eql?(value)}
-          case found.length
-          when 0 then raise "No #{type} with #{field} = #{value}"
-          when 1 then return found.first
-          else raise "Found #{found.length} #{real_path} with #{field} = #{value}"
-          end
-        end
-
         # list all packages with optional filter
         def list_packages_with_filter(query: {})
           filter = options.get_next_argument('filter', mandatory: false, validation: Proc, default: ->(_x){true})
           # translate box name to API prefix (with ending slash)
           box = options.get_option(:box)
-          real_path =
+          entity =
             case box
             when SpecialValues::ALL then 'packages' # only admin can list all packages globally
             when *API_LIST_MAILBOX_TYPES then "#{box}/packages"
             else
               group_type = options.get_option(:group_type)
-              "#{group_type}/#{lookup_entity_by_field(type: group_type, value: box)['id']}/packages"
+              "#{group_type}/#{lookup_entity_by_field(api: @api_v5, entity: group_type, value: box)['id']}/packages"
             end
-          return list_entities(
-            type: 'packages',
-            query:  query_read_delete(default: query),
-            real_path: real_path).select(&filter)
+          list, total = list_entities_limit_offset_total_count(
+            api: @api_v5,
+            entity: entity,
+            query:  query_read_delete(default: query)
+          )
+          return list.select(&filter), total
         end
 
         def package_receive(package_ids)
@@ -344,22 +318,23 @@ module Aspera
                 options.get_option(:url, mandatory: true),
                 options.get_option(:username, mandatory: true),
                 options.get_option(:box, mandatory: true)
-              ]))
+              ])
+            )
           end
           packages = []
           case package_ids
           when SpecialValues::INIT
             Aspera.assert(skip_ids_persistency){'Only with option once_only'}
-            skip_ids_persistency.data.clear.concat(list_packages_with_filter.map{ |p| p['id']})
+            skip_ids_persistency.data.clear.concat(list_packages_with_filter.first.map{ |p| p['id']})
             skip_ids_persistency.save
             return Main.result_status("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
           when SpecialValues::ALL
             # TODO: if packages have same name, they will overwrite ?
-            packages = list_packages_with_filter(query: {'status' => 'completed'})
-            Log.log.trace1{Log.dump(:package_ids, packages.map{ |p| p['id']})}
-            Log.log.trace1{Log.dump(:skip_ids, skip_ids_persistency.data)}
+            packages = list_packages_with_filter(query: {'status' => 'completed'}).first
+            Log.dump(:package_ids, level: :trace1){packages.map{ |p| p['id']}}
+            Log.dump(:skip_ids, skip_ids_persistency.data, level: :trace1)
             packages.reject!{ |p| skip_ids_persistency.data.include?(p['id'])} if skip_ids_persistency
-            Log.log.trace1{Log.dump(:package_ids, packages.map{ |p| p['id']})}
+            Log.dump(:package_ids, level: :trace1){packages.map{ |p| p['id']}}
           else
             # a single id was provided, or a list of ids
             package_ids = [package_ids] unless package_ids.is_a?(Array)
@@ -384,7 +359,7 @@ module Aspera
           when /outbox/ then download_params[:type] = 'sent'
           when *API_LIST_MAILBOX_TYPES then nil # nothing to do
           else # shared inbox / workgroup
-            download_params[:recipient_workgroup_id] = lookup_entity_by_field(type: options.get_option(:group_type), value: box)['id']
+            download_params[:recipient_workgroup_id] = lookup_entity_by_field(api: @api_v5, entity: options.get_option(:group_type), value: box)['id']
           end
           packages.each do |package|
             pkg_id = package['id']
@@ -448,17 +423,13 @@ module Aspera
                 all_items = all_items.slice(0, max_items) if all_items.count > max_items
                 break
               end
-              if recursive
-                folders_to_process.concat(response[:data]['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']})
-              end
+              folders_to_process.concat(response[:data]['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']}) if recursive
               if use_paging
                 iteration_token = response[:http][HEADER_ITERATION_TOKEN]
                 break if iteration_token.nil? || iteration_token.empty?
                 query['iteration_token'] = iteration_token
               else
-                if total_count.nil?
-                  total_count = response[:data]['total_count']
-                end
+                total_count = response[:data]['total_count'] if total_count.nil?
                 break if response[:data]['item_count'].eql?(0)
                 query['offset'] += response[:data]['item_count']
               end
@@ -484,7 +455,7 @@ module Aspera
             location = case options.get_option(:box)
             when 'inbox' then 'received'
             when 'outbox' then 'sent'
-            else raise 'Browse only available for inbox and outbox'
+            else raise BadArgument, 'Browse only available for inbox and outbox'
             end
             return browse_folder("packages/#{package_id}/files/#{location}")
           when :status
@@ -536,9 +507,11 @@ module Aspera
               # send from remote shared folder
               if (m = shared_folder.match(REGEX_LOOKUP_ID_BY_FIELD))
                 shared_folder = lookup_entity_by_field(
-                  type: 'shared_folders',
+                  api: @api_v5,
+                  entity: 'shared_folders',
                   field: m[1],
-                  value: ExtendedValue.instance.evaluate(m[2]))['id']
+                  value: ExtendedValue.instance.evaluate(m[2])
+                )['id']
               end
               transfer_request = {shared_folder_id: shared_folder, paths: transfer.source_list}
               # start remote transfer and get first status
@@ -551,100 +524,102 @@ module Aspera
               return Main.result_single_object(result)
             end
           when :list
-            return {
-              type:   :object_list,
-              data:   list_packages_with_filter,
-              fields: %w[id title release_date total_bytes total_files created_time state]
-            }
+            list, total = list_packages_with_filter
+            return Main.result_object_list(list, total: total, fields: %w[id title release_date total_bytes total_files created_time state])
           end
         end
 
-        def execute_resource(res_type)
-          list_key = res_path = res_type.to_s
-          id_as_arg = false
-          display_fields = nil
-          adm_api = @api_v5
+        def execute_resource(res_sym)
+          exec_args = {
+            api:    @api_v5,
+            entity: res_sym.to_s,
+            tclo:   true
+          }
           res_id_query = :default
-          delete_style = nil
-          available_commands = [].concat(Plugin::ALL_OPS)
-          case res_type
+          available_commands = Plugin::ALL_OPS
+          case res_sym
           when :metadata_profiles
-            res_path = 'configuration/metadata_profiles'
-            list_key = 'profiles'
+            exec_args[:entity] = 'configuration/metadata_profiles'
+            exec_args[:items_key] = 'profiles'
           when :alternate_addresses
-            res_path = 'configuration/alternate_addresses'
+            exec_args[:entity] = 'configuration/alternate_addresses'
           when :distribution_lists
-            res_path = 'account/distribution_lists'
-            list_key = 'distribution_lists'
-            delete_style = 'ids'
+            exec_args[:entity] = 'account/distribution_lists'
+            exec_args[:delete_style] = 'ids'
           when :email_notifications
-            list_key = false
-            id_as_arg = 'type'
+            exec_args.delete(:items_key)
+            exec_args[:id_as_arg] = 'type'
           when :accounts
-            display_fields = Formatter.all_but('user_profile_data_attributes')
-            available_commands.push(:reset_password)
+            exec_args[:display_fields] = Formatter.all_but('user_profile_data_attributes')
+            available_commands += [:reset_password]
           when :oauth_clients
-            display_fields = Formatter.all_but('public_key')
-            adm_api = Rest.new(**@api_v5.params, base_url: "#{@faspex5_api_base_url}/#{PATH_AUTH}")
+            exec_args[:display_fields] = Formatter.all_but('public_key')
+            exec_args[:api] = Rest.new(**@api_v5.params, base_url: "#{@faspex5_api_base_url}/#{PATH_AUTH}")
+            exec_args[:list_query] = {'expand': true, 'no_api_path': true, 'client_types[]': 'public'}
           when :shared_inboxes, :workgroups
-            available_commands.push(:members, :saml_groups, :invite_external_collaborator)
+            available_commands += %i[members saml_groups invite_external_collaborator]
             res_id_query = {'all': true}
           when :nodes
-            available_commands.push(:shared_folders, :browse)
+            available_commands += %i[shared_folders browse]
           end
           res_command = options.get_next_command(available_commands)
+          return Main.result_value_list(EMAIL_NOTIF_LIST, name: 'email_id') if res_command.eql?(:list) && res_sym.eql?(:email_notifications)
           case res_command
           when *Plugin::ALL_OPS
-            return entity_command(
-              res_command, adm_api, res_path, item_list_key: list_key, display_fields: display_fields, id_as_arg: id_as_arg,
-              delete_style: delete_style) do |field, value|
-                     lookup_entity_by_field(
-                       type: res_type, value: value, field: field, real_path: res_path, item_list_key: list_key, query: res_id_query)['id']
+            return entity_execute(command: res_command, **exec_args) do |field, value|
+                     lookup_entity_by_field(api: @api_v5, entity: exec_args[:entity], value: value, field: field, items_key: exec_args[:items_key], query: res_id_query)['id']
                    end
           when :shared_folders
+            # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(type: res_type, field: field, value: value)['id']
+              lookup_entity_by_field(api: @api_v5, entity: 'nodes', field: field, value: value)['id']
             end
-            sh_path = "#{res_path}/#{node_id}/shared_folders"
-            sh_command = options.get_next_command([:user].concat(Plugin::ALL_OPS))
+            shfld_entity = "nodes/#{node_id}/shared_folders"
+            sh_command = options.get_next_command(Plugin::ALL_OPS + [:user])
             case sh_command
             when *Plugin::ALL_OPS
-              return entity_command(sh_command, adm_api, sh_path, item_list_key: 'shared_folders') do |field, value|
-                       lookup_entity_by_field(type: 'shared_folders', real_path: sh_path, field: field, value: value)['id']
+              return entity_execute(
+                api: @api_v5,
+                entity: shfld_entity,
+                command: sh_command
+              ) do |field, value|
+                       lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
                      end
             when :user
               sh_id = instance_identifier do |field, value|
-                lookup_entity_by_field(type: 'shared_folders', real_path: sh_path, field: field, value: value)['id']
+                lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
               end
-              user_path = "#{sh_path}/#{sh_id}/custom_access_users"
-              return entity_action(adm_api, user_path, item_list_key: 'users') do |field, value|
-                       lookup_entity_by_field(type: 'users', real_path: user_path, field: field, value: value)['id']
+              user_path = "#{shfld_entity}/#{sh_id}/custom_access_users"
+              return entity_execute(api: @api_v5, entity: user_path, items_key: 'users') do |field, value|
+                       lookup_entity_by_field(api: @api_v5, entity: user_path, items_key: 'users', field: field, value: value)['id']
                      end
 
             end
           when :browse
+            # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(
-                type: res_type, value: value, field: field, real_path: res_path, item_list_key: list_key, query: res_id_query)['id']
+              lookup_entity_by_field(api: @api_v5, entity: 'nodes', value: value, field: field)['id']
             end
-            return browse_folder("#{res_path}/#{node_id}/browse")
+            return browse_folder("nodes/#{node_id}/browse")
           when :invite_external_collaborator
-            shared_inbox_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
+            # :shared_inboxes, :workgroups
+            shared_inbox_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
             creation_payload = value_create_modify(command: res_command, type: [Hash, String])
             creation_payload = {'email_address' => creation_payload} if creation_payload.is_a?(String)
-            res_path = "#{res_type}/#{shared_inbox_id}/external_collaborator"
-            result = adm_api.create(res_path, creation_payload)
+            result = @api_v5.create("#{res_sym}/#{shared_inbox_id}/external_collaborator", creation_payload)
             formatter.display_status(result['message'])
             result = lookup_entity_by_field(
-              type: 'members',
-              real_path: "#{res_type}/#{shared_inbox_id}/members",
+              api: @api_v5,
+              entity: "#{res_sym}/#{shared_inbox_id}/members",
+              items_key: 'members',
               value: creation_payload['email_address'],
-              query: {})
+              query: {}
+            )
             return Main.result_single_object(result)
           when :members, :saml_groups
-            res_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
-            res_prefix = "#{res_type}/#{res_id}"
-            res_path = "#{res_prefix}/#{res_command}"
+            # :shared_inboxes, :workgroups
+            res_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
+            res_path = "#{res_sym}/#{res_id}/#{res_command}"
             list_key = res_command.to_s
             list_key = 'groups' if res_command.eql?(:saml_groups)
             sub_command = options.get_next_command(%i[create list modify delete])
@@ -655,10 +630,12 @@ module Aspera
               users = users.map do |user|
                 if (m = user.match(REGEX_LOOKUP_ID_BY_FIELD))
                   lookup_entity_by_field(
-                    type: 'accounts',
+                    api: @api_v5,
+                    entity: 'accounts',
                     field: m[1],
                     value: ExtendedValue.instance.evaluate(m[2]),
-                    query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})})['id']
+                    query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})}
+                  )['id']
                 else
                   # it's the user id (not member id...)
                   user
@@ -667,16 +644,24 @@ module Aspera
               access = options.get_next_argument('level', mandatory: false, accept_list: %i[submit_only standard shared_inbox_admin], default: :standard)
               options.unshift_next_argument({user: users.map{ |u| {id: u, access: access}}})
             end
-            return entity_command(sub_command, adm_api, res_path, item_list_key: list_key) do |field, value|
+            return entity_execute(
+              api: @api_v5,
+              entity: res_path,
+              command: sub_command,
+              items_key: list_key
+            ) do |field, value|
                      lookup_entity_by_field(
-                       type: 'accounts',
+                       api: @api_v5,
+                       entity: 'accounts',
                        field: field,
                        value: value,
-                       query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})})['id']
+                       query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})}
+                     )['id']
                    end
           when :reset_password
-            contact_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
-            adm_api.create("#{res_type}/#{contact_id}/reset_password", {})
+            # :accounts
+            contact_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: 'accounts', field: field, value: value, query: res_id_query)['id']}
+            @api_v5.create("accounts/#{contact_id}/reset_password", {})
             return Main.result_status('password reset, user shall check email')
           end
           Aspera.error_unreachable_line
@@ -700,12 +685,21 @@ module Aspera
             event_type = options.get_next_command(%i[application webhook])
             case event_type
             when :application
-              return Main.result_object_list(
-                list_entities(type: 'application_events', query: query_read_delete),
-                fields: %w[event_type created_at application user.name])
+              list, total = list_entities_limit_offset_total_count(
+                api: @api_v5,
+                entity: 'application_events',
+                query: query_read_delete
+              )
+
+              return Main.result_object_list(list, total: total, fields: %w[event_type created_at application user.name])
             when :webhook
-              return Main.result_object_list(
-                list_entities(type: 'all_webhooks_events', query: query_read_delete, item_list_key: 'events'))
+              list, total = list_entities_limit_offset_total_count(
+                api: @api_v5,
+                entity: 'all_webhooks_events',
+                query: query_read_delete,
+                items_key: 'events'
+              )
+              return Main.result_object_list(list, total: total)
             end
           when :configuration
             conf_path = 'configuration'
@@ -717,6 +711,7 @@ module Aspera
               return Main.result_single_object(@api_v5.update(conf_path, value_create_modify(command: conf_cmd)))
             end
           when :smtp
+            # only one SMTP config
             smtp_path = 'configuration/smtp'
             smtp_cmd = options.get_next_command(%i[show create modify delete test])
             case smtp_cmd
@@ -807,11 +802,15 @@ module Aspera
               @api_v5.create("#{invitation_endpoint}/#{instance_identifier}/resend")
               return Main.result_status('Invitation resent')
             else
-              return entity_command(
-                invitation_command, @api_v5, invitation_endpoint, item_list_key: invitation_endpoint,
-                display_fields: %w[id public recipient_type recipient_name email_address]) do |field, value|
-                  lookup_entity_by_field(type: invitation_endpoint, field: field, value: value, query: {})['id']
-                end
+              return entity_execute(
+                api: @api_v5,
+                entity: invitation_endpoint,
+                command: invitation_command,
+                items_key: invitation_endpoint,
+                display_fields: %w[id public recipient_type recipient_name email_address]
+              ) do |field, value|
+                lookup_entity_by_field(api: @api_v5, entity: invitation_endpoint, field: field, value: value, query: {})['id']
+              end
             end
           when :gateway
             require 'aspera/faspex_gw'

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

@@ -17,8 +17,8 @@ module Aspera
             api = Rest.new(base_url: base_url)
             ping_result = api.call(operation: 'GET', subpath: 'ping', headers: {'Accept' => Rest::MIME_JSON})
             server_type = ping_result[:http]['Server']
-            return nil unless ping_result[:data].is_a?(Hash) && ping_result[:data].empty?
-            return nil unless server_type.is_a?(String) && server_type.include?('faspio')
+            return unless ping_result[:data].is_a?(Hash) && ping_result[:data].empty?
+            return unless server_type.is_a?(String) && server_type.include?('faspio')
             return {
               version: server_type.gsub(%r{^.*/}, ''),
               url:     base_url
@@ -39,7 +39,7 @@ module Aspera
         end
         ACTIONS = %i[health bridges].freeze
 
-        def initialize(**env)
+        def initialize(**_)
           super
           options.declare(:auth, 'OAuth type of authentication', values: %i[jwt basic])
           options.declare(:client_id, 'OAuth client identifier')
@@ -70,7 +70,8 @@ module Aspera
                   },
                   private_key_obj: OpenSSL::PKey::RSA.new(options.get_option(:private_key, mandatory: true), options.get_option(:passphrase)),
                   headers:         {typ: 'JWT'}
-                })
+                }
+              )
             end
           command = options.get_next_command(ACTIONS)
           case command
@@ -88,7 +89,7 @@ module Aspera
             end
             return nagios.result
           when :bridges
-            return entity_action(api, 'bridges')
+            return entity_execute(api: api, entity: 'bridges')
           end
         end
       end

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

@@ -20,7 +20,7 @@ module Aspera
               url:     api.base_url,
               version: api_info['version']
             } if api_info.is_a?(Hash) && api_info.key?('download_endpoint')
-            return nil
+            return
           end
 
           # @param object [Plugin] An instance of this class
@@ -37,7 +37,7 @@ module Aspera
         end
         ACTIONS = %i[health info].freeze
 
-        def initialize(**env)
+        def initialize(**_)
           super
           options.declare(:url, 'URL of application, e.g. https://app.example.com/aspera/app')
           options.parse_options!