morpheus-cli 5.3.4 → 5.4.3

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

@@ -57,9 +57,9 @@ module Morpheus::Cli::ProvisioningHelper
     @api_client.accounts
   end
 
-  def get_available_groups(refresh=false)
+  def get_available_groups(params = {}, refresh=false)
     if !@available_groups || refresh
-      option_results = options_interface.options_for_source('groups',{})
+      option_results = options_interface.options_for_source('groups', params)
       @available_groups = option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"]}
       }
@@ -68,9 +68,9 @@ module Morpheus::Cli::ProvisioningHelper
     return @available_groups
   end
 
-  def get_available_clouds(group_id, refresh=false)
+  def get_available_clouds(group_id, params = {}, refresh=false)
     if !group_id
-      option_results = options_interface.options_for_source('clouds', {'default' => 'false'})
+      option_results = options_interface.options_for_source('clouds', params.merge({'default' => 'false'}))
       return option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"], "zoneTypeId" => it["zoneTypeId"]}
       }
@@ -80,7 +80,7 @@ module Morpheus::Cli::ProvisioningHelper
       return []
     end
     if !group["clouds"] || refresh
-      option_results = options_interface.options_for_source('clouds', {groupId: group_id})
+      option_results = options_interface.options_for_source('clouds', params.merge({groupId: group_id}))
       group["clouds"] = option_results['data'].collect {|it|
         {"id" => it["value"], "name" => it["name"], "value" => it["value"], "zoneTypeId" => it["zoneTypeId"]}
       }
@@ -484,7 +484,7 @@ module Morpheus::Cli::ProvisioningHelper
     if options[:instance_type_code]
       instance_type_code = options[:instance_type_code]
     else
-      instance_type_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'type' => 'select', 'fieldLabel' => 'Type', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Select Instance Type.'}],options[:options],api_client,{groupId: group_id}, no_prompt, true)
+      instance_type_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'type' => 'select', 'fieldLabel' => 'Type', 'optionSource' => 'instanceTypes', 'required' => true, 'description' => 'Select Instance Type.'}],options[:options],api_client,{groupId: group_id, cloudId: cloud_id, restrictProvisionType:true}, no_prompt, true)
       instance_type_code = instance_type_prompt['type']
     end
     if instance_type_code.to_s =~ /\A\d{1,}\Z/
@@ -870,6 +870,12 @@ module Morpheus::Cli::ProvisioningHelper
       end
     end
 
+    # plan customizations
+    plan_opts = prompt_service_plan_options(service_plan, options, api_client, {zoneId: cloud_id, layoutId: layout['id'], siteId: group_id})
+    if plan_opts && !plan_opts.empty?
+      payload['servicePlanOptions'] = plan_opts
+    end
+
     # prompt networks
     if locked_fields.include?('networks')
       # payload['networkInterfaces'] = options[:options]['networkInterfaces'] if options[:options]['networkInterfaces']
@@ -942,6 +948,7 @@ module Morpheus::Cli::ProvisioningHelper
     # prompt for option types
     api_params['config'] = payload['config'] if payload['config']
     api_params['poolId'] = payload['config']['resourcePoolId'] if payload['config'] && payload['config']['resourcePoolId']
+    api_params['resourcePoolId'] = api_params['poolId']
 
     # set option type defaults from config
     if options[:default_config]
@@ -2093,6 +2100,15 @@ module Morpheus::Cli::ProvisioningHelper
     permissions
   end
 
+  def prompt_permissions_v2(options, excludes = [])
+    perms = prompt_permissions(options, excludes)
+    rtn = {}
+
+    rtn['visibility'] = perms['resourcePool']['visibility'] if !perms['resourcePool'].nil?
+    rtn['tenants'] = ((perms['tenantPermissions'] || {})['accounts'] || []).collect {|it| {'id' => it}}
+    rtn
+  end
+
   def print_permissions(permissions, excludes = [])
     if permissions.nil?
       print_h2 "Permissions"
