foreman_remote_execution 1.6.3 → 1.6.4

data/app/controllers/api/v2/template_inputs_controller.rb

@@ -1,92 +0,0 @@
-module Api
-  module V2
-    class TemplateInputsController < ::Api::V2::BaseController
-      include ::Api::Version2
-      include ::Foreman::Renderer
-      include ::Foreman::Controller::Parameters::TemplateInput
-
-      before_action :find_required_nested_object
-      before_action :find_resource, :only => %w{show update destroy}
-      before_action :normalize_options, :only => %w{create update}
-
-      api :GET, '/templates/:template_id/template_inputs', N_('List template inputs')
-      param :template_id, :identifier, :required => true
-      param_group :search_and_pagination, ::Api::V2::BaseController
-      def index
-        @template_inputs = nested_obj.template_inputs.search_for(*search_options).paginate(paginate_options)
-      end
-
-      api :GET, '/templates/:template_id/template_inputs/:id', N_('Show template input details')
-      param :template_id, :identifier, :required => true
-      param :id, :identifier, :required => true
-      def show; end
-
-      def_param_group :template_input do
-        param :template_input, Hash, :required => true, :action_aware => true do
-          param :name, String, :required => true, :desc => N_('Input name')
-          param :description, String, :required => false, :desc => N_('Input description')
-          param :required, :bool, :allow_nil => true, :desc => N_('Input is required')
-          param :advanced, :bool, :allow_nil => true, :desc => N_('Input is advanced')
-          param :input_type, TemplateInput::TYPES.keys.map(&:to_s), :required => true, :desc => N_('Input type')
-          param :fact_name, String, :required => false, :desc => N_('Fact name, used when input type is fact')
-          param :variable_name, String, :required => false, :desc => N_('Variable name, used when input type is variable')
-          param :puppet_class_name, String, :required => false, :desc => N_('Puppet class name, used when input type is puppet_parameter')
-          param :puppet_parameter_name, String, :required => false, :desc => N_('Puppet parameter name, used when input type is puppet_parameter')
-          param :options, Array, :required => false, :desc => N_('Selectable values for user inputs')
-        end
-      end
-
-      api :POST, '/templates/:template_id/template_inputs/', N_('Create a template input')
-      param :template_id, :identifier, :required => true
-      param_group :template_input, :as => :create
-      def create
-        @template_input = resource_class.new(template_input_params.merge(:template_id => @nested_obj.id))
-        process_response @template_input.save
-      end
-
-      api :DELETE, '/templates/:template_id/template_inputs/:id', N_('Delete a template input')
-      param :template_id, :identifier, :required => true
-      param :id, :identifier, :required => true
-      def destroy
-        process_response @template_input.destroy
-      end
-
-      api :PUT, '/templates/:template_id/template_inputs/:id', N_('Update a template input')
-      param :template_id, :identifier, :required => true
-      param :id, :identifier, :required => true
-      param_group :template_input
-      def update
-        process_response @template_input.update_attributes(template_input_params)
-      end
-
-      def resource_name(nested_resource = nil)
-        nested_resource || 'template_input'
-      end
-
-      def controller_permission
-        'templates'
-      end
-
-      def action_permission
-        case params[:action]
-        when :create, :edit, :destroy
-          'edit'
-        else
-          super
-        end
-      end
-
-      private
-
-      def normalize_options
-        if params[:template_input][:options].is_a?(Array)
-          params[:template_input][:options] = params[:template_input][:options].join("\n")
-        end
-      end
-
-      def resource_class
-        TemplateInput
-      end
-    end
-  end
-end

data/app/controllers/concerns/foreman/controller/parameters/template_input.rb

@@ -1,17 +0,0 @@
-module Foreman::Controller::Parameters::TemplateInput
-  extend ActiveSupport::Concern
-
-  class_methods do
-    def template_input_params_filter
-      Foreman::ParameterFilter.new(::TemplateInput).tap do |filter|
-        filter.permit_by_context :id, :_destroy, :name, :required, :input_type, :fact_name,
-                                 :variable_name, :puppet_class_name, :puppet_parameter_name, :description, :template_id,
-                                 :options, :advanced, :nested => true
-      end
-    end
-  end
-
-  def template_input_params
-    self.class.template_input_params_filter.filter_params(params, parameter_filter_context, :template_input)
-  end
-end

