morpheus-cli 6.2.2 → 6.3.0

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

@@ -15,9 +15,22 @@ class Morpheus::Cli::Options
   end
   
   def handle(args)
-    list(args)
+    # todo: probably just make these proper subcommands
+    # handle_subcommand(args)
+    # handle some special cases that do not conform to name, value
+    # This also provides some help on their by documenting the required parameters.
+    source_name = args[0]
+    if source_name == "networkServices"
+      network_services(args[1..-1])
+    elsif source_name == "zoneNetworkOptions"
+      zone_network_options(args[1..-1])
+    else
+      list(args)
+    end
   end
 
+  # This is the default handler for the options command.
+  # It shows the NAME and VALUE for the list of "data" returned.
   def list(args)
     options = {}
     params = {}
@@ -67,6 +80,9 @@ EOT
     begin
       json_response = @options_interface.options_for_source(source_name, params)
     rescue RestClient::Exception => e
+      if Morpheus::Logging.debug? # or options[:debug]
+        raise e
+      end
       if e.response && e.response.code == 404
         raise_command_error("Options source not found by name '#{source_name}'", args, optparse)
       elsif e.response && e.response.code == 500
@@ -88,8 +104,125 @@ EOT
         print cyan,"No options found.",reset,"\n"
       else
         print as_pretty_table(records, [:name, :value], options)
-        print_results_pagination(json_response)
+        print_results_pagination({size: records.size, total: records.size})
+      end
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  # handle some well option sources by name
+
+  def network_services(args)
+    options = {}
+    params = {}
+    source_name = "networkServices"
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = "Usage: morpheus #{command_name} #{source_name} #{args[0]}"
+      # build_standard_list_options(opts, options)
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+View list of options for source '#{source_name}'.
+This is the list of network service types (network server types) that can be added.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count: 0)
+    connect(options)
+    params.merge!(parse_list_options(options))
+    @options_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @options_interface.dry.options_for_source(source_name, params)
+      return
+    end
+    json_response = @options_interface.options_for_source(source_name, params)
+    render_response(json_response, options, "data") do
+      records = json_response["data"].collect {|r| r['services']}.compact.flatten
+      print_h1 "Morpheus Options", ["Source: #{source_name}"] + parse_list_subtitles(options), options, ""
+      if records.nil? || records.empty?
+        print cyan,"No options found.",reset,"\n"
+      else
+        json_response["data"].each do |data_row|
+          if data_row['services'] && !data_row['services'].empty?
+            services = []
+            data_row['services'].each do |service_row|
+              services << {name: service_row['name'], code: service_row['code'] , id: service_row['id'], value: service_row['id']}
+            end
+            # print_h2 "#{data_row['name']} Options", [], options
+            print_h2 "#{data_row['name']}", [], options
+            print as_pretty_table(services, [:id, :name, :code], options)
+          end
+        end
+      end
+      print_results_pagination({size: records.size, total: records.size})
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+  
+#  # this is a really slow one right now, need to look into that.
+#   def networks(args)
+#   end
+
+  def zone_network_options(args)
+    options = {}
+    params = {}
+    source_name = "zoneNetworkOptions"
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = "Usage: morpheus #{command_name} #{source_name} #{args[0]}"
+      # build_standard_list_options(opts, options)
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+View list of options for source '#{source_name}'.
+This is the list of networks available when provisioning to a particular cloud and layout.
+
+Required Parameters:
+    Cloud ID (zoneId)
+    Layout ID (layoutId)
+
+Examples: 
+    options #{source_name} -Q zoneId=40&layoutId=1954
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count: 0)
+    connect(options)
+    params.merge!(parse_list_options(options))
+    @options_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @options_interface.dry.options_for_source(source_name, params)
+      return
+    end
+    # This requires Cloud and Layout -Q zoneId=40&layoutId=1954
+    # todo: prompt
+    json_response = @options_interface.options_for_source(source_name, params)
+    render_response(json_response, options, "data") do
+      # This is different, data is a Hash, not an Array...
+      networks = json_response["data"]["networks"]
+      network_groups = json_response["data"]["networkGroups"]
+      network_subnets = json_response["data"]["networkSubnets"]
+      records = [networks, network_groups, network_subnets].compact.flatten
+      print_h1 "Morpheus Options", ["Source: #{source_name}"] + parse_list_subtitles(options), options, ""
+      if records.nil? || records.empty?
+        print cyan,"No options found.",reset,"\n"
+      else
+        if networks && !networks.empty?
+          print_h2 "Networks", [], options
+          rows = networks.collect {|row| {name: row['name'], value: row['id']} }
+          print as_pretty_table(rows, [:name, :value], options)
+        end
+        if network_groups && !network_groups.empty?
+          print_h2 "Network Groups", [], options
+          rows = network_groups.collect {|row| {name: row['name'], value: row['id']} }
+          print as_pretty_table(rows, [:name, :value], options)
+        end
+        if network_subnets && !network_subnets.empty?
+          print_h2 "Subnets", [], options
+          rows = network_subnets.collect {|row| {name: row['name'], value: row['id']} }
+          print as_pretty_table(rows, [:name, :value], options)
+        end
       end