@@ -2230,6 +2246,80 @@ module Morpheus::Cli::ProvisioningHelper
     return ports
   end
 
+  def prompt_service_plan_options(plan_info, options={}, api_client=nil, api_params={}, instance=nil)
+    plan_opts = {}
+    # provisioning with blueprint can lock fields
+    locked_fields = options[:locked_fields] || []
+    if options[:options]['servicePlanOptions']
+      plan_opts = options[:options]['servicePlanOptions']
+    end
+    default_max_cores = plan_info['maxCores'].to_i != 0 ? plan_info['maxCores'] : 1
+    default_cores_per_socket = plan_info['coresPerSocket'].to_i != 0 ? plan_info['coresPerSocket'] : 1
+    default_max_memory = plan_info['maxMemory'].to_i != 0 ? plan_info['maxMemory'] : nil
+    # use defaults from the instance/server
+    if instance
+      default_max_cores = instance["maxCores"] if instance["maxCores"]
+      default_cores_per_socket = instance["coresPerSocket"] if instance["coresPerSocket"]
+      default_max_memory = instance["maxMemory"] if instance["maxMemory"]
+    end
+    # Core Count
+    if plan_info["customCores"]
+      if locked_fields.include?('servicePlanOptions.maxCores')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxCores']
+          plan_opts['maxCores'] = options[:options]['servicePlanOptions']['maxCores'].to_i
+        end
+      else
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => 'servicePlanOptions', 'fieldName' => 'maxCores', 'type' => 'number', 'fieldLabel' => "Core Count", 'required' => true, 'defaultValue' => default_max_cores, 'description' => "Customize service plan options Core Count"}], options[:options])
+        if v_prompt['servicePlanOptions'] && v_prompt['servicePlanOptions']['maxCores']
+          plan_opts['maxCores'] = v_prompt['servicePlanOptions']['maxCores'].to_i
+        end
+      end
+    end
+    # Cores Per Socket
+    if plan_info["customCoresPerSocket"]
+      if locked_fields.include?('servicePlanOptions.coresPerSocket')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['coresPerSocket']
+          plan_opts['coresPerSocket'] = options[:options]['servicePlanOptions']['coresPerSocket'].to_i
+        end
+      else
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => 'servicePlanOptions', 'fieldName' => 'coresPerSocket', 'type' => 'number', 'fieldLabel' => "Cores Per Socket", 'required' => true, 'defaultValue' => default_cores_per_socket, 'description' => "Customize service plan options Cores Per Socket"}], options[:options])
+        if v_prompt['servicePlanOptions'] && v_prompt['servicePlanOptions']['coresPerSocket']
+          plan_opts['coresPerSocket'] = v_prompt['servicePlanOptions']['coresPerSocket'].to_i
+        end
+      end
+    end
+    # Memory
+    if plan_info["customMaxMemory"]
+      if locked_fields.include?('servicePlanOptions.maxMemory')
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxMemory']
+          plan_opts['maxMemory'] = options[:options]['servicePlanOptions']['maxMemory'].to_i
+        end
+      else
+        if options[:options]['servicePlanOptions'] && options[:options]['servicePlanOptions']['maxMemory']
+          plan_opts['maxMemory'] = options[:options]['servicePlanOptions']['maxMemory'].to_i
+        else
+          # prompt for "memoryMB" field as MB or "memoryGB" in GB
+          # always convert maxMemory to bytes
+          if plan_info["memorySizeType"] == "MB" || options[:options]["memoryMB"]
+            v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memoryMB', 'type' => 'text', 'fieldLabel' => "Memory (MB)", 'required' => true, 'defaultValue' => default_max_memory / (1024 * 1024), 'description' => "Customize service plan options Memory (MB). Value is in megabytes."}], options[:options])
+            if v_prompt['memoryMB'].to_s != ""
+              plan_opts['maxMemory'] = v_prompt['memoryMB'].to_i * 1024 * 1024
+            end
+          else
+            v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'memoryGB', 'type' => 'text', 'fieldLabel' => "Memory (GB)", 'required' => true, 'defaultValue' => default_max_memory / (1024 * 1024 * 1024), 'description' => "Customize service plan options Memory (GB). Value is in gigabytes."}], options[:options])
+            if v_prompt['memoryGB'].to_s != ""
+              plan_opts['maxMemory'] = v_prompt['memoryGB'].to_i * 1024 * 1024 * 1024
+            end
+          end
+          # remove transient memory field just used for prompting for MB or GB
+          plan_opts.delete("memoryMB")
+          plan_opts.delete("memoryGB")
+        end
+      end
+    end
+    return plan_opts
+  end
+
   def format_instance_status(instance, return_color=cyan)
     out = ""
     status_string = instance['status'].to_s

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

