Parent

Class/Module Index [+]

Quicksearch

HammerCLIForeman::IdResolver

Attributes

api[R]

Public Class Methods

new(api, searchables) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 79
def initialize(api, searchables)
  @api = api
  @searchables = searchables
  define_id_finders
end

Public Instance Methods

puppetclass_id(options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 110
def puppetclass_id(options)
  if options[HammerCLI.option_accessor_name("id")]
    return options[HammerCLI.option_accessor_name("id")]
  else
    resource = @api.resource(:puppetclasses)
    results = resolved_call(:puppetclasses, :index, options)[0]
    results = results.values.flatten
    return pick_result(results, resource)['id']
  end
end
puppetclass_ids(options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 121
def puppetclass_ids(options)
  options[HammerCLI.option_accessor_name("ids")] || find_resources(:puppetclasses, options).collect{|h| h.values}.flatten.map{|h| h['id']}
end
scoped_options(scope, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 85
def scoped_options(scope, options)
  scoped_options = options.dup

  resource = HammerCLIForeman.param_to_resource(scope)
  return scoped_options unless resource

  option_names = searchables(resource).map { |s| s.name }
  option_names += searchables(resource).map { |s| s.plural_name }
  option_names << "id"

  option_names.each do |name|
    option = HammerCLI.option_accessor_name(name)
    scoped_option = HammerCLI.option_accessor_name("#{scope}_#{name}")
    # remove the scope
    # e.g. option_architecture_id -> option_id
    if scoped_options[scoped_option]
      scoped_options[option] = scoped_options.delete(scoped_option)
    else
      scoped_options.delete(option)
    end
  end
  scoped_options
end

Protected Instance Methods

create_search_options(options, resource) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 259
def create_search_options(options, resource)
  searchables(resource).each do |s|
    value = options[HammerCLI.option_accessor_name(s.name.to_s)]
    values = options[HammerCLI.option_accessor_name(s.plural_name.to_s)]
    if value
      return {:search => "#{s.name} = \"#{value}\""}
    elsif values
      query = values.map{|v| "#{s.name} = \"#{v}\"" }.join(" or ")
      return {:search => query}
    end
  end
  {}
end
create_smart_class_parameters_search_options(options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 244
def create_smart_class_parameters_search_options(options)
  search_options = {}
  value = options[HammerCLI.option_accessor_name('name')]
  search_options[:search] = "key = \"#{value}\""
  search_options[:puppetclass_id] = puppetclass_id(scoped_options("puppetclass", options))
  search_options
end
create_smart_variables_search_options(options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 252
def create_smart_variables_search_options(options)
  search_options = {}
  value = options[HammerCLI.option_accessor_name('name')]
  search_options[:search] = "key = \"#{value}\""
  search_options
end
define_id_finders() click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 127
def define_id_finders
  @api.resources.each do |resource|
    method_name = "#{resource.singular_name}_id"
    plural_method_name = "#{resource.singular_name}_ids"

    self.class.send(:define_method, method_name) do |options|
      get_id(resource.name, options)
    end unless respond_to?(method_name, true)

    self.class.send(:define_method, plural_method_name) do |options|
      get_ids(resource.name, options)
    end unless respond_to?(plural_method_name, true)
  end
end
expected_record_count(options, resource) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 220
def expected_record_count(options, resource)
  searchables(resource).each do |s|
    value = options[HammerCLI.option_accessor_name(s.name.to_s)]
    values = options[HammerCLI.option_accessor_name(s.plural_name.to_s)]
    if value
      return 1
    elsif values
      return values.count
    end
  end
  0
end
find_resource(resource_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 157
def find_resource(resource_name, options)
  results = find_resource_raw(resource_name, options)
  resource = @api.resource(resource_name)
  pick_result(results, resource)
end
find_resource_raw(resource_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 163
def find_resource_raw(resource_name, options)
  resolved_call(resource_name, :index, options)
end
find_resources(resource_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 150
def find_resources(resource_name, options)
  resource = @api.resource(resource_name)
  results = resolved_call(resource_name, :index, options)
  raise ResolverError.new(_("one of %s not found") % resource.name, resource) if results.count < expected_record_count(options, resource)
  results
end
get_id(resource_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 142
def get_id(resource_name, options)
  options[HammerCLI.option_accessor_name("id")] || find_resource(resource_name, options)['id']
end
get_ids(resource_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 146
def get_ids(resource_name, options)
  options[HammerCLI.option_accessor_name("ids")] || find_resources(resource_name, options).map{|r| r['id']}
end
pick_result(results, resource) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 199
def pick_result(results, resource)
  raise ResolverError.new(_("%s not found") % resource.singular_name, resource) if results.empty?
  raise ResolverError.new(_("found more than one %s") % resource.singular_name, resource) if results.count > 1
  results[0]
end
resolved_call(resource_name, action_name, options) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 168
def resolved_call(resource_name, action_name, options)
  resource = @api.resource(resource_name)
  action = resource.action(action_name)

  search_options = search_options(options, resource)
  IdParamsFilter.new(:only_required => true).for_action(action).each do |param|
    search_options[param.name] ||= send(param.name, scoped_options(param.name.gsub(/_id$/, ""), options))
  end
  search_options = route_options(options, action).merge(search_options)

  results = resource.call(action_name, search_options)
  results = HammerCLIForeman.collection_to_common_format(results)
  results
end
route_options(options, action) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 183
def route_options(options, action)
  return {} if action.routes.any? { |r| r.params_in_path.empty? }

  route_options = {}

  action.routes.each do |route|
    route.params_in_path.each do |param|
      key = HammerCLI.option_accessor_name(param.to_s)
      if options[key]
        route_options[param] ||= options[key]
      end
    end
  end
  route_options
end
search_options(options, resource) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 205
def search_options(options, resource)
  method = "create_#{resource.name}_search_options"
  search_options = if respond_to?(method, true)
                     send(method, options)
                   else
                     create_search_options(options, resource)
                   end
  raise MissingSeachOptions.new(_("Missing options to search %s") % resource.singular_name, resource) if search_options.empty?
  search_options
end
searchables(resource) click to toggle source
# File lib/hammer_cli_foreman/id_resolver.rb, line 216
def searchables(resource)
  @searchables.for(resource)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.