+      print_results_pagination({size: records.size, total: records.size})
       print reset,"\n"
     end
     return 0, nil

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

@@ -763,61 +763,49 @@ class Morpheus::Cli::PoliciesCommand
     params = {}
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage()
-      build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :remote])
+      opts.banner = subcommand_usage("[search]")
+      build_standard_list_options(opts, options, [], [:search])
+      opts.footer = <<-EOT
+Get details about a policy type.
+[policy-type] is required. This is Name or ID of a policy type.
+EOT
       opts.footer = "List policy types."
     end
     optparse.parse!(args)
-
-    if args.count != 0
-      print_error Morpheus::Terminal.angry_prompt
-      puts_error  "wrong number of arguments, expected 0 and got #{args.count}\n#{optparse}"
-      return 1
-    end
-
+    verify_args!(args:args, optparse:optparse, count:0)
+    # if args.count > 0
+    #   options[:phrase] = args.join(" ")
+    # end
+    params.merge!(parse_list_options(options))
     connect(options)
-    begin
-      @policies_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @policies_interface.dry.list_policy_types(params)
-        return 0
-      end
-      json_response = @policies_interface.list_policy_types()
+    @policies_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @policies_interface.dry.list_policy_types(params)
+      return 0
+    end
+    json_response = @policies_interface.list_policy_types(params)
+    render_response(json_response, options, 'policyTypes') do
       policy_types = json_response['policyTypes']