data/app/models/template_input.rb

@@ -1,179 +0,0 @@
-class TemplateInput < ApplicationRecord
-  include ::Exportable
-
-  class ValueNotReady < ::Foreman::Exception
-  end
-  class UnsatisfiedRequiredInput < ::Foreman::Exception
-  end
-
-  TYPES = { :user => N_('User input'), :fact => N_('Fact value'), :variable => N_('Variable'),
-            :puppet_parameter => N_('Puppet parameter') }.with_indifferent_access
-
-  attr_exportable(:name, :required, :input_type, :fact_name, :variable_name, :puppet_class_name,
-                  :puppet_parameter_name, :description, :options, :advanced)
-
-  belongs_to :template
-  has_many :template_invocation_input_values, :dependent => :destroy
-
-  scoped_search :on => :name, :complete_value => true
-  scoped_search :on => :input_type, :complete_value => true
-
-  validates :name, :presence => true, :uniqueness => { :scope => 'template_id' }
-  validates :input_type, :presence => true, :inclusion => TemplateInput::TYPES.keys
-
-  validates :fact_name, :presence => { :if => :fact_template_input? }
-  validates :variable_name, :presence => { :if => :variable_template_input? }
-  validates :puppet_parameter_name, :puppet_class_name, :presence => { :if => :puppet_parameter_template_input? }
-
-  def user_template_input?
-    input_type == 'user'
-  end
-
-  def fact_template_input?
-    input_type == 'fact'
-  end
-
-  def variable_template_input?
-    input_type == 'variable'
-  end
-
-  def puppet_parameter_template_input?
-    input_type == 'puppet_parameter'
-  end
-
-  def preview(renderer)
-    get_resolver(renderer).preview
-  end
-
-  def value(renderer)
-    get_resolver(renderer).value
-  end
-
-  def options_array
-    self.options.blank? ? [] : self.options.split(/\r?\n/).map(&:strip)
-  end
-
-  def basic?
-    !advanced
-  end
-
-  private
-
-  def get_resolver(renderer)
-    resolver_class = case input_type
-                     when 'user'
-                       UserInputResolver
-                     when 'fact'
-                       FactInputResolver
-                     when 'variable'
-                       VariableInputResolver
-                     when 'puppet_parameter'
-                       PuppetParameterInputResolver
-                     else
-                       raise "unknown template input type #{input_type.inspect}"
-                     end
-    resolver_class.new(self, renderer)
-  end
-
-  class InputResolver
-    def initialize(input, renderer)
-      @input = input
-      @renderer = renderer
-    end
-
-    def preview
-      ready? ? resolved_value : preview_value
-    end
-
-    def value
-      ready? ? resolved_value : raise(ValueNotReady, "Input '#{@input.name}' is not ready for rendering")
-    end
-
-    def preview_value
-      "$#{@input.input_type.upcase}_INPUT[#{@input.name}]"
-    end
-
-    # should be defined in descendants
-    def ready?
-      raise NotImplementedError
-    end
-
-    # should be defined in descendants
-    def resolved_value
-      raise NotImplementedError
-    end
-  end
-
-  class UserInputResolver < InputResolver
-
-    def value
-      raise(UnsatisfiedRequiredInput, _("Value for required input '%s' was not specified") % @input.name) if required_value_needed?
-      super
-    end
-
-    def ready?
-      @renderer.invocation
-    end
-
-    def resolved_value
-      input_value.try(:value)
-    end
-
-    private
-
-    def required_value_needed?
-      @input.required? && input_value.try(:value).blank?
-    end
-
-    def input_value
-      return unless @renderer.invocation
-      @renderer.invocation.input_values.find { |value| value.template_input_name == @input.name }
-    end
-  end
-
-  class FactInputResolver < InputResolver
-    # fact might not be present if it hasn't been uploaded yet, there's typo in name
-    def ready?
-      @renderer.host && get_fact.present?
-    end
-
-    def resolved_value
-      get_fact.value
-    end
-
-    private
-
-    def get_fact
-      @fact ||= @renderer.host.fact_values.includes(:fact_name).find_by(:'fact_names.name' => @input.fact_name)
-    end
-  end
-
-  class VariableInputResolver < InputResolver
-    def ready?
-      @renderer.host && @renderer.host.params.key?(@input.variable_name)
-    end
-
-    def resolved_value
-      @renderer.host.params[@input.variable_name]
-    end
-  end
-
-  class PuppetParameterInputResolver < InputResolver
-    def ready?
-      @renderer.host &&
-        get_enc.key?(@input.puppet_class_name) &&
-        get_enc[@input.puppet_class_name].is_a?(Hash) &&
-        get_enc[@input.puppet_class_name].key?(@input.puppet_parameter_name)
-    end
-
-    def resolved_value
-      get_enc[@input.puppet_class_name][@input.puppet_parameter_name]
-    end
-
-    private
-
-    def get_enc
-      @enc ||= HostInfoProviders::PuppetInfo.new(@renderer.host).puppetclass_parameters
-    end
-  end
-end

