Project

General

Profile

« Previous | Next » 

Revision 57526a20

Added by Joseph Magen over 11 years ago

  • ID 57526a20744f3f7e9cfdeef6e7f3268da8eab2ad

fixes #1988 - CRUD Actions for nested parameters for host, domain, hostgroup, os

e.g.

GET /api/domains/6/parameters
POST /api/hosts/6/parameters
PUT /api/hostgroups/6/parameters/100
DELETE /api/operatingsystems/6/parameters/100

View differences:

app/controllers/api/v2/parameters_controller.rb
module Api
module V2
class ParametersController < V2::BaseController
include Api::Version2
include Api::TaxonomyScope
before_filter :find_resource, :only => [:show, :update, :destroy]
before_filter :find_nested_object, :only => [:index, :show, :create]
resource_description do
desc <<-DOC
These API calls are related to <b>nested parameters for host, domain, hostgroup, operating system</b>. If you are looking for
<a href="common_parameters.html">global parameters</a>, go to <a href="common_parameters.html">this link</a>.
DOC
end
api :GET, "/references/:id/parameters/", "List all parameters for host, domain, hostgroup, or operating system"
param :page, String, :desc => "paginate results"
param :per_page, String, :desc => "number of entries per request"
def index
@parameters = nested_obj.send(parameters_method).paginate(paginate_options)
end
api :GET, "/references/:reference_id/parameters/:id/", "Show a nested parameter for host, domain, hostgroup, or operating system"
param :reference_id, String, :required => true, :desc => "id of nested reference object (:i.e. host, domain, hostgroup, or operating system) results"
param :id, String, :required => true, :desc => "id of parameter"
def show
end
api :POST, "/references/:reference_id/parameters", "Create a nested parameter for host, domain, hostgroup, or operating system"
param :reference_id, String, :required => true, :desc => "id of nested reference object (:i.e. host, domain, hostgroup, or operating system) results"
param :id, String, :required => true, :desc => "id of parameter"
param :parameter, Hash, :required => true do
param :name, String
param :value, String
end
def create
@parameter = nested_obj.send(parameters_method).new(params[:parameter])
process_response @parameter.save
end
api :PUT, "/references/:reference_id/parameters/:id/", "Update a nested parameter for host, domain, hostgroup, or operating system"
param :reference_id, String, :required => true, :desc => "id of nested reference object (:i.e. host, domain, hostgroup, or operating system) results"
param :id, String, :required => true, :desc => "id of parameter"
param :parameter, Hash, :required => true do
param :name, String
param :value, String
end
def update
process_response @parameter.update_attributes(params[:parameter])
end
api :DELETE, "/references/:id/parameters/:id/", "Delete a nested parameter for host, domain, hostgroup, or operating system."
param :reference_id, String, :required => true, :desc => "id of nested reference object (:i.e. host, domain, hostgroup, or operating system) results"
param :id, String, :required => true, :desc => "id of parameter"
def destroy
process_response @parameter.destroy
end
private
attr_reader :nested_obj
def find_nested_object
params.keys.each do |param|
if param =~ /(\w+)_id$/
resource_identifying_attributes.each do |key|
find_method = "find_by_#{key}"
@nested_obj ||= $1.classify.constantize.send(find_method, params[param])
end
end
end
return nested_obj if nested_obj
render_error 'not_found', :status => :not_found and return false
end
def parameters_method
# hostgroup.rb has a method def parameters, so I didn't create has_many :parameters like Host, Domain, Os
nested_obj.is_a?(Hostgroup) ? :group_parameters : :parameters
end
end
end
end
app/models/domain.rb
has_many :subnets, :through => :subnet_domains
belongs_to :dns, :class_name => "SmartProxy"
has_many :domain_parameters, :dependent => :destroy, :foreign_key => :reference_id
has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "DomainParameter"
has_and_belongs_to_many :users, :join_table => "user_domains"
has_many :interfaces, :class_name => 'Nic::Base'
app/models/host.rb
belongs_to :hostgroup
has_many :reports, :dependent => :destroy
has_many :host_parameters, :dependent => :destroy, :foreign_key => :reference_id
has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "HostParameter"
accepts_nested_attributes_for :host_parameters, :reject_if => lambda { |a| a[:value].blank? }, :allow_destroy => true
has_many :interfaces, :dependent => :destroy, :inverse_of => :host, :class_name => 'Nic::Base'
accepts_nested_attributes_for :interfaces, :reject_if => lambda { |a| a[:mac].blank? }, :allow_destroy => true
app/models/operatingsystem.rb
validates_presence_of :major, :message => "Operating System version is required"
has_many :os_parameters, :dependent => :destroy, :foreign_key => :reference_id
has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "OsParameter"
accepts_nested_attributes_for :os_parameters, :reject_if => lambda { |a| a[:value].blank? }, :allow_destroy => true
has_many :trends, :as => :trendable, :class_name => "ForemanTrend"
validates_numericality_of :major
app/views/api/v2/parameters/create.json.rabl
object @parameter => :parameter
extends "api/v2/parameters/show"
app/views/api/v2/parameters/index.json.rabl
collection @parameters => :parameters
extends "api/v2/parameters/show"
app/views/api/v2/parameters/show.json.rabl
object @parameter => :parameter
attributes :id, :name, :value
app/views/api/v2/parameters/update.json.rabl
object @parameter => :parameter
extends "api/v2/parameters/show"
bundler.d/local.rb
gem 'bullet'
config/routes/api/v2.rb
resources :template_combinations, :only => [:show, :destroy]
# The following resources are above in v1, so the RESTful actions will NOT be called for v2. Only nested resources not in v1 will be called for v2
# domains, compute_resources, subnets, environments, usergroups, hostgroups, smart_proxies, users, media
# hosts, domains, compute_resources, subnets, environments, usergroups, hostgroups, smart_proxies, users, media, operatingsystems
constraints(:id => /[^\/]+/) do
resources :hosts, :except => [:new, :edit] do
resources :parameters, :except => [:new, :edit]
end
resources :domains, :except => [:new, :edit] do
(resources :locations, :only => [:index, :show]) if SETTINGS[:locations_enabled]
(resources :organizations, :only => [:index, :show]) if SETTINGS[:organizations_enabled]
(resources :locations, :only => [:index, :show]) if SETTINGS[:locations_enabled]
(resources :organizations, :only => [:index, :show]) if SETTINGS[:organizations_enabled]
resources :parameters, :except => [:new, :edit]
end
resources :compute_resources, :except => [:new, :edit] do
......
resources :hostgroups, :except => [:new, :edit] do
(resources :locations, :only => [:index, :show]) if SETTINGS[:locations_enabled]
(resources :organizations, :only => [:index, :show]) if SETTINGS[:organizations_enabled]
resources :parameters, :except => [:new, :edit]
end
resources :smart_proxies, :except => [:new, :edit] do
......
(resources :organizations, :only => [:index, :show]) if SETTINGS[:organizations_enabled]
end
resources :operatingsystems, :except => [:new, :edit] do
resources :parameters, :except => [:new, :edit]
end
if SETTINGS[:locations_enabled]
resources :locations do
test/fixtures/parameters.yml
name: parameter
value: value1
type: DomainParameter
domain: one
domain: mydomain
host:
name: host1
......
value: group1
type: GroupParameter
hostgroup: common
os:
name: os1
value: os1
type: OsParameter
operatingsystem: redhat
test/functional/api/v2/parameters_controller_test.rb
require 'test_helper'
class Api::V2::ParametersControllerTest < ActionController::TestCase
valid_attrs = { :name => 'special_key', :value => '123' }
test "should get index for specific host" do
get :index, {:host_id => hosts(:one).to_param }
assert_response :success
assert_not_nil assigns(:parameters)
parameters = ActiveSupport::JSON.decode(@response.body)
assert !parameters.empty?
end
test "should get index for specific domain" do
get :index, {:domain_id => domains(:mydomain).to_param }
assert_response :success
assert_not_nil assigns(:parameters)
parameters = ActiveSupport::JSON.decode(@response.body)
assert !parameters.empty?
end
test "should get index for specific hostgroup" do
get :index, {:hostgroup_id => hostgroups(:common).to_param }
assert_response :success
assert_not_nil assigns(:parameters)
parameters = ActiveSupport::JSON.decode(@response.body)
assert !parameters.empty?
end
test "should get index for specific os" do
get :index, {:operatingsystem_id => operatingsystems(:redhat).to_param }
assert_response :success
assert_not_nil assigns(:parameters)
parameters = ActiveSupport::JSON.decode(@response.body)
assert !parameters.empty?
end
test "should show a host parameter" do
get :show, { :host_id => hosts(:one).to_param, :id => parameters(:host).to_param }
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert !show_response.empty?
end
test "should show a domain parameter" do
get :show, {:domain_id => domains(:mydomain).to_param, :id => parameters(:domain).to_param }
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert !show_response.empty?
end
test "should show a hostgroup parameter" do
get :show, {:hostgroup_id => hostgroups(:common).to_param,:id => parameters(:group).to_param }
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert !show_response.empty?
end
test "should show an os parameter" do
get :show, {:operatingsystem_id => operatingsystems(:redhat).to_param,:id => parameters(:os).to_param }
assert_response :success
show_response = ActiveSupport::JSON.decode(@response.body)
assert !show_response.empty?
end
test "should create host parameter" do
host = hosts(:one)
assert_difference('host.parameters.count') do
post :create, { :host_id => host.to_param, :parameter => valid_attrs }
end
assert_response :success
end
test "should create domain parameter" do
domain = domains(:mydomain)
assert_difference('domain.parameters.count') do
post :create, { :domain_id => domain.to_param, :parameter => valid_attrs }
end
assert_response :success
end
test "should create hostgroup parameter" do
hostgroup = hostgroups(:common)
assert_difference('hostgroup.group_parameters.count') do
post :create, { :hostgroup_id => hostgroup.to_param, :parameter => valid_attrs }
end
assert_response :success
end
test "should create os parameter" do
os = operatingsystems(:redhat)
assert_difference('os.parameters.count') do
post :create, { :operatingsystem_id => os.to_param, :parameter => valid_attrs }
end
assert_response :success
end
test "should update nested host parameter" do
put :update, { :host_id => hosts(:one).to_param, :id => parameters(:host).to_param, :parameter => valid_attrs }
assert_response :success
assert_equal Host.find_by_name("my5name.mydomain.net").parameters.order("parameters.updated_at").last.value, "123"
end
test "should update nested domain parameter" do
put :update, { :domain_id => domains(:mydomain).to_param, :id => parameters(:domain).to_param, :parameter => valid_attrs }
assert_response :success
assert_equal Domain.find_by_name("mydomain.net").parameters.order("parameters.updated_at").last.value, "123"
end
test "should update nested hostgroup parameter" do
put :update, { :hostgroup_id => hostgroups(:common).to_param, :id => parameters(:group).to_param, :parameter => valid_attrs }
assert_response :success
assert_equal Hostgroup.find_by_name("Common").group_parameters.order("parameters.updated_at").last.value, "123"
end
test "should update nested os parameter" do
put :update, { :operatingsystem_id => operatingsystems(:redhat).to_param, :id => parameters(:os).to_param, :parameter => valid_attrs }
assert_response :success
assert_equal Operatingsystem.find_by_name("Redhat").parameters.order("parameters.updated_at").last.value, "123"
end
test "should destroy nested host parameter" do
assert_difference('HostParameter.count', -1) do
delete :destroy, { :host_id => hosts(:one).to_param, :id => parameters(:host).to_param }
end
assert_response :success
end
test "should destroy nested domain parameter" do
assert_difference('DomainParameter.count', -1) do
delete :destroy, { :domain_id => domains(:mydomain).to_param, :id => parameters(:domain).to_param }
end
assert_response :success
end
test "should destroy Hostgroup parameter" do
assert_difference('GroupParameter.count', -1) do
delete :destroy, { :hostgroup_id => hostgroups(:common).to_param, :id => parameters(:group).to_param }
end
assert_response :success
end
test "should destroy nested os parameter" do
assert_difference('OsParameter.count', -1) do
delete :destroy, { :operatingsystem_id => operatingsystems(:redhat).to_param, :id => parameters(:os).to_param }
end
assert_response :success
end
end

Also available in: Unified diff