-      if options[:json]
-        puts as_json(json_response, options, "policyTypes")
-        return 0
-      elsif options[:yaml]
-        puts as_yaml(json_response, options, "policyTypes")
-        return 0
-      elsif options[:csv]
-        puts records_as_csv(policy_types, options)
-        return 0
-      else
-        print_h1 "Morpheus Policy Types"
-        rows = policy_types.collect {|policy_type| 
-          row = {
-            id: policy_type['id'],
-            name: policy_type['name'],
-            code: policy_type['code'],
-            description: policy_type['description']
-          }
-          row
+      print_h1 "Morpheus Policy Types"
+      rows = policy_types.collect {|policy_type| 
+        row = {
+          id: policy_type['id'],
+          name: policy_type['name'],
+          code: policy_type['code'],
+          description: policy_type['description']
         }
-        columns = [:id, :name]
-        if options[:include_fields]
-          columns = options[:include_fields]
-        end
-        print cyan
-        print as_pretty_table(rows, columns, options)
-        print_results_pagination(json_response, {:label => "policy type", :n_label => "policy types"})
-        print reset, "\n"
+        row
+      }
+      columns = [:id, :name]
+      if options[:include_fields]
+        columns = options[:include_fields]
       end
-      return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      return 1
+      print cyan
+      print as_pretty_table(rows, columns, options)
+      print_results_pagination(json_response)
+      print reset, "\n"
     end
+    return 0
   end
 
   def get_type(args)
@@ -825,91 +813,54 @@ class Morpheus::Cli::PoliciesCommand
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[policy-type]")
-      build_common_options(opts, options, [:json, :dry_run, :remote])
-      opts.footer = "Get details about a policy type." + "\n" +
-                    "[policy-type] is required. This is ID of a policy type."
+      build_standard_get_options(opts, options)
+      opts.footer = <<-EOT
+Get details about a policy type.
+[policy-type] is required. This is Name or ID of a policy type.
+EOT
     end
     optparse.parse!(args)
-
-    if args.count != 1
-      print_error Morpheus::Terminal.angry_prompt
-      puts_error  "wrong number of arguments, expected 1 and got #{args.count}\n#{optparse}"
-      return 1
-    end
-
+    verify_args!(args:args, optparse:optparse, count: 1)
     connect(options)
-    begin
-      policy_type_id = args[0].to_s
-      @policies_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @policies_interface.dry.get_policy_type(policy_type_id, params)
-        return 0
-      end
-      json_response = @policies_interface.get_policy_type(policy_type_id, params)
-      policy_type = json_response['policyType']
-      if options[:json]
-        puts as_json(json_response)
-      else
-        print_h1 "Policy Type Details"
-        print cyan
-        description_cols = {
-          "ID" => 'id',
-          "Name" => 'name',
-          # "Description" => 'description',
-          "Code" => 'code',
-          "Category" => 'category',
-          # "Load Method" => 'loadMethod',
-          # "Enforce Method" => 'enforceMethod',
-          # "Prepare Method" => 'prepareMethod',
-          # "Validate Method" => 'validateMethod',
-          "Provision Enforced" => lambda {|it| it['enforceOnProvision'] ? 'Yes' : 'No'  },
-          "Managed Enforced" => lambda {|it| it['enforceOnManaged'] ? 'Yes' : 'No'  },
-        }
-        print_description_list(description_cols, policy_type)
-        print reset,"\n"
-
-        # show option types
-        print_h2 "Policy Type Options"
-        policy_type_option_types = policy_type['optionTypes']
-        if !policy_type_option_types || policy_type_option_types.size() == 0
-          puts "No options found for policy type"
-        else
-          rows = policy_type_option_types.collect {|option_type|
-            field_str = option_type['fieldName'].to_s
-            if !option_type['fieldContext'].to_s.empty?
-              field_str = option_type['fieldContext'] + "." + field_str
-            end
-            description_str = option_type['description'].to_s
-            if option_type['helpBlock']
-              if description_str.empty?
-                description_str = option_type['helpBlock']
-              else
-                description_str += " " + option_type['helpBlock']
-              end
-            end
-            row = {
-              #code: option_type['code'],
-              field: field_str,
-              type: option_type['type'],
-              description: description_str,
-              default: option_type['defaultValue'],
-              required: option_type['required'] ? 'Yes' : 'No'
-            }
-            row
-          }
-          columns = [:field, :type, :description, :default, :required]
-          print cyan
-          print as_pretty_table(rows, columns)
-          print reset,"\n"
-        end
-        return 0
-      end
+    params.merge!(parse_query_options(options))
+    policy_type_id = args[0]
+    if policy_type_id.to_s !~ /\A\d{1,}\Z/
+      policy_type = find_policy_type_by_name_or_id(args[0])
+      return [1, "Policy Type not found for #{args[0]}"] if policy_type.nil?
+      policy_type_id = policy_type['id']
+    end
+    @policies_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @policies_interface.dry.get_policy_type(policy_type_id, params)
       return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      return 1
     end
-    @policies_interface.list_policy_types
+    json_response = @policies_interface.get_policy_type(policy_type_id, params)
+    render_response(json_response, options, 'policyType') do
+      policy_type = json_response['policyType']
+      print_h1 "Policy Type Details"
+      print cyan
+      description_cols = {
+        "ID" => 'id',
+        "Name" => 'name',
+        # "Description" => 'description',
+        "Code" => 'code',
+        "Category" => 'category',
+        # "Load Method" => 'loadMethod',
+        # "Enforce Method" => 'enforceMethod',
+        # "Prepare Method" => 'prepareMethod',
+        # "Validate Method" => 'validateMethod',
+        "Provision Enforced" => lambda {|it| it['enforceOnProvision'] ? 'Yes' : 'No'  },
+        "Managed Enforced" => lambda {|it| it['enforceOnManaged'] ? 'Yes' : 'No'  },
+      }
+      print_description_list(description_cols, policy_type)
+      print reset,"\n"
+
+      # show option types
+      print_h2 "Policy Type Options"
+      print format_option_types_table(policy_type['optionTypes'], options, 'policy')
+      print reset,"\n"
+    end
+    return 0
   end
 
   private
@@ -978,9 +929,42 @@ class Morpheus::Cli::PoliciesCommand
     end
   end
 
+  def find_policy_type_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_policy_type_by_id(val)
+    else
+      return find_policy_type_by_name(val)
+    end
+  end
+
+  def find_policy_type_by_name(name)
+    json_response = nil
+    
+    # json_response = @policies_interface.list_policy_types({name: name.to_s})
+    json_response = @policies_interface.list_policy_types({max: 10000})
+    policy_types = json_response['policyTypes']
+    match_value = name.to_s.downcase
+    policy_types = policy_types.select {|it| it['name'].to_s.downcase == match_value || it['code'].to_s.downcase == match_value }
+    if policy_types.empty?
+      print_red_alert "Policy not found by name #{name}"
+      return nil
+    elsif policy_types.size > 1
+      print_red_alert "#{policy_types.size} policy types found by name or code #{name}"
+      # print_policies_table(policy_types, {color: red})
+      rows = policy_types.collect do |it|
+        {id: it['id'], name: it['name'], code: it['code']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      policy_type = policy_types[0]
+      return policy_type
+    end
+  end
+
   def find_policy_type_by_id(id)
     begin
-      json_response = @policies_interface.get_type(id.to_s)
+      json_response = @policies_interface.get_policy_type(id.to_s)
       return json_response['policyType']
     rescue RestClient::Exception => e
       if e.response && e.response.code == 404

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

@@ -631,6 +631,8 @@ EOT
         params['authority'] = v_prompt['authority']
         v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text', 'displayOrder' => 2}], options[:options])
         params['description'] = v_prompt['description']
+        v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'landingUrl', 'fieldLabel' => 'landingUrl', 'type' => 'text', 'displayOrder' => 3, 'description' => 'An optional override for the default landing page after login for a user.'}], options[:options])
+        params['landingUrl'] = v_prompt['landingUrl']
 
         if params['owner']
           if @is_master_account && has_complete_access