data/app/views/api/v2/template_inputs/base.json.rabl

@@ -1,3 +0,0 @@
-object @template_input
-
-attributes :id, :name, :input_type

data/app/views/api/v2/template_inputs/create.json.rabl

@@ -1,3 +0,0 @@
-object @template_input
-
-extends 'api/v2/template_inputs/show'

data/app/views/api/v2/template_inputs/index.json.rabl

@@ -1,3 +0,0 @@
-collection @template_inputs
-
-extends 'api/v2/template_inputs/main'

data/app/views/api/v2/template_inputs/main.json.rabl

@@ -1,10 +0,0 @@
-object @template_input
-
-extends 'api/v2/template_inputs/base'
-
-attributes :template_id, :fact_name, :variable_name, :puppet_parameter_name, :puppet_class_name,
-           :description, :required
-
-node :options do |input|
-  input.options.split(/\r?\n/) if input.options.present?
-end

data/app/views/api/v2/template_inputs/show.json.rabl

@@ -1,3 +0,0 @@
-object @template_input
-
-extends 'api/v2/template_inputs/main'

data/app/views/template_inputs/_form.html.erb

@@ -1,25 +0,0 @@
-<div class="fields">
-  <div class="form-group">
-    <%= field_set_tag template_input_header(f, @template) do  %>
-      <%= text_f f, :name, :disabled => @template.locked? %>
-      <%= checkbox_f f, :required, :disabled => @template.locked? %>
-      <%= selectable_f f, :input_type, template_input_types_options, {}, :class => 'input_type_selector without_select2', :disabled => @template.locked? %>
-      <div class="fact_input_type custom_input_type_fields" style="<%= f.object.fact_template_input? ? '' : 'display:none' %>">
-        <%= text_f f, :fact_name, :class => 'fact_input_type', :required => true, :disabled => @template.locked? %>
-      </div>
-      <div class="variable_input_type custom_input_type_fields" style="<%= f.object.variable_template_input? ? '' : 'display:none' %>">
-        <%= text_f f, :variable_name, :class => 'variable_input_type', :required => true, :disabled => @template.locked? %>
-      </div>
-      <div class="puppet_parameter_input_type custom_input_type_fields" style="<%= f.object.puppet_parameter_template_input? ? '' : 'display:none' %>">
-        <%= text_f f, :puppet_class_name, :class => 'puppet_parameter_input_type', :required => true, :disabled => @template.locked? %>
-        <%= text_f f, :puppet_parameter_name, :class => 'puppet_parameter_input_type', :required => true, :disabled => @template.locked? %>
-      </div>
-      <div class="user_input_type custom_input_type_fields" style="<%= (f.object.user_template_input? || f.object.new_record?) ? '' : 'display:none' %>">
-        <%= checkbox_f f, :advanced, :disabled => @template.locked? %>
-        <%= textarea_f f, :options, :rows => 3, :class => 'user_input_type', :help_inline => _("A list of options the user can select from. If not provided, the user will be given a free-form field"),
-                                    :disabled => @template.locked? %>
-      </div>
-      <%= textarea_f f, :description, :rows => 3, :disabled => @template.locked? %>
-    <% end %>
-  </div>
-</div>

data/app/views/template_inputs/_invocation_form.html.erb