@@ -39,7 +39,7 @@ module Morpheus::Cli::RestCommand
 
   module ClassMethods
 
-    # rest_name is the plural name of the rest command resource eg. NeatThingsCommand would be "neat_things"
+    # rest_name is the plural name of the resource eg. NeatThings would be "neat_things"
     # It is used to derive all other default rest settings key, label, etc.  
     # The default name the command name with underscores `_` instead of dashes `-`.
     def rest_name
@@ -86,6 +86,22 @@ module Morpheus::Cli::RestCommand
 
     alias :set_rest_arg :rest_arg=
 
+    # rest_has_name indicates a resource has a name and can be retrieved by name or id
+    # true by default, set to false for lookups by only id
+    def rest_has_name
+      @rest_has_name != nil ? @rest_has_name :  default_rest_has_name
+    end
+
+    def default_rest_has_name
+      true
+    end
+
+    def rest_has_name=(v)
+      @rest_has_name = !!v
+    end
+
+    alias :set_rest_has_name :rest_has_name=
+
     # rest_label is the capitalized resource label eg. "Neat Thing"    
     def rest_label
       @rest_label || default_rest_label
@@ -297,6 +313,10 @@ module Morpheus::Cli::RestCommand
     self.class.rest_arg
   end
 
+  def rest_has_name
+    self.class.rest_has_name
+  end
+
   def rest_label
     self.class.rest_label
   end
@@ -316,23 +336,37 @@ module Morpheus::Cli::RestCommand
   end
 
   def rest_object_key
-    self.send("#{rest_key}_object_key")
+    send("#{rest_key}_object_key")
   end
 
   def rest_list_key
-    self.send("#{rest_key}_list_key")
+    send("#{rest_key}_list_key")
   end
 
-  def rest_column_definitions
-    self.send("#{rest_key}_column_definitions")
+  def rest_column_definitions(options)
+    send("#{rest_key}_column_definitions", options)
   end
 
-  def rest_list_column_definitions
-    self.send("#{rest_key}_list_column_definitions")
+  def rest_list_column_definitions(options)
+    send("#{rest_key}_list_column_definitions", options)
   end
 
-  def rest_find_by_name_or_id(name)
-    return self.send("find_#{rest_key}_by_name_or_id", name)
+  def rest_find_by_name_or_id(val)
+    # use explicitly defined finders
+    # else default to new generic CliCommand method to find anything by type (singular underscore)
+    if rest_has_name
+      if respond_to?("find_#{rest_key}_by_name_or_id", true)
+        send("find_#{rest_key}_by_name_or_id", val)
+      else
+        find_by_name_or_id(rest_key, val)
+      end
+    else
+      if respond_to?("find_#{rest_key}_by_id", true)
+        send("find_#{rest_key}_by_id", val)
+      else
+        find_by_id(rest_key, val)
+      end
+    end
   end
 
   def rest_has_type
@@ -353,6 +387,10 @@ module Morpheus::Cli::RestCommand
     self.class.rest_type_arg
   end
 
+  def rest_has_name
+    self.class.rest_type_arg
+  end
+
   def rest_type_label
     self.class.rest_type_label
   end
@@ -370,23 +408,29 @@ module Morpheus::Cli::RestCommand
   end
 
   def rest_type_object_key