@@ -2479,6 +2481,7 @@ Update default workflow access for a role.
     [
       {'fieldName' => 'authority', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true},
       {'fieldName' => 'description', 'fieldLabel' => 'Description', 'type' => 'text'},
+      {'fieldName' => 'landingUrl', 'fieldLabel' => 'Landing URL', 'type' => 'text', 'description' => 'An optional override for the default landing page after login for a user.'},
       {'fieldName' => 'roleType', 'fieldLabel' => 'Role Type', 'type' => 'select', 'selectOptions' => [{'name' => 'User Role', 'value' => 'user'}, {'name' => 'Account Role', 'value' => 'account'}], 'defaultValue' => 'user'},
       {'fieldName' => 'baseRole', 'fieldLabel' => 'Copy From Role', 'type' => 'text'},
       {'fieldName' => 'multitenant', 'fieldLabel' => 'Multitenant', 'type' => 'checkbox', 'defaultValue' => 'off', 'description' => 'A Multitenant role is automatically copied into all existing subaccounts as well as placed into a subaccount when created. Useful for providing a set of predefined roles a Customer can use'},

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

@@ -131,6 +131,7 @@ module Morpheus::Cli::AccountsHelper
       "ID" => 'id',
       "Name" => 'authority',
       "Description" => 'description',
+      "Landing URL" => 'landingUrl',
       #"Scope" => lambda {|it| it['scope'] },
       "Type" => lambda {|it| format_role_type(it) },
       "Multitenant" => lambda {|it| 
@@ -149,6 +150,7 @@ module Morpheus::Cli::AccountsHelper
       "ID" => 'id',
       "Name" => 'authority',
       "Description" => 'description',
+      "Landing URL" => 'landingUrl',
       "Created" => lambda {|it| format_local_dt(it['dateCreated']) },
       "Updated" => lambda {|it| format_local_dt(it['lastUpdated']) }
     }

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

@@ -137,6 +137,7 @@ module Morpheus::Cli::InfrastructureHelper
       return cloud_type_for_name(val)
     end
   end
+
   def cloud_type_for_id(id)
     return get_available_cloud_types().find { |z| z['id'].to_i == id.to_i}
   end
@@ -633,7 +634,6 @@ module Morpheus::Cli::InfrastructureHelper
       "Name" => lambda {|it| it['name'] },
       "Type" => lambda {|it| it['type'] ? it['type']['name'] : '' },
       "URL" => lambda {|it| it['serviceUrl'] },
-      #"Pools" => lambda {|it| it['pools'] ? anded_list(it['pools'].collect {|p| p['name'] }, 3) : '' },
       "Enabled" => lambda {|it| format_boolean(it['enabled']) },
       "Status" => lambda {|it| format_network_pool_server_status(it) },
       "Date Created" => lambda {|it| format_local_dt(it['dateCreated']) },
@@ -661,7 +661,6 @@ module Morpheus::Cli::InfrastructureHelper
       "Extra Attributes" => lambda {|it| it['config'] ? it['config']['extraAttributes'] : nil },
       "Enabled" => lambda {|it| format_boolean(it['enabled']) },
       "Status" => lambda {|it| format_network_pool_server_status(it) },
-      #"Pools" => lambda {|it| it['pools'] ? anded_list(it['pools'].collect {|p| p['name'] }, 3) : '' },
       "Date Created" => lambda {|it| format_local_dt(it['dateCreated']) },
       "Last Updated" => lambda {|it| format_local_dt(it['lastUpdated']) },
     }