@@ -1,7 +0,0 @@
-<%= input_values_fields.fields_for input.id.to_s, composer.template_invocation_input_value_for(job_template, input) do |input_fields| %>
-  <% unless input.options.blank? %>
-    <%= selectable_f input_fields, :value, input.options_array, { :include_blank => !input.required }, :label_help => input.description, :require => input.required, :label => input.name, :id => input.name, :onchange => "regenerate_description(this);" %>
-  <% else %>
-    <%= textarea_f input_fields, :value, :label => input.name, :label_help => input.description, :required => input.required, :rows => 2, :onchange => "regenerate_description(this);", :id => input.name %>
-  <% end %>
-<% end %>

data/db/migrate/20150616080015_create_template_input.rb

@@ -1,19 +0,0 @@
-class CreateTemplateInput < ActiveRecord::Migration[4.2]
-  def change
-    create_table :template_inputs do |t|
-      t.string :name, :null => false, :limit => 255
-      t.boolean :required, :null => false, :default => false
-      t.string :input_type, :null => false, :limit => 255
-      t.string :fact_name, :limit => 255
-      t.string :variable_name, :limit => 255
-      t.string :puppet_class_name, :limit => 255
-      t.string :puppet_parameter_name, :limit => 255
-      t.text :description
-      t.integer :template_id
-
-      t.timestamps :null => true
-    end
-
-    add_foreign_key :template_inputs, :templates, :name => 'templates_template_id_fk', :column => 'template_id'
-  end
-end

data/db/migrate/20150827152730_add_options_to_template_input.rb

@@ -1,5 +0,0 @@
-class AddOptionsToTemplateInput < ActiveRecord::Migration[4.2]
-  def change
-    add_column :template_inputs, :options, :text
-  end
-end

data/db/migrate/20160127134031_add_advanced_to_template_input.rb

@@ -1,11 +0,0 @@
-class AddAdvancedToTemplateInput < ActiveRecord::Migration[4.2]
-  def up
-    add_column :template_inputs, :advanced, :boolean, :default => false, :null => false
-    template = JobTemplate.find_by(name: 'Package Action - SSH Default')
-    TemplateInput.where(:name => ['pre_script', 'post_script'], :template_id => template.try(:id)).update_all(:advanced => true)
-  end
-
-  def down
-    remove_column :template_inputs, :advanced
-  end
-end

data/test/functional/api/v2/template_inputs_controller_test.rb

@@ -1,56 +0,0 @@
-require 'test_plugin_helper'
-
-module Api
-  module V2
-    class TemplateInputsControllerTest < ActionController::TestCase
-      setup do
-        @template = FactoryBot.create(:job_template, :with_input)
-        @input = @template.template_inputs.first
-      end
-
-      test 'should get index' do
-        get :index, params: { :template_id => @template.id }
-        inputs = ActiveSupport::JSON.decode(@response.body)
-        assert !inputs.empty?, 'Should respond with inputs'
-        assert_response :success
-      end
-
-      test 'should get input detail' do
-        get :show, params: { :template_id => @template.to_param, :id => @input.to_param }
-        assert_response :success
-        input = ActiveSupport::JSON.decode(@response.body)
-        assert !input.empty?
-        assert_equal input['name'], @input.name
-      end
-
-      test 'should create valid' do
-        valid_attrs = { :name => 'is_potato', :input_type => 'user', :options => ['true', 'false'] }
-        post :create, params: { :template_input => valid_attrs, :template_id => @template.to_param }
-        input = ActiveSupport::JSON.decode(@response.body)
-        assert input['name'] == 'is_potato'
-        assert_response :success
-      end
-
-      test 'should not create invalid' do
-        post :create, params: { :template_id => @template.to_param }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should update valid' do
-        put :update, params: { :template_id => @template.to_param, :id => @input.to_param, :template_input => { :name => 'blah' } }
-        assert_response :ok
-      end
-
-      test 'should not update invalid' do
-        put :update, params: { :template_id => @template.to_param, :id => @input.to_param, :template_input => { :name => '' } }
-        assert_response :unprocessable_entity
-      end
-
-      test 'should destroy' do
-        delete :destroy, params: { :template_id => @template.to_param, :id => @input.to_param }
-        assert_response :ok
-        refute TemplateInput.exists?(@input.id)
-      end
-    end
-  end
-end