aspera-cli 4.12.0 → 4.14.0

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

@@ -23,7 +23,10 @@ module Aspera
             # either in standard domain, or product name in page
             if URI.parse(base_url).host.end_with?(Aspera::AoC::PROD_DOMAIN) ||
                 api.call({operation: 'GET', redirect_max: 1, headers: {'Accept' => 'text/html'}})[:http].body.include?(Aspera::AoC::PRODUCT_NAME)
-              return {product: :aoc, version: 'SaaS' }
+              return {
+                version: 'SaaS',
+                name:    'Aspera on Cloud'
+              }
             end
             return nil
           end
@@ -50,6 +53,7 @@ module Aspera
           client_registration_token
           client_access_key
           kms_profile].freeze
+        # TODO: remove this and use %name: instead
         ENTITY_NAME_SPECIFIER = 'name'
         PACKAGE_QUERY_DEFAULT = {'archived' => false, 'exclude_dropbox_packages' => true, 'has_content' => true, 'received' => true}.freeze
 
@@ -58,28 +62,23 @@ module Aspera
           @cache_workspace_info = nil
           @cache_home_node_file = nil
           @cache_api_aoc = nil
-          options.add_opt_list(:auth, Oauth::STD_AUTH_TYPES, 'OAuth type of authentication')
-          options.add_opt_list(:operation, %i[push pull], 'client operation for transfers')
-          options.add_opt_simple(:client_id, 'OAuth API client identifier')
-          options.add_opt_simple(:client_secret, 'OAuth API client secret')
-          options.add_opt_simple(:redirect_uri, 'OAuth API client redirect URI')
-          options.add_opt_simple(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
-          options.add_opt_simple(:scope, 'OAuth scope for AoC API calls')
-          options.add_opt_simple(:passphrase, 'RSA private key passphrase')
-          options.add_opt_simple(:workspace, 'Name of workspace')
-          options.add_opt_simple(:name, "Resource name (prefer to use keyword #{ENTITY_NAME_SPECIFIER})")
-          options.add_opt_simple(:link, 'Public link to shared resource')
-          options.add_opt_simple(:new_user_option, 'New user creation option for unknown package recipients')
-          options.add_opt_simple(:from_folder, 'Source folder for Folder-to-Folder transfer')
-          options.add_opt_boolean(:validate_metadata, 'Validate shared inbox metadata')
-          options.set_option(:validate_metadata, :yes)
-          options.set_option(:operation, :push)
-          options.set_option(:auth, :jwt)
-          options.set_option(:scope, AoC::SCOPE_FILES_USER)
-          options.set_option(:private_key, '@file:' + env[:private_key_path]) if env[:private_key_path].is_a?(String)
-          options.set_option(:workspace, :default)
+          options.declare(:auth, 'OAuth type of authentication', values: Oauth::STD_AUTH_TYPES, default: :jwt)
+          options.declare(:operation, 'Client operation for transfers', values: %i[push pull], default: :push)
+          options.declare(:client_id, 'OAuth API client identifier')
+          options.declare(:client_secret, 'OAuth API client secret')
+          options.declare(:redirect_uri, 'OAuth API client redirect URI')
+          options.declare(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
+          options.declare(:scope, 'OAuth scope for AoC API calls', default: AoC::SCOPE_FILES_USER)
+          options.declare(:passphrase, 'RSA private key passphrase')
+          options.declare(:workspace, 'Name of workspace', default: :default)
+          # TODO: remove this and use %name: instead
+          options.declare(:name, "Resource name (prefer to use keyword #{ENTITY_NAME_SPECIFIER})")
+          options.declare(:link, 'Public link to shared resource')
+          options.declare(:new_user_option, 'New user creation option for unknown package recipients')
+          options.declare(:from_folder, 'Source folder for Folder-to-Folder transfer')
+          options.declare(:validate_metadata, 'Validate shared inbox metadata', values: :bool, default: true)
           options.parse_options!
-          # add node plugin options
+          # add node plugin options (TODO: check needed ? if yes, tell why)
           Node.new(env.merge({man_only: true, skip_basic_auth_options: true}))
         end
 
@@ -114,7 +113,7 @@ module Aspera
               Log.log.debug('Using default workspace'.green)
               raise CliError, 'No default workspace defined for user, please specify workspace' if default_workspace_id.nil?
               default_workspace_id
-            when String then aoc_api.lookup_entity_by_name('workspaces', ws_name)['id']
+            when String then aoc_api.lookup_by_name('workspaces', ws_name)['id']
             when NilClass then nil
             else raise CliError, 'unexpected value type for workspace'
             end
@@ -142,6 +141,13 @@ module Aspera
           end
           home_node_id ||= current_workspace_info['home_node_id'] || current_workspace_info['node_id']
           home_file_id ||= current_workspace_info['home_file_id']
+          if home_node_id.to_s.empty?
+            # not part of any workspace, but has some folder shared
+            user_info = aoc_api.current_user_info(exception: true)
+            home_node_id = user_info['read_only_home_node_id']
+            home_file_id = user_info['read_only_home_file_id']
+          end
+
           raise "Cannot get user's home node id, check your default workspace or specify one" if home_node_id.to_s.empty?
           @cache_home_node_file = {
             node_id: home_node_id,
@@ -157,11 +163,11 @@ module Aspera
           l_res_name = options.get_option(:name)
           raise 'Provide either option id or name, not both' unless l_res_id.nil? || l_res_name.nil?
           # try to find item by name (single partial match or exact match)
-          l_res_id = aoc_api.lookup_entity_by_name(resource_class_path, l_res_name)['id'] unless l_res_name.nil?
+          l_res_id = aoc_api.lookup_by_name(resource_class_path, l_res_name)['id'] unless l_res_name.nil?
           # if no name or id option, taken on command line (after command)
           if l_res_id.nil?
             l_res_id = options.get_next_argument('identifier')
-            l_res_id = aoc_api.lookup_entity_by_name(resource_class_path, options.get_next_argument('identifier'))['id'] if l_res_id.eql?(ENTITY_NAME_SPECIFIER)
+            l_res_id = aoc_api.lookup_by_name(resource_class_path, options.get_next_argument('identifier'))['id'] if l_res_id.eql?(ENTITY_NAME_SPECIFIER)
           end
           return l_res_id
         end
@@ -214,7 +220,12 @@ module Aspera
         # @param file_id [String] root file id for the operation (can be AK root, or other, e.g. package, or link)
         # @param scope [String] node scope, or nil (admin)
         def execute_nodegen4_command(command_repo, node_id, file_id: nil, scope: nil)
-          top_node_api = aoc_api.node_api_from(node_id: node_id, workspace_info: current_workspace_info, scope: scope)
+          top_node_api = aoc_api.node_api_from(
+            node_id: node_id,
+            workspace_id: current_workspace_info['id'],
+            workspace_name: current_workspace_info['name'],
+            scope: scope
+          )
           file_id = top_node_api.read("access_keys/#{top_node_api.app_info[:node_info]['access_key']}")[:data]['root_file_id'] if file_id.nil?
           node_plugin = Node.new(@agents.merge(
             skip_basic_auth_options: true,
@@ -228,15 +239,15 @@ module Aspera
             # server side is protocol server
             # in same workspace
             # default is push
-            case options.get_option(:operation, is_type: :mandatory)
+            case options.get_option(:operation, mandatory: true)
             when :push
               client_direction = Fasp::TransferSpec::DIRECTION_SEND
-              client_folder = options.get_option(:from_folder, is_type: :mandatory)
+              client_folder = options.get_option(:from_folder, mandatory: true)
               server_folder = transfer.destination_folder(client_direction)
             when :pull
               client_direction = Fasp::TransferSpec::DIRECTION_RECEIVE
               client_folder = transfer.destination_folder(client_direction)
-              server_folder = options.get_option(:from_folder, is_type: :mandatory)
+              server_folder = options.get_option(:from_folder, mandatory: true)
             end
             client_apfid = top_node_api.resolve_api_fid(file_id, client_folder)
             server_apfid = top_node_api.resolve_api_fid(file_id, server_folder)
@@ -359,12 +370,12 @@ module Aspera
               filter = options.get_option(:query) || {}
               raise 'query must be Hash' unless filter.is_a?(Hash)
               filter['limit'] ||= 100
-              if options.get_option(:once_only, is_type: :mandatory)
+              if options.get_option(:once_only, mandatory: true)
                 saved_date = []
                 start_date_persistency = PersistencyActionOnce.new(
                   manager: @agents[:persistency],
                   data: saved_date,
-                  ids: IdGenerator.from_list(['aoc_ana_date', options.get_option(:url, is_type: :mandatory), current_workspace_info['name']].push(
+                  ids: IdGenerator.from_list(['aoc_ana_date', options.get_option(:url, mandatory: true), current_workspace_info['name']].push(
                     filter_resource,
                     filter_id)))
                 start_date_time = saved_date.first
@@ -375,7 +386,7 @@ module Aspera
                 filter['start_time'] = start_date_time unless start_date_time.nil?
                 filter['stop_time'] = stop_date_time
               end
-              events = analytics_api.read("#{filter_resource}/#{filter_id}/#{event_type}", option_url_query(filter))[:data][event_type]
+              events = analytics_api.read("#{filter_resource}/#{filter_id}/#{event_type}", query_read_delete(default: filter))[:data][event_type]
               start_date_persistency&.save
               if !options.get_option(:notif_to).nil?
                 events.each do |tr_event|
@@ -439,10 +450,8 @@ module Aspera
               when :group_membership then default_fields.push(*%w[group_id member_type member_id])
               when :workspace_membership then default_fields.push(*%w[workspace_id member_type member_id])
               end
-              items = read_with_paging(resource_class_path, option_url_query(default_query))
-              count_msg = "Items: #{items[:list].length}/#{items[:total]}"
-              count_msg = count_msg.bg_red unless items[:list].length.eql?(items[:total].to_i)
-              formatter.display_status(count_msg)
+              items = read_with_paging(resource_class_path, query_read_delete(default: default_query))
+              formatter.display_item_count(items[:list].length, items[:total])
               return {type: :object_list, data: items[:list], fields: default_fields}
             when :show
               object = aoc_api.read(resource_instance_path)[:data]
@@ -481,7 +490,7 @@ module Aspera
           case command
           when :reminder
             # send an email reminder with list of orgs
-            user_email = options.get_option(:username, is_type: :mandatory)
+            user_email = options.get_option(:username, mandatory: true)
             Rest.new(base_url: "#{AoC.api_base_url}/#{AoC::API_V1}").create('organization_reminders', {email: user_email})[:data]
             return Main.result_status("List of organizations user is member of, has been sent by e-mail to #{user_email}")
           when :servers
@@ -518,7 +527,7 @@ module Aspera
             when :shared_inboxes
               case options.get_next_command(%i[list show])
               when :list
-                query = option_url_query(nil)
+                query = query_read_delete
                 if query.nil?
                   query = {'embed[]' => 'dropbox', 'aggregate_permissions_by_dropbox' => true, 'sort' => 'dropbox_name'}
                   query['workspace_id'] = current_workspace_info['id'] unless current_workspace_info['id'].eql?(:undefined)
@@ -528,8 +537,7 @@ module Aspera
                 return {type: :single_object, data: aoc_api.read(get_resource_path_from_args('dropboxes'), query)[:data]}
               end
             when :send
-              package_data = options.get_option(:value, is_type: :mandatory)
-              raise CliBadArgument, 'value must be hash, refer to doc' unless package_data.is_a?(Hash)
+              package_data = value_create_modify(command: package_command, type: Hash)
               new_user_option = options.get_option(:new_user_option)
               option_validate = options.get_option(:validate_metadata)
               # works for both normal usr auth and link auth
@@ -557,20 +565,20 @@ module Aspera
               ids_to_download = instance_identifier
               skip_ids_data = []
               skip_ids_persistency = nil
-              if options.get_option(:once_only, is_type: :mandatory)
+              if options.get_option(:once_only, mandatory: true)
                 skip_ids_persistency = PersistencyActionOnce.new(
                   manager: @agents[:persistency],
                   data: skip_ids_data,
-                  id: IdGenerator.from_list(['aoc_recv', options.get_option(:url, is_type: :mandatory),
+                  id: IdGenerator.from_list(['aoc_recv', options.get_option(:url, mandatory: true),
                                              current_workspace_info['id']].concat(aoc_api.additional_persistence_ids)))
               end
               if VAL_ALL.eql?(ids_to_download)
-                query = option_url_query(PACKAGE_QUERY_DEFAULT)
+                query = query_read_delete(default: PACKAGE_QUERY_DEFAULT)
                 raise 'option query must be Hash' unless query.is_a?(Hash)
                 if query.key?('dropbox_name')
                   # convenience: specify name instead of id
                   raise 'not both dropbox_name and dropbox_id' if query.key?('dropbox_id')
-                  query['dropbox_id'] = aoc_api.lookup_entity_by_name('dropboxes', query['dropbox_name'])['id']
+                  query['dropbox_id'] = aoc_api.lookup_by_name('dropboxes', query['dropbox_name'])['id']
                   query.delete('dropbox_name')
                 end
                 query['workspace_id'] ||= current_workspace_info['id'] unless current_workspace_info['id'].eql?(:undefined)
@@ -588,7 +596,11 @@ module Aspera
               ids_to_download.each do |package_id|
                 package_info = aoc_api.read("packages/#{package_id}")[:data]
                 formatter.display_status("downloading package: #{package_info['name']}")
-                package_node_api = aoc_api.node_api_from(package_info: package_info, scope: AoC::SCOPE_NODE_USER)
+                package_node_api = aoc_api.node_api_from(
+                  node_id: package_info['node_id'],
+                  workspace_id: current_workspace_info['id'],
+                  workspace_name: current_workspace_info['name'],
+                  package_info: package_info)
                 statuses = transfer.start(
                   package_node_api.transfer_spec_gen4(
                     package_info['contents_file_id'],
@@ -609,12 +621,12 @@ module Aspera
               return { type: :single_object, data: package_info }
             when :list
               display_fields = %w[id name bytes_transferred]
-              query = option_url_query(PACKAGE_QUERY_DEFAULT)
+              query = query_read_delete(default: PACKAGE_QUERY_DEFAULT)
               raise 'option query must be Hash' unless query.is_a?(Hash)
               if query.key?('dropbox_name')
                 # convenience: specify name instead of id
                 raise 'not both dropbox_name and dropbox_id' if query.key?('dropbox_id')
-                query['dropbox_id'] = aoc_api.lookup_entity_by_name('dropboxes', query['dropbox_name'])['id']
+                query['dropbox_id'] = aoc_api.lookup_by_name('dropboxes', query['dropbox_name'])['id']
                 query.delete('dropbox_name')
               end
               if current_workspace_info['id'].eql?(:undefined)
@@ -641,72 +653,111 @@ module Aspera
             when *NODE4_EXT_COMMANDS
               return execute_nodegen4_command(command_repo, home_info[:node_id], file_id: home_info[:file_id], scope: AoC::SCOPE_NODE_USER)
             when :short_link
-              # TODO: move to permissions ?
-              folder_dest = options.get_option(:to_folder)
-              value_option = options.get_option(:value)
-              case value_option
-              when 'public'  then value_option = {'purpose' => 'token_auth_redirection'}
-              when 'private' then value_option = {'purpose' => 'shared_folder_auth_link'}
-              when NilClass, Hash then nil # keep value
-              else raise 'value must be either: public, private, Hash or nil'
+              # execute action on AoC API
+              short_link_command = options.get_next_command(%i[create delete list])
+              folder_dest = options.get_next_argument('path')
+              link_type = options.get_next_argument('link type', expected: %i[public private])
+              home_node_api = aoc_api.node_api_from(
+                node_id: home_info[:node_id],
+                workspace_id: current_workspace_info['id'],
+                workspace_name: current_workspace_info['name'])
+              shared_apfid = home_node_api.resolve_api_fid(home_info[:file_id], folder_dest)
+              folder_info = {
+                node_id:      shared_apfid[:api].app_info[:node_info]['id'],
+                file_id:      shared_apfid[:file_id],
+                workspace_id: current_workspace_info['id']
+              }
+              purpose = case link_type
+              when :public  then 'token_auth_redirection'
+              when :private then 'shared_folder_auth_link'
+              else raise 'internal error'
               end
-              create_params = nil
-              shared_apfid = nil
-              if !folder_dest.nil?
-                home_node_api = aoc_api.node_api_from(node_id: home_info[:node_id], workspace_info: current_workspace_info, scope: AoC::SCOPE_NODE_USER)
-                shared_apfid = home_node_api.resolve_api_fid(home_info[:file_id], folder_dest)
-                create_params = {
-                  file_id:      shared_apfid[:file_id],
-                  node_id:      shared_apfid[:api].app_info[:node_info]['id'],
-                  workspace_id: current_workspace_info['id']
+              case short_link_command
+              when :delete
+                one_id = instance_identifier
+                folder_info.delete(:workspace_id)
+                delete_params = {
+                  edit_access: true,
+                  json_query:  folder_info.to_json
                 }
-              end
-              if !value_option.nil? && !create_params.nil?
-                case value_option['purpose']
-                when 'shared_folder_auth_link'
-                  value_option['data'] = create_params
-                  value_option['user_selected_name'] = nil
-                when 'token_auth_redirection'
-                  create_params['name'] = ''
-                  value_option['data'] = {
+                aoc_api.delete("short_links/#{one_id}", delete_params)
+                if link_type.eql?(:public)
+                  # TODO: get permission id..
+                  # shared_apfid[:api].delete('permissions', {ids: })[:data]
+                end
+                return Main.result_status('deleted')
+              when :list
+                query = if link_type.eql?(:private)
+                  folder_info
+                else
+                  {
+                    url_token_data: {
+                      data:    folder_info,
+                      purpose: 'view_shared_file'
+                    }
+                  }
+                end
+                list_params = {
+                  json_query:  query.to_json,
+                  edit_access: true,
+                  purpose:     purpose,
+                  # embed: 'updated_by_user',
+                  sort:        '-created_at'
+                }
+                result = aoc_api.read('short_links', list_params)[:data]
+                result.each{|i|i.delete('data')}
+                return {type: :object_list, data: result}
+              when :create
+                creation_params = {
+                  purpose:            purpose,
+                  user_selected_name: nil
+                }
+                case link_type
+                when :private
+                  creation_params[:data] = folder_info
+                when :public
+                  creation_params[:expires_at]       = nil
+                  creation_params[:password_enabled] = false
+                  folder_info[:name] = ''
+                  creation_params[:data] = {
                     aoc:            true,
                     url_token_data: {
-                      data:    create_params,
+                      data:    folder_info,
                       purpose: 'view_shared_file'
                     }
                   }
-                  value_option['user_selected_name'] = nil
-                else
-                  raise 'purpose must be one of: token_auth_redirection or shared_folder_auth_link'
                 end
-                options.set_option(:value, value_option)
-              end
-              result = entity_action(aoc_api, 'short_links', id_default: 'self')
-              if result[:data].is_a?(Hash) && result[:data].key?('created_at') && result[:data]['resource_type'].eql?('UrlToken')
-                # TODO: access level as arg
-                access_levels = Aspera::Node::ACCESS_LEVELS # ['delete','list','mkdir','preview','read','rename','write']
-                perm_data = {
-                  'file_id'       => shared_apfid[:file_id],
-                  'access_type'   => 'user',
-                  'access_id'     => result[:data]['resource_id'],
-                  'access_levels' => access_levels,
-                  'tags'          => {
-                    'url_token'        => true,
-                    'workspace_id'     => current_workspace_info['id'],
-                    'workspace_name'   => current_workspace_info['name'],
-                    'folder_name'      => 'my folder',
-                    'created_by_name'  => aoc_api.current_user_info['name'],
-                    'created_by_email' => aoc_api.current_user_info['email'],
-                    'access_key'       => shared_apfid[:api].app_info[:node_info]['access_key'],
-                    'node'             => shared_apfid[:api].app_info[:node_info]['host']
+                result_create_short_link = aoc_api.create('short_links', creation_params)[:data]
+                # public: Creation: permission on node
+                if link_type.eql?(:public)
+                  # TODO: merge with node permissions ?
+                  # TODO: access level as arg
+                  access_levels = Aspera::Node::ACCESS_LEVELS # ['delete','list','mkdir','preview','read','rename','write']
+                  folder_name = File.basename(folder_dest)
+                  perm_data = {
+                    'file_id'       => shared_apfid[:file_id],
+                    'access_id'     => result_create_short_link['resource_id'],
+                    'access_type'   => 'user',
+                    'access_levels' => access_levels,
+                    'tags'          => {
+                      'url_token'        => true,
+                      'workspace_id'     => current_workspace_info['id'],
+                      'workspace_name'   => current_workspace_info['name'],
+                      'folder_name'      => folder_name,
+                      'created_by_name'  => aoc_api.current_user_info['name'],
+                      'created_by_email' => aoc_api.current_user_info['email'],
+                      'access_key'       => shared_apfid[:api].app_info[:node_info]['access_key'],
+                      'node'             => shared_apfid[:api].app_info[:node_info]['host']
+                    }
                   }
-                }
-                shared_apfid[:api].create("permissions?file_id=#{shared_apfid[:file_id]}", perm_data)
-                # TODO: event ?
-              end
-              return result
+                  created_data = shared_apfid[:api].create('permissions', perm_data)[:data]
+                  aoc_api.permissions_send_event(created_data: created_data, app_info: shared_apfid[:api].app_info)
+                  # TODO: event ?
+                end
+                return {type: :single_object, data: result_create_short_link}
+              end # short_link command
             end # files command
-            throw('Error: shall not reach this line')
+            raise 'Error: shall not reach this line'
           when :automation
             Log.log.warn('BETA: work under progress')
             # automation api is not in the same place
@@ -743,7 +794,7 @@ module Aspera
             return execute_admin_action
           when :gateway
             require 'aspera/faspex_gw'
-            url = options.get_option(:value, is_type: :mandatory)
+            url = value_create_modify(type: String)
             uri = URI.parse(url)
             server = WebServerSimple.new(uri)
             server.mount(uri.path, Faspex4GWServlet, aoc_api, current_workspace_info['id'])
@@ -759,6 +810,86 @@ module Aspera
           raise 'internal error: command shall return'
         end
 
+        # @param [Hash] params : plugin_sym, instance_url
+        # @return [Hash] :preset_value, :test_args
+        def wizard(params)
+          if params[:prepare]
+            organization = AoC.parse_url(params[:instance_url]).first
+            # if not defined by user, generate name
+            params[:preset_name] ||= [params[:plugin_sym], organization].join('_')
+            params[:need_private_key] = true
+            return
+          end
+          options.set_option(:private_key, '@file:' + params[:private_key_path])
+          # make username mandatory for jwt, this triggers interactive input
+          options.get_option(:username, mandatory: true)
+          auto_set_pub_key = false
+          auto_set_jwt = false
+          use_browser_authentication = false
+          if options.get_option(:use_generic_client)
+            formatter.display_status('Using global client_id.')
+            formatter.display_status('Please Login to your Aspera on Cloud instance.'.red)
+            formatter.display_status('Navigate to your "Account Settings"'.red)
+            formatter.display_status('Check or update the value of "Public Key" to be:'.red.blink)
+            formatter.display_status(params[:pub_key_pem])
+            if !options.get_option(:test_mode)
+              formatter.display_status('Once updated or validated, press enter.')
+              OpenApplication.instance.uri(params[:instance_url])
+              $stdin.gets
+            end
+          else
+            formatter.display_status('Using organization specific client_id.')
+            if options.get_option(:client_id).nil? || options.get_option(:client_secret).nil?
+              formatter.display_status('Please login to your Aspera on Cloud instance.'.red)
+              formatter.display_status('Go to: Apps->Admin->Organization->Integrations')
+              formatter.display_status('Create or check if there is an existing integration named:')
+              formatter.display_status("- name: #{@info[:name]}")
+              formatter.display_status("- redirect uri: #{DEFAULT_REDIRECT}")
+              formatter.display_status('- origin: localhost')
+              formatter.display_status('Once created or identified,')
+              formatter.display_status('Please enter:'.red)
+            end
+            OpenApplication.instance.uri("#{params[:instance_url]}/#{AOC_PATH_API_CLIENTS}")
+            options.get_option(:client_id, mandatory: true)
+            options.get_option(:client_secret, mandatory: true)
+            use_browser_authentication = true
+          end
+          if use_browser_authentication
+            formatter.display_status('We will use web authentication to bootstrap.')
+            auto_set_pub_key = true
+            auto_set_jwt = true
+            aoc_api.oauth.generic_parameters[:grant_method] = :web
+            aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
+            aoc_api.oauth.specific_parameters[:redirect_uri] = DEFAULT_REDIRECT
+          end
+          myself = aoc_api.read('self')[:data]
+          if auto_set_pub_key
+            raise CliError, 'Public key is already set in profile (use --override=yes)' unless myself['public_key'].empty? || option_override
+            formatter.display_status('Updating profile with new key')
+            aoc_api.update("users/#{myself['id']}", {'public_key' => params[:pub_key_pem]})
+          end
+          if auto_set_jwt
+            formatter.display_status('Enabling JWT for client')
+            aoc_api.update("clients/#{options.get_option(:client_id)}", {'jwt_grant_enabled' => true, 'explicit_authorization_required' => false})
+          end
+          formatter.display_status("Creating new config preset: #{params[:preset_name]}")
+          preset_result = {
+            url:         params[:instance_url],
+            username:    myself['email'],
+            auth:        :jwt.to_s,
+            private_key: '@file:' + params[:private_key_path]
+          }.stringify_keys
+          # set only if non nil
+          %i[client_id client_secret].each do |s|
+            o = options.get_option(s)
+            preset_result[s.to_s] = o unless o.nil?
+          end
+          return {
+            preset_value: preset_result,
+            test_args:    "#{params[:plugin_sym]} user profile show"
+          }
+        end
+
         private :aoc_params,
           :home_info,
           :assert_public_link_types,

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

@@ -7,25 +7,24 @@ module Aspera
   module Cli
     module Plugins
       # Access Aspera Transfer Service
-      # https://52.44.83.163/docs/
       # https://developer.ibm.com/aspera/docs/ats-api-reference/creating-ats-api-keys/
       class Ats < Aspera::Cli::Plugin
         def initialize(env)
           super(env)
-          options.add_opt_simple(:ibm_api_key, 'IBM API key, see https://cloud.ibm.com/iam/apikeys')
-          options.add_opt_simple(:instance, 'ATS instance in ibm cloud')
-          options.add_opt_simple(:ats_key, 'ATS key identifier (ats_xxx)')
-          options.add_opt_simple(:ats_secret, 'ATS key secret')
-          options.add_opt_simple(:params, 'Parameters access key creation (@json:)')
-          options.add_opt_simple(:cloud, 'Cloud provider')
-          options.add_opt_simple(:region, 'Cloud region')
+          options.declare(:ibm_api_key, 'IBM API key, see https://cloud.ibm.com/iam/apikeys')
+          options.declare(:instance, 'ATS instance in ibm cloud')
+          options.declare(:ats_key, 'ATS key identifier (ats_xxx)')
+          options.declare(:ats_secret, 'ATS key secret')
+          options.declare(:params, 'Parameters access key creation (@json:)')
+          options.declare(:cloud, 'Cloud provider')
+          options.declare(:region, 'Cloud region')
           options.parse_options!
         end
 
         def server_by_cloud_region
           # TODO: provide list ?
-          cloud = options.get_option(:cloud, is_type: :mandatory).upcase
-          region = options.get_option(:region, is_type: :mandatory)
+          cloud = options.get_option(:cloud, mandatory: true).upcase
+          region = options.get_option(:region, mandatory: true)
           return @ats_api_pub.read("servers/#{cloud}/#{region}")[:data]
         end
 
@@ -36,8 +35,8 @@ module Aspera
             base_url: AtsApi.base_url + '/pub/v1',
             auth:     {
               type:     :basic,
-              username: options.get_option(:ats_key, is_type: :mandatory),
-              password: options.get_option(:ats_secret, is_type: :mandatory)}
+              username: options.get_option(:ats_key, mandatory: true),
+              password: options.get_option(:ats_secret, mandatory: true)}
           })
         end
 
@@ -90,7 +89,7 @@ module Aspera
             res = ats_api_pub_v1.read("access_keys/#{access_key_id}")
             return {type: :single_object, data: res[:data]}
           when :modify
-            params = options.get_option(:value, is_type: :mandatory)
+            params = value_create_modify(command: command, type: Hash)
             params['id'] = access_key_id
             ats_api_pub_v1.update("access_keys/#{access_key_id}", params)
             return Main.result_status('modified')
@@ -138,7 +137,7 @@ module Aspera
           when :list
             return {type: :object_list, data: @ats_api_pub.all_servers, fields: %w[id cloud region]}
           when :show
-            if options.get_option(:cloud) || options.get_option(:region, is_type: :optional)
+            if options.get_option(:cloud) || options.get_option(:region)
               server_data = server_by_cloud_region
             else
               server_id = instance_identifier
@@ -161,7 +160,7 @@ module Aspera
               generic:      {
                 grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
                 response_type: 'cloud_iam',
-                apikey:        options.get_option(:ibm_api_key, is_type: :mandatory)
+                apikey:        options.get_option(:ibm_api_key, mandatory: true)
               }}})
         end
 
@@ -187,8 +186,7 @@ module Aspera
             Log.log.warn{"more instances remaining: #{instances['remaining']}"} unless instances['remaining'].to_i.eql?(0)
             return {type: :value_list, data: instances['data'], name: 'instance'}
           when :create
-            create_value = options.get_option(:value) || {}
-            created_key = ats_ibm_api.create('api_keys', create_value)[:data]
+            created_key = ats_ibm_api.create('api_keys', value_create_modify(command: command, default: {}, type: Hash))[:data]
             return {type: :single_object, data: created_key}
           when :list # list known api keys in ATS (this require an api_key ...)
             res = ats_ibm_api.read('api_keys', {'offset' => 0, 'max_results' => 1000})
@@ -221,7 +219,7 @@ module Aspera
           when :api_key # manage credential to access ATS API
             return execute_action_api_key
           when :aws_trust_policy
-            res = ats_api_pub_v1.read('aws/trustpolicy', {region: options.get_option(:region, is_type: :mandatory)})[:data]
+            res = ats_api_pub_v1.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})[:data]
             return {type: :single_object, data: res}
           else raise 'ERROR'
           end

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

@@ -23,7 +23,7 @@ module Aspera
 
         def execute_action
           if @api_bss.nil?
-            key = options.get_option(:password, is_type: :mandatory)
+            key = options.get_option(:password, mandatory: true)
             @api_bss = Rest.new(
               base_url: 'https://dashboard.bss.asperasoft.com/platform',
               headers: {cookie: "_dashboard_key=#{key}"})
@@ -35,8 +35,8 @@ module Aspera
             object = 'bssSubscriptions'
             case command
             when :find
-              query = options.get_option(:query, is_type: :mandatory) # AOC_ORGANIZATION_QUERY AOC_USER_EMAIL
-              value = options.get_option(:value, is_type: :mandatory)
+              query = options.get_option(:query, mandatory: true) # AOC_ORGANIZATION_QUERY AOC_USER_EMAIL
+              value = value_create_modify(command: command)
               request = {
                 'variables' => {'filter' => {'key' => query, 'value' => value}},
                 'query'     => "query($filter: BssSubscriptionFilter!) {#{object}(filter: $filter) { #{all_fields('bssSubscriptions')} } }"