@@ -706,4 +705,106 @@ module Morpheus::Cli::InfrastructureHelper
     }
   end
 
+  def find_network_server_type_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_network_server_type_by_id(val)
+    else
+      # always find by code too
+      #return find_network_server_type_by_name(val)
+      return find_network_server_type_by_name_or_code(val)
+    end
+  end
+
+  def find_network_server_type_by_id(id)
+    begin
+      json_response = @network_server_types_interface.get(id.to_i)
+      return json_response['networkServerType']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Network Server Type not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_network_server_type_by_name(name)
+    json_response = @network_server_types_interface.list({name: name.to_s})
+    network_server_types = json_response['networkServerTypes']
+    if network_server_types.empty?
+      print_red_alert "Network Server Type not found by name #{name}"
+      return nil
+    elsif network_server_types.size > 1
+      print_red_alert "#{network_server_types.size} network server types found by name #{name}"
+      # print_networks_table(networks, {color: red})
+      rows = network_server_types.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :code, :name], {color:red})
+      return nil
+    else
+      return network_server_types[0]
+    end
+  end
+
+  def find_network_server_type_by_name_or_code(name)
+    json_response = @network_server_types_interface.list({phrase: name.to_s, max: 100})
+    downcase_name = name.to_s.downcase
+    network_server_types = json_response['networkServerTypes'].select { |it| 
+        it['code'].to_s.downcase == downcase_name || it['name'].to_s.downcase == downcase_name 
+    }
+    if network_server_types.empty?
+      print_red_alert "Network Server Type not found by name or code '#{name}'"
+      return nil
+    elsif network_server_types.size > 1
+      print_red_alert "#{network_server_types.size} network server types found with name or code '#{name}'"
+      # print_networks_table(networks, {color: red})
+      rows = network_server_types.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :code, :name], {color:red})
+      return nil
+    else
+      return network_server_types[0]
+    end
+  end
+
+  def network_server_type_list_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+      "Enabled" => lambda {|it| format_boolean(it['enabled']) }
+    }
+  end
+
+  def network_server_type_column_definitions(options)
+    {
+      "ID" => 'id',
+      "Name" => 'name',
+      "Code" => 'code',
+      "Description" => 'description',
+      "Enabled" => lambda {|it| format_boolean(it['enabled']) },
+      "Selectable" => lambda {|it| format_boolean(it['selectable']) },
+      "Creatable" => lambda {|it| format_boolean(it['creatable']) },
+      "Plugin" => lambda {|it| format_boolean(it['isPlugin']) },
+      "Embedded" => lambda {|it| format_boolean(it['isEmbedded']) },
+      #"Integration Code" => lambda {|it| it['integrationCode'] },
+      "Networks" => lambda {|it| format_boolean(it['hasNetworks']) },
+      "Gateways" => lambda {|it| format_boolean(it['hasGateways']) },
+      "DHCP Servers" => lambda {|it| format_boolean(it['hasDhcpServers']) },
+      "DHCP Relays" => lambda {|it| format_boolean(it['hasDhcpRelays']) },
+      # "Route Tables" => lambda {|it| format_boolean(it['hasRouteTables']) },
+      "Routers" => lambda {|it| format_boolean(it['hasRouters']) },
+      "Switches" => lambda {|it| format_boolean(it['hasSwitches']) },
+      "Firewall" => lambda {|it| format_boolean(it['hasFirewall']) },
+      "Security Groups" => lambda {|it| format_boolean(it['hasSecurityGroups']) },
+      "Load Balancers" => lambda {|it| format_boolean(it['hasLoadBalancers']) },
+      # "Security Code" => lambda {|it| it['securityCode'] },
+      # "User Visible" => lambda {|it| format_boolean(it['userVisible']) },
+    }
+  end
+
 end

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