-    self.send("#{rest_type_key}_object_key")
+    send("#{rest_type_key}_object_key")
   end
 
   def rest_type_list_key
-    self.send("#{rest_type_key}_list_key")
+    send("#{rest_type_key}_list_key")
   end
 
-  def rest_type_column_definitions
-    self.send("#{rest_type_key}_column_definitions")
+  def rest_type_column_definitions(options)
+    send("#{rest_type_key}_column_definitions", options)
   end
 
-  def rest_type_list_column_definitions
-    self.send("#{rest_type_key}_list_column_definitions")
+  def rest_type_list_column_definitions(options)
+    send("#{rest_type_key}_list_column_definitions", options)
   end
 
-  def rest_type_find_by_name_or_id(name)
-    return self.send("find_#{rest_type_key}_by_name_or_id", name)
+  def rest_type_find_by_name_or_id(val)
+    # use explicately defined finders
+    # else default to new generic CliCommand method to find anything by type (singular underscore)
+    if respond_to?("find_#{rest_type_key}_by_name_or_id", true)
+      send("find_#{rest_type_key}_by_name_or_id", val)
+    else
+      find_by_name_or_id(rest_type_key, val)
+    end
   end
 
   def registered_interfaces
@@ -417,18 +461,15 @@ module Morpheus::Cli::RestCommand
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[search]")
-      build_standard_list_options(opts, options)
-            opts.footer = <<-EOT
+      build_list_options(opts, options, params)
+      opts.footer = <<-EOT
 List #{rest_label_plural.downcase}.
 [search] is optional. This is a search phrase to filter the results.
 EOT
     end
     optparse.parse!(args)
     connect(options)
-    if args.count > 0
-      options[:phrase] = args.join(" ")
-    end
-    params.merge!(parse_list_options(options))
+    parse_list_options!(args, options, params)
     rest_interface.setopts(options)
     if options[:dry_run]
       print_dry_run rest_interface.dry.list(params)
@@ -441,7 +482,7 @@ EOT
       if records.nil? || records.empty?
         print cyan,"No #{rest_label_plural.downcase} found.",reset,"\n"
       else
-        print as_pretty_table(records, rest_list_column_definitions.upcase_keys!, options)
+        print as_pretty_table(records, rest_list_column_definitions(options).upcase_keys!, options)
         print_results_pagination(json_response) if json_response['meta']
       end
       print reset,"\n"
