morpheus-cli 6.3.0 → 6.3.2

data/lib/morpheus/cli/commands/network_servers_command.rb

@@ -23,8 +23,8 @@ class Morpheus::Cli::NetworkServersCommand
   end
 
   def add(args)
-    options = {}
-    params = {}
+    options = {params: {}}
+    params = options[:params]
     ip_range_list = nil
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[name]")
@@ -55,18 +55,20 @@ EOT
     end
 
     # merge -O options into normally parsed options
-    params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
+    #params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) }) if options[:options]
 
     # construct payload
     payload = nil
     if options[:payload]
       payload = options[:payload]
+      payload.deep_merge!({rest_object_key => parse_passed_options(options)})
+      payload.deep_merge!({rest_object_key => params})
     else
-      # prompt for network server options
-      
+      payload = {}
+      payload.deep_merge!({rest_object_key => parse_passed_options(options)})
       # Name
       if !params['name']
-        params['name'] = prompt_value({'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name for this network server.'}, params, options[:no_prompt])
+        params['name'] = prompt_value({'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name for this network server.'}, options)
         # params['name'] = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true, 'description' => 'Name for this network server.'}], params, @api_client, {}, options[:no_prompt])['name']
       end
 
@@ -93,7 +95,7 @@ EOT
         end
         network_type_code = selected_type['code']
       else