@@ -0,0 +1,62 @@
+require 'morpheus/cli/mixins/print_helper'
+require 'morpheus/cli/option_types'
+require 'morpheus/rest_client'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for networking commands
+module Morpheus::Cli::NetworksHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def network_servers_interface
+    # @api_client.network_servers
+    raise "#{self.class} has not defined @network_servers_interface" if @network_servers_interface.nil?
+    @network_servers_interface
+  end
+
+  def find_network_server(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_network_server_by_id(val)
+    else
+      if server = find_network_server_by_name(val)
+        return find_network_server_by_id(server['id'])
+      end
+    end
+  end
+
+  def find_network_server_by_id(id)
+    begin
+      # Use query parameter `details=true` to get the full type object with all its configuration settings and optionTypes
+      json_response = @network_servers_interface.get(id.to_i, {details:true})
+      return json_response['networkServer']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Network Server not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_network_server_by_name(name)
+    # Use query parameter `details=true` to get the full type object with all its configuration settings and optionTypes
+    json_response = @network_servers_interface.list({phrase: name.to_s, details:true})
+    servers = json_response['networkServers']
+    if servers.empty?
+      print_red_alert "Network Server not found by name #{name}"
+      return nil
+    elsif servers.size > 1
+      print_red_alert "#{servers.size} network servers found by name #{name}"
+      rows = servers.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      return servers[0]
+    end
+  end
+
+end