@@ -454,27 +495,25 @@ EOT
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[#{rest_arg}]")
-      build_standard_get_options(opts, options)
+      build_get_options(opts, options, params)
       opts.footer = <<-EOT
 Get details about #{a_or_an(rest_label)} #{rest_label.downcase}.
-[#{rest_arg}] is required. This is the name or id of #{a_or_an(rest_label)} #{rest_label.downcase}.
+[#{rest_arg}] is required. This is the #{rest_has_name ? 'name or id' : 'id'} of #{a_or_an(rest_label)} #{rest_label.downcase}.
 EOT
     end
     optparse.parse!(args)
     verify_args!(args:args, optparse:optparse, min:1)
     connect(options)
-    params.merge!(parse_query_options(options))
-    id_list = parse_id_list(args)
-    return run_command_for_each_arg(id_list) do |arg|
-      _get(arg, params, options)
-    end
+    parse_get_options!(args, options, params)
+    id = args.join(" ")
+    _get(id, params, options)
   end
 
   def _get(id, params, options)
-    if id !~ /\A\d{1,}\Z/
+    if id !~ /\A\d{1,}\Z/ && rest_has_name
       record = rest_find_by_name_or_id(id)
       if record.nil?
-        raise_command_error "#{rest_label} not found for name '#{id}'"
+        return 1, "#{rest_label} not found for '#{id}'"
       end
       id = record['id']
     end
@@ -493,8 +532,14 @@ EOT
       record = json_response[rest_object_key]
       print_h1 rest_label, [], options
       print cyan
-      print_description_list(rest_column_definitions, record, options)
-      # show config settings...
+      print_description_list(rest_column_definitions(options), record, options)
+      # # could always show config eh? or maybe only with --config if that is nicer.
+      # # config = record['config'].is_a?(Hash) && !record['config'].empty?
+      # if config && !config.empty?
+      #   print_h2 "Configuration"
+      #   print_description_list(config.keys, config)
+      # end
+      # Option Types
       if record['optionTypes'] && record['optionTypes'].size > 0
         print_h2 "Option Types", options
         print format_option_types_table(record['optionTypes'], options, rest_object_key)
@@ -504,45 +549,52 @@ EOT
   end
 
   def add(args)
+    record_type = nil
     record_type_id = nil
     options = {}
+    option_types = respond_to?("add_#{rest_key}_option_types", true) ? send("add_#{rest_key}_option_types") : []
+    advanced_option_types = respond_to?("add_#{rest_key}_advanced_option_types", true) ? send("add_#{rest_key}_advanced_option_types") : []
+    type_option_type = option_types.find {|it| it['fieldName'] == 'type'} 
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      if rest_has_type
-        opts.banner = subcommand_usage("[#{rest_arg}] -t TYPE")
+      opts.banner = subcommand_usage("[#{rest_arg}]")
+      if rest_has_type && type_option_type.nil?
         opts.on( '-t', "--#{rest_type_arg} TYPE", "#{rest_type_label}" ) do |val|
           record_type_id = val
         end
-      else
-        opts.banner = subcommand_usage("[#{rest_arg}]")
       end
-      # if defined?(add_#{rest_key}_option_types)
-      #   build_option_type_options(opts, options, add_#{rest_key}_option_types)
-      # end
+      build_option_type_options(opts, options, option_types)
+      build_option_type_options(opts, options, advanced_option_types)
       build_standard_add_options(opts, options)
       opts.footer = <<-EOT
 Create a new #{rest_label.downcase}.
 [#{rest_arg}] is required. This is the name of the new #{rest_label.downcase}.
 EOT
+      opts.footer += send "add_#{rest_key}_footer_addn" if respond_to?("add_#{rest_key}_footer_addn", true)
     end
     optparse.parse!(args)
     # todo: make supporting args[0] optional and more flexible
     # for now args[0] is assumed to be the 'name'
     record_name = nil
-    if args[0] # && rest_has_name
-      record_name = args[0]
-    end
-    verify_args!(args:args, optparse:optparse, min:0, max: 1)
-    # todo: maybe need a flag to make this required, it could be an option type too, so
-    if rest_has_type
-      if record_type_id.nil?
-        raise_command_error "#{rest_type_label} is required.\n#{optparse}"
+    if rest_has_name
+      if args.count > 0
+        record_name = args.join(" ")
       end
+      verify_args!(args:args, optparse:optparse, min:0, max: 1)
+    else
+      verify_args!(args:args, optparse:optparse, count: 0)
     end
     connect(options)
-    if rest_has_type
+    # load or prompt for type
+    if rest_has_type && type_option_type.nil?
+      if record_type_id.nil?
+        #raise_command_error "#{rest_type_label} is required.\n#{optparse}"
+        type_list = rest_type_interface.list({max:10000, creatable:true})[rest_type_list_key]
+        type_dropdown_options = respond_to?("#{rest_key}_type_list_to_options", true) ? send("#{rest_key}_type_list_to_options", type_list) : type_list.collect {|it| {'name' => it['name'], 'value' => it['code']} }
+        record_type_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => rest_type_label, 'type' => 'select', 'selectOptions' => type_dropdown_options, 'required' => true}], options[:options], @api_client)['type']
+      end
       record_type = rest_type_find_by_name_or_id(record_type_id)
       if record_type.nil?
-        raise_command_error "#{rest_type_label} not found for '#{record_type_id}'.\n#{optparse}"
+        return 1, "#{rest_type_label} not found for '#{record_type_id}"
       end
     end
     passed_options = parse_passed_options(options)
@@ -557,13 +609,40 @@ EOT
         options[:options]['name'] = record_name # injected for prompt
       end
       if rest_has_type && record_type
-        # record_payload['type'] = {'code' => record_type['code']}
+        # inject type to options for prompting
         record_payload['type'] = record_type['code']
-        options[:options]['type'] = record_type['code'] # injected for prompt
+        options[:options]['type'] = record_type['code']
+        # initialize params for loading optionSource data
+        options[:params] ||= {}
+        options[:params]['type'] = record_type['code']
       end
       record_payload.deep_merge!(passed_options)
+      if option_types && !option_types.empty?
+        v_prompt = Morpheus::Cli::OptionTypes.prompt(option_types, options[:options], @api_client, options[:params])
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
       # options by type
-      my_option_types = record_type ? record_type['optionTypes'] : nil
+      if rest_has_type && record_type.nil?
+        type_value = record_payload['type'].is_a?(Hash) ? record_payload['type']['id'] : record_payload['type']
+        if type_value
+          record_type = rest_type_find_by_name_or_id(type_value)
+          if record_type.nil?
+            return 1, "#{rest_type_label} not found for '#{type_value}"
+          end
+        end
+        # reload the type by id to get all the details ie. optionTypes
+        if record_type && record_type['optionTypes'].nil?
+          record_type = rest_type_find_by_name_or_id(record_type['id'])
+        end
+      end
+      my_option_types = nil
+      if respond_to?("load_option_types_for_#{rest_key}", true)
+        my_option_types = send("load_option_types_for_#{rest_key}", record_type, nil)
+      else
+        my_option_types = record_type ? record_type['optionTypes'] : nil
+      end
       if my_option_types && !my_option_types.empty?
         # remove redundant fieldContext
         my_option_types.each do |option_type| 
@@ -571,7 +650,15 @@ EOT
             option_type['fieldContext'] = nil
           end
         end
-        v_prompt = Morpheus::Cli::OptionTypes.prompt(my_option_types, options[:options], @api_client, options[:params])
+        api_params = (options[:params] || {}).merge(record_payload)
+        v_prompt = Morpheus::Cli::OptionTypes.prompt(my_option_types, options[:options], @api_client, api_params)
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
+      # advanced options (uses no_prompt)
+      if advanced_option_types && !advanced_option_types.empty?
+        v_prompt = Morpheus::Cli::OptionTypes.no_prompt(advanced_option_types, options[:options], @api_client, options[:params])
         v_prompt.deep_compact!
         v_prompt.booleanize! # 'on' => true
         record_payload.deep_merge!(v_prompt)
@@ -594,28 +681,101 @@ EOT
 
   def update(args)
     id = args[0]
+    record_type = nil
+    record_type_id = nil
     options = {}
-    params = {}
-    account_name = nil
+    option_types = respond_to?("update_#{rest_key}_option_types", true) ? send("update_#{rest_key}_option_types") : []
+    advanced_option_types = respond_to?("update_#{rest_key}_advanced_option_types", true) ? send("update_#{rest_key}_advanced_option_types") : []
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[#{rest_arg}] [options]")
+      build_option_type_options(opts, options, option_types)
+      build_option_type_options(opts, options, advanced_option_types)
       build_standard_update_options(opts, options)
       opts.footer = <<-EOT
 Update an existing #{rest_label.downcase}.
-[#{rest_arg}] is required. This is the name or id of #{a_or_an(rest_label)} #{rest_label.downcase}.
+[#{rest_arg}] is required. This is the #{rest_has_name ? 'name or id' : 'id'} of #{a_or_an(rest_label)} #{rest_label.downcase}.
 EOT
+      opts.footer += send "update_#{rest_key}_footer_addn" if respond_to?("update_#{rest_key}_footer_addn", true)
     end
     optparse.parse!(args)
     verify_args!(args:args, optparse:optparse, count:1)
     connect(options)
     record = rest_find_by_name_or_id(id)
+    if record.nil?
+      return 1, "#{rest_name} not found for '#{id}'"
+    end
+    # load type so we can prompt for those option types
+    if rest_has_type
+      record_type_id = record['type']['id']
+      record_type = rest_type_find_by_name_or_id(record_type_id)
+      if record_type.nil?
+        return 1, "#{rest_type_label} not found for '#{record_type_id}"
+      end
+      # reload the type by id to get all the details ie. optionTypes
+      if record_type['optionTypes'].nil?
+        record_type = rest_type_find_by_name_or_id(record_type['id'])
+      end
+    end
     passed_options = parse_passed_options(options)
-    payload = nil
+    payload = {}
     if options[:payload]
       payload = options[:payload]
       payload.deep_merge!({rest_object_key => passed_options}) unless passed_options.empty?
     else
       record_payload = passed_options
+      if rest_has_type && record_type
+        # inject type to options for prompting
+        # record_payload['type'] = record_type['code']
+        # options[:options]['type'] = record_type['code']
+        # initialize params for loading optionSource data
+        options[:params] ||= {}
+        options[:params]['type'] = record_type['code']
+      end
+      # update options without prompting by default
+      if option_types && !option_types.empty?
+        api_params = (options[:params] || {}).merge(record_payload) # need to merge in values from record too, ughhh
+        v_prompt = Morpheus::Cli::OptionTypes.no_prompt(option_types, options[:options], @api_client, api_params)
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
+      # options by type
+      my_option_types = nil
+      if respond_to?("load_option_types_for_#{rest_key}", true)
+        my_option_types = send("load_option_types_for_#{rest_key}", record_type, nil)
+      else
+        my_option_types = record_type ? record_type['optionTypes'] : nil
+      end
+      if my_option_types && !my_option_types.empty?
+        # remove redundant fieldContext
+        # make them optional for updates
+        # todo: use current value as default instead of just making things optioanl
+        # maybe new prompt() options like {:mode => :edit, :object => storage_server} or something
+        my_option_types.each do |option_type| 
+          if option_type['fieldContext'] == rest_object_key
+            option_type['fieldContext'] = nil
+          end
+          option_type.delete('required')
+          option_type.delete('defaultValue')
+        end
+        api_params = (options[:params] || {}).merge(record_payload) # need to merge in values from record too, ughhh
+        v_prompt = Morpheus::Cli::OptionTypes.no_prompt(my_option_types, options[:options], @api_client, api_params)
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
+      # advanced options
+      if advanced_option_types && !advanced_option_types.empty?
+        v_prompt = Morpheus::Cli::OptionTypes.no_prompt(advanced_option_types, options[:options], @api_client, options[:params])
+        v_prompt.deep_compact!
+        v_prompt.booleanize! # 'on' => true
+        record_payload.deep_merge!(v_prompt)
+      end
+      # remove empty config, compact could hanlde this
+      if record_payload['config'] && record_payload['config'].empty?
+        record_payload.delete('config')
+      end
+      # prevent updating with empty payload
       if record_payload.empty?
         raise_command_error "Specify at least one option to update.\n#{optparse}"
       end
@@ -643,7 +803,7 @@ EOT
       build_standard_remove_options(opts, options)
       opts.footer = <<-EOT
 Delete an existing #{rest_label.downcase}.
-[#{rest_arg}] is required. This is the name or id of #{a_or_an(rest_label)} #{rest_label.downcase}.
+[#{rest_arg}] is required. This is the #{rest_has_name ? 'name or id' : 'id'} of #{a_or_an(rest_label)} #{rest_label.downcase}.
 EOT
     end
     optparse.parse!(args)
@@ -659,7 +819,7 @@ EOT
     end
     rest_interface.setopts(options)
     if options[:dry_run]
-      print_dry_run rest_interface.dry.destroy(record['id'])
+      print_dry_run rest_interface.dry.destroy(record['id'], params)
       return 0, nil
     end
     json_response = rest_interface.destroy(record['id'], params)