-        network_type_code = prompt_value({'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'selectOptions' => network_server_type_options, 'required' => true, 'description' => 'Choose a network server type.'}, params, options[:no_prompt])
+        network_type_code = prompt_value({'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'selectOptions' => network_server_type_options, 'required' => true, 'description' => 'Choose a network server type.'}, options.merge(params))
         #network_type_code = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => 'Network Server Type', 'type' => 'select', 'selectOptions' => network_server_type_options, 'required' => true, 'description' => 'Choose a network server type.'}], options, @api_client, {}, options[:no_prompt])['type']
         selected_type = network_server_type_options.find {|it| it['code'] == network_type_code }
         if selected_type.nil?
@@ -106,9 +108,9 @@ EOT
       # prompt options by type
       network_server_type = @network_server_types_interface.get(network_type_id.to_i)['networkServerType']
       # params['type'] = network_server_type['code']
-      option_result = Morpheus::Cli::OptionTypes.prompt(network_server_type['optionTypes'], params.merge({:context_map => {'networkServer' => ''}}), @api_client, {}, options[:no_prompt], true)
+      option_result = prompt(network_server_type['optionTypes'], options.merge({:context_map => {'networkServer' => ''}}))
       params.deep_merge!(option_result)
-      payload = {'networkServer' => params}
+      payload.deep_merge!({rest_object_key => params})
     end
     @network_servers_interface.setopts(options)
     if options[:dry_run]
@@ -218,6 +220,14 @@ EOT
 
   private
 
+  def network_server_list_key
+    'networkServers'
+  end
+
+  def network_server_object_key
+    'networkServer'
+  end
+
   # def render_response_for_get(json_response, options)
   #   # load the type and show fields dynamically based on optionTypes
   #   render_response(json_response, options, rest_object_key) do

data/lib/morpheus/cli/commands/self_service_command.rb

@@ -0,0 +1,17 @@
+require 'morpheus/cli/cli_command'
+require 'morpheus/cli/commands/catalog_item_types_command'
+
+class Morpheus::Cli::SelfServiceCommand
+  include Morpheus::Cli::CliCommand
+
+  set_command_name :'self-service'
+  set_command_description "Deprecated and replaced by catalog-item-types"
+
+  set_command_hidden
+  
+  def handle(args)
+  	print_error yellow,"[DEPRECATED] The command `self-service` is deprecated and replaced by `catalog-item-types`.",reset,"\n"
+  	Morpheus::Cli::CatalogItemTypesCommand.new.handle(args)
+  end
+
+end

data/lib/morpheus/cli/commands/service_catalog_command.rb

@@ -308,7 +308,7 @@ EOT
     catalog_item_type = json_response[catalog_item_type_object_key]
     # need to load by id to get optionTypes
     # maybe do ?name=foo&includeOptionTypes=true 
-    if catalog_item_type['optionTypes'].nil?
+    if catalog_item_type['optionTypes'].nil? && catalog_item_type['form'].nil?
       catalog_item_type = find_catalog_item_type_by_id(catalog_item_type['id'])
       return [1, "catalog item type not found"] if catalog_item_type.nil?
     end
@@ -318,14 +318,25 @@ EOT
       show_columns = catalog_item_type_column_definitions
       print_description_list(show_columns, catalog_item_type)
 
+      form = catalog_item_type['form']
+      if form
+        # print_h2 "Configuration Options (Form: #{form['name']})"
+        print_h2 "Configuration Options"
+        form_inputs = (form['options'] || [])
+        if form['fieldGroups']
+          form['fieldGroups'].each { |field_group| form_inputs += (field_group['options'] || []) }
+        end
+        #print format_simple_option_types_table(form_inputs, options)
+        print format_option_types_table(form_inputs, options, 'config.customOptions')
+        # print reset,"\n"
+      else
+        # print cyan,"No form inputs found for this catalog item.","\n",reset
+      end
+
       if catalog_item_type['optionTypes'] && catalog_item_type['optionTypes'].size > 0
         print_h2 "Configuration Options"
-        print as_pretty_table(catalog_item_type['optionTypes'], {
-          "LABEL" => lambda {|it| it['fieldLabel'] },
-          "NAME" => lambda {|it| it['fieldName'] },
-          "TYPE" => lambda {|it| it['type'] },
-          "REQUIRED" => lambda {|it| format_boolean it['required'] },
-        })
+        #print format_simple_option_types_table(catalog_item_type['optionTypes'], options)
+        print format_option_types_table(catalog_item_type['optionTypes'], options, 'config.customOptions')
       else
         # print cyan,"No option types found for this catalog item.","\n",reset
       end
@@ -645,21 +656,38 @@ EOT
 
       # this is silly, need to load by id to get optionTypes
       # maybe do ?name=foo&includeOptionTypes=true 
-      if catalog_item_type['optionTypes'].nil?
+      if catalog_item_type['optionTypes'].nil? && catalog_item_type['form'].nil?
         catalog_item_type = find_catalog_item_type_by_id(catalog_item_type['id'])
         return [1, "catalog item type not found"] if catalog_item_type.nil?
       end
-      catalog_option_types = catalog_item_type['optionTypes']
-      # instead of config.customOptions just use config...
-      catalog_option_types = catalog_option_types.collect {|it|
-        it['fieldContext'] = 'config'
-        it
-      }
-      if catalog_option_types && !catalog_option_types.empty?
-        api_params = construct_catalog_api_params(catalog_item_type)
-        config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
+      
+      if catalog_item_type['formType'] == 'form'
+        # prompt for form options
+        if catalog_item_type['form'].nil?
+          raise_command_error "No form found for catalog item type '#{catalog_item_type['name']}'"
+        end
+        # use the new PromptHelper method prompt_form()
+        config_prompt = prompt_form(catalog_item_type['form'], options.merge({:context_map => {'config.customOptions' => 'config'}, :api_params => construct_catalog_api_params(catalog_item_type)}))['config']
         payload[add_item_object_key].deep_merge!({'config' => config_prompt})
+      else
+        # prompt for optionTypes
+        catalog_option_types = catalog_item_type['optionTypes']
+        if catalog_option_types.nil?
+          #raise_command_error "No options found for catalog item type '#{catalog_item_type['name']}'"
+          catalog_option_types = []
+        end
+        # instead of config.customOptions just use config...
+        catalog_option_types = catalog_option_types.collect {|it|
+          it['fieldContext'] = 'config'
+          it
+        }
+        if catalog_option_types && !catalog_option_types.empty?
+          api_params = construct_catalog_api_params(catalog_item_type)
+          config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
+          payload[add_item_object_key].deep_merge!({'config' => config_prompt})
+        end
       end
+
       if workflow_context
         payload[add_item_object_key]['context'] = workflow_context
       else
@@ -673,7 +701,7 @@ EOT
         elsif !catalog_item_type['context'].nil?
           workflow_context = catalog_item_type['context']
         end
-        payload[add_item_object_key]['context'] = workflow_context
+        payload[add_item_object_key]['context'] = workflow_context  if workflow_context
       end
 
       if workflow_target
@@ -981,23 +1009,35 @@ EOT
 
         # this is silly, need to load by id to get optionTypes
         # maybe do ?name=foo&includeOptionTypes=true 
-        if catalog_item_type['optionTypes'].nil?
+        if catalog_item_type['optionTypes'].nil? && catalog_item_type['form'].nil?
           catalog_item_type = find_catalog_item_type_by_id(catalog_item_type['id'])
           return [1, "catalog item type not found"] if catalog_item_type.nil?
         end
-        catalog_option_types = catalog_item_type['optionTypes']
-        # instead of config.customOptions just use config...
-        catalog_option_types = catalog_option_types.collect {|it|
-          it['fieldContext'] = nil
-          it['fieldContext'] = 'config'
-          it
-        }
-        if catalog_option_types && !catalog_option_types.empty?
-          api_params = construct_catalog_api_params(catalog_item_type)
-          config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
+        
+        if catalog_item_type['formType'] == 'form'
+          # prompt for form options
+          if catalog_item_type['form'].nil?
+            raise_command_error "No form found for catalog item type '#{catalog_item_type['name']}'"
+          end
+          # use the new PromptHelper method prompt_form()
+          config_prompt = prompt_form(catalog_item_type['form'], options.merge({:context_map => {'config.customOptions' => 'config'}, :api_params => construct_catalog_api_params(catalog_item_type)}))['config']
           item_payload.deep_merge!({'config' => config_prompt})
+        else
+          # prompt for optionTypes
+          catalog_option_types = catalog_item_type['optionTypes']
+          # instead of config.customOptions just use config...
+          catalog_option_types = catalog_option_types.collect {|it|
+            it['fieldContext'] = nil
+            it['fieldContext'] = 'config'
+            it
+          }
+          if catalog_option_types && !catalog_option_types.empty?
+            api_params = construct_catalog_api_params(catalog_item_type)
+            config_prompt = Morpheus::Cli::OptionTypes.prompt(catalog_option_types, options[:options], @api_client, api_params, options[:no_prompt], false, false, true)['config']
+            item_payload.deep_merge!({'config' => config_prompt})
+          end
         end
-        
+
         if workflow_context
           item_payload['context'] = workflow_context
         else
@@ -1465,7 +1505,8 @@ EOT
     # this should be fixed on the api side, so it automatically extracts this input from the config
     begin
       instance_type_code = nil
-      catalog_item_type = find_by_id(:catalog_item_type, catalog_item_type_id.to_i)
+      catalog_item_type = record
+      #catalog_item_type = find_by_id(:catalog_item_type, catalog_item_type_id.to_i)
       if catalog_item_type
         if catalog_item_type['type'] == 'instance'
           if catalog_item_type['config'] && catalog_item_type['config']['type']

data/lib/morpheus/cli/commands/virtual_images.rb

@@ -847,7 +847,7 @@ EOT
       print_description_list(virtual_image_location_column_definitions, location, options)
       if volumes && !volumes.empty?
         print_h2 "Volumes", options
-        volume_rows = location_volumes.collect do |volume|
+        volume_rows = volumes.collect do |volume|
           {name: volume['name'], size: Filesize.from("#{volume['rawSize']} B").pretty}
         end
         print cyan

data/lib/morpheus/cli/error_handler.rb

@@ -216,9 +216,11 @@ class Morpheus::Cli::ErrorHandler
             @stderr.puts response['msg']
           end
           if response['errors']
-            response['errors'].each do |key, value|
-              @stderr.print "* #{key}: #{value}\n"
-            end
+            # response['errors'].each do |key, value|
+            #   @stderr.print "* #{key}: #{value}\n"
+            # end
+            # puts as_yaml(response['errors'])
+            @stderr.print format_rest_errors(response['errors'])
           end
           @stderr.print reset
         else
@@ -231,6 +233,19 @@ class Morpheus::Cli::ErrorHandler
     end
   end
 
+  def format_rest_errors(errors, context=nil)
+    out = ""
+    Hash(errors).each do |key, value|
+      if value.is_a?(Hash)
+        out << format_rest_errors(value, context ? "#{context}.#{key}" : key)
+      else
+        prefix = context ? (context + '.') : ''
+        out << "* #{prefix}#{key}: #{value}\n"
+      end
+    end
+    out
+  end
+
   def print_rest_request(req)
     @stderr.print "REQUEST"
     @stderr.print "\n"

data/lib/morpheus/cli/mixins/print_helper.rb

@@ -1511,6 +1511,8 @@ module Morpheus::Cli::PrintHelper
   end
 
   def format_option_types_table(option_types, options={}, domain_name=nil)
+    show_option_source = option_types.find {|it| !it['optionList'].to_s.empty? || !it['optionSource'].to_s.empty? }
+    show_default = option_types.find {|it| !it['defaultValue'].nil? }
     columns = [
       {"FIELD LABEL" => lambda {|it| it['fieldLabel'] } },
       {"FIELD NAME" => lambda {|it| 
@@ -1521,17 +1523,29 @@ module Morpheus::Cli::PrintHelper
         end
       } },
       {"TYPE" => lambda {|it| it['type'] } },
-      {"OPTION SOURCE" => lambda {|it| 
-        if it['optionSourceType']
+      {"REQUIRED" => lambda {|it| format_boolean it['required'] } },
+      show_option_source ? {"OPTION SOURCE" => lambda {|it| 
+        if it['optionList']
+          it['optionList']['name']
+        elsif it['optionSourceType']
           "#{it['optionSourceType']}/#{it['optionSource']}"
         else
           "#{it['optionSource']}"
         end
-      } },
-      {"DEFAULT" => lambda {|it| it['defaultValue'] } },
-      {"REQUIRED" => lambda {|it| format_boolean it['required'] } },
-    ]
+      } } : nil,
+      show_default ? {"DEFAULT" => lambda {|it| it['defaultValue'] } } : nil,
+    ].compact
     as_pretty_table(option_types, columns, options)
   end
+
+  def format_simple_option_types_table(option_types, options={})
+    as_pretty_table(option_types, {
+      "LABEL" => lambda {|it| it['fieldLabel'] },
+      "NAME" => lambda {|it| it['fieldName'] },
+      "TYPE" => lambda {|it| it['type'] },
+      "REQUIRED" => lambda {|it| format_boolean it['required'] },
+      "DEFAULT" => lambda {|it| it['defaultValue'] },
+    }, options)
+  end
   
 end

data/lib/morpheus/cli/mixins/prompt_helper.rb

@@ -1,15 +1,136 @@
+require 'morpheus/cli/option_types'
+
 # Mixin for Morpheus::Cli command classes
-# Provides common methods for prompting for input
+# Provides common methods for prompting for option type inputs and forms.
+# Prompting is delegated to the {Morpheus::Cli::OptionTypes} module
+# while the provided {#prompt} simplifies the required parameters
+# The command class must establish the +@api_client+ on its own.
+#
 module Morpheus::Cli::PromptHelper
 
-	# prompt for a single option type and and return the input value
-	# @param option_type [Hash] The OptionType input record to prompt for , contians fieldName, fieldLabel, etc.
-  # @param options [Hash] The context being constructed, checks this for the value before prompting the user for input.
-  # @param no_prompt [Boolean] The context being constructed, checks this for the value before prompting the user for input.
-  # @param api_params [Hash] Optional map of parameters to include in API request for select option types
-  # @return input value for the option type, usually a string or number if the value is an ID or of type: number
-	def prompt_value(option_type, options, no_prompt=false, api_params={})
-		# this does not work with fieldContext, so get rid of it
-		return Morpheus::Cli::OptionTypes.prompt([option_type.merge({'fieldContext' => nil})], options, @api_client, api_params, no_prompt)[option_type['fieldName']]
-	end
+  # Prompt for a list of inputs (OptionType) and return a Hash containing
+  # all of the provides values.  The user is prompted to provide a value 
+  # for each input, unless the value is already set in the options.
+  # @param [Array, Hash] option_types the list of OptionType inputs with fieldName, fieldLabel, etc.
+  #   A single option type Hash can be passed instead.
+  # @param [Hash] options the standard command options
+  #   This map is a mixture of keys that are Symbols that provide some common
+  #   functionality like :no_prompt, :context_map, etc.
+  #   Any keys that are Strings get used to lookup input values, along with 
+  #   +options[:options]+ and +options[:params]+.
+  #   The precedence for providing option values is as follows: 
+  #   1. options['foo']  2. options[:params]['foo'] 3. options[:options]['foo'] 4. User is prompted.
+  # @option options [Hash] :options map of values provided by the user via the generic -O OPTIONS switch, gets merged into the context used for providing input values
+  # @option options [Hash] :params map of additional values provided by the user via explicite options, gets merged into the context used for providing input values
+  # @option options [Hash] :no_prompt supresses prompting, use default values and error if a required input is not provided. Default is of course +false+.
+  # @option options [Hash] :context_map Can to change the fieldContext of the option_types, eg. :context_map => {'networkDhcpRelay' => ''}
+  # @option options [APIClient] :api_client The {APIClient} to use for option types that request api calls. Default is the @api_client established by the class
+  # @option options [Hash] :api_params Optional map of parameters to include in API request for select option types
+  # @option options [Boolean] :paging_enabled Enable paging if there are a lot of available options to display. Default is +false+.
+  # @option options [Boolean] :ignore_empty Ignore inputs that have no options, this can be used to allow prompting to continue without error if a select input has no options.
+  # @option options [Boolean] :skip_sort Do not sort the inputs by displayOrder, assume they are already sorted. Default is +true+.
+  # @return [Hash] containing the values provided for each option type, the key is the input fieldName
+  #
+  # @example Prompt for name
+  #
+  #   results = prompt([{'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true}], options)
+  #   puts "Name: #{results['name']}"
+  #
+  def prompt(option_types, options={})
+    # option types can be passed as a single input instead of an array
+    option_types = option_types.is_a?(Hash) ? [option_types] : option_types #Array(option_types)
+    # construct options parameter for Morpheus::Cli::OptionTypes.prompt
+    options = construct_prompt_options(options)
+    # by default the @api_client established by the command is used
+    api_client = options.key?(:api_client) ? options[:api_client] : @api_client
+    api_params = options.key?(:api_params) ? options[:api_params] : {}
+    no_prompt = options.key?(:no_prompt) ? options[:no_prompt] : false
+    paging_enabled = options.key?(:paging_enabled) ? options[:paging_enabled] : true
+    ignore_empty = options.key?(:ignore_empty) ? options[:ignore_empty] : false
+    # Defaulting skip_sort to true which is the opposite of OptionTypes.prompt()
+    # The API handles sorting most of the time now, calling function can sort before prompting if needed
+    # maybe switch this later if needed, removing skip_sort would be nice though...
+    skip_sort = options.key?(:skip_sort) ? options[:skip_sort] : true
+    results = Morpheus::Cli::OptionTypes.prompt(option_types, options, api_client, api_params, no_prompt, paging_enabled, ignore_empty, skip_sort)
+    # trying to get rid of the need to do these compact and booleanize calls..
+    # for now you can use options.merge({compact: true,booleanize: true}) or modify the results yourself
+    results.deep_compact! if options[:compact]
+    results.booleanize! if options[:booleanize] # 'on' => true
+    return results
+  end
+
+  # Process 1-N inputs (OptionType) in a special 'edit mode' that supresses user interaction.
+  # This is used by +update+ commands where we want to process option types
+  # without prompting the user so that the results only contains values that are passed in explicitely as options and default values are not used.
+  # @see {#prompt} method for details on the supported options
+  #
+  def no_prompt(option_types, options={})
+    options = options.merge({:edit_mode => true, :no_prompt => true})
+    options.delete(:no_prompt) if options[:always_prompt] # --prompt to always prompt
+    return prompt(option_types, options)
+  end
+
+  # Prompt for a single input and return only the value
+  # @param [Hash] option_type the OptionType input record to prompt for, contains fieldName, fieldLabel, etc.
+  # @param [Hash] options the standard command options
+  # @see {#prompt} method for details on the supported options
+  # @return [String, Number, Hash, Array, nil] value provided by the options or user input, usually a string or a number or nil if no value is provided.
+  #
+  # @example Prompt for name value
+  #
+  #   chosen_name = prompt_value({'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true}, options)
+  #   puts "Chosen Name: #{chosen_name}"
+  #
+  def prompt_value(option_type, options={})
+    # this does not need with fieldContext, so get rid of it
+    # option_types = [option_type.merge({'fieldContext' => nil})]
+    # results = prompt(Array(option_type), options)
+    # return results[option_type['fieldName']]
+
+    # this works with fieldContext now, hooray
+    # use get_object_value() to traverse object to get the value
+    option_types = [option_type] # Array(option_type)
+    results = prompt(option_types, options)
+    return get_option_type_value(results, option_types.first)
+  end
+
+  # Process inputs of a form, prompting for its options and field groups
+  # @param [Hash] form the OptionTypeForm to process
+  # @param [Hash] options the standard command options
+  # @see {#prompt} method for defailts on the supported options
+  # @return Hash containing the values provided for each option type, the key is the fieldName
+  #
+  def prompt_form(form, options={})
+    form_results = {}
+    results = prompt(Array(form['options']), options.merge(form_results))
+    form_results.deep_merge!(results)
+    # prompt for each field group, merging results into options context as we go
+    Array(form['fieldGroups']).each do |field_group|
+      # todo: look at isCollapsible, defaultCollapsed and visibleOnCode to see if the group should
+      # if collapsed then just use options.merge({:no_prompt => true}) and maybe need to set :required => false ?
+      results = prompt(field_group['options'], options.merge(form_results))
+      form_results.deep_merge!(results)
+    end
+    return form_results
+  end
+
+  protected
+
+  # construct options parameter for Morpheus::Cli::OptionTypes.prompt
+  # This options Hash is a mixture of Symbols that provide some common functionality like :no_prompt, and :context_map, etc.
+  # String keys are used to lookup values being passed into the command in order to prevent prompting the user
+  # The precedence for providing option values is as follows: 
+  #   1. options['foo']  2. options[:params]['foo'] 3. options[:options]['foo']
+  #
+  def construct_prompt_options(options)
+    passed_options = Hash(options[:options]).select {|k,v| k.is_a?(String) }
+    params = Hash(options[:params]).select {|k,v| k.is_a?(String) }
+    return passed_options.deep_merge(params).deep_merge!(options)
+  end
+
+  def get_option_type_value(results, option_type)
+    field_key = [option_type['fieldContext'], option_type['fieldName']].select {|it| it && it != '' }.join('.')
+    get_object_value(results, field_key)
+  end
+
 end