foreman_puppet 0.0.1

data/app/controllers/foreman_puppet/api/v2/override_values_controller.rb

@@ -0,0 +1,99 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class OverrideValuesController < LookupsCommonController
+        include Foreman::Controller::Parameters::LookupValue
+
+        resource_description do
+          api_version '2'
+          api_base_url '/foreman_puppet/api'
+        end
+
+        before_action :find_override_values
+        before_action :find_override_value, only: %i[show update destroy]
+        # override return_if_smart_mismatch in LookupKeysCommonController to add :create
+        before_action :return_if_smart_mismatch, only: %i[create show update destroy]
+        before_action :return_if_override_mismatch, only: %i[show update destroy]
+
+        before_action :cast_value, only: %i[create update]
+
+        api :GET, '/smart_class_parameters/:smart_class_parameter_id/override_values', N_('List of override values for a specific smart class parameter')
+        param :smart_class_parameter_id, :identifier, required: false
+        param :show_hidden, :bool, desc: N_('Display hidden values')
+        param_group :pagination, ::Api::V2::BaseController
+
+        def index
+        end
+
+        api :GET, '/smart_class_parameters/:smart_class_parameter_id/override_values/:id', N_('Show an override value for a specific smart class parameter')
+        param :smart_class_parameter_id, :identifier, required: false
+        param :id, :identifier, required: true
+        param :show_hidden, :bool, desc: N_('Display hidden values')
+
+        def show
+        end
+
+        def_param_group :override_value do
+          param :override_value, Hash, required: true, action_aware: true do
+            param :match, String, required: true, desc: N_('Override match')
+            param :value, :any_type, of: LookupKey::KEY_TYPES, required: false, desc: N_('Override value, required if omit is false')
+            param :omit, :bool, required: false, desc: N_('Foreman will not send this parameter in classification output')
+          end
+        end
+
+        api :POST, '/smart_class_parameters/:smart_class_parameter_id/override_values', N_('Create an override value for a specific smart class parameter')
+        param :smart_class_parameter_id, :identifier, required: false
+        param_group :override_value, as: :create
+
+        def create
+          @override_value = @smart_class_parameter.lookup_values.create!(lookup_value_params)
+          @smart_class_parameter.update(override: true)
+          process_response @override_value
+        end
+
+        api :PUT, '/smart_class_parameters/:smart_class_parameter_id/override_values/:id', N_('Update an override value for a specific smart class parameter')
+        param :smart_class_parameter_id, :identifier, required: false
+        param_group :override_value
+
+        def update
+          @override_value.update!(lookup_value_params)
+          render 'foreman_puppet/api/v2/override_values/show'
+        end
+
+        api :DELETE, '/smart_class_parameters/:smart_class_parameter_id/override_values/:id', N_('Delete an override value for a specific smart class parameter')
+        param :smart_class_parameter_id, :identifier, required: false
+        param :id, :identifier, required: true
+
+        def destroy
+          @override_value.destroy
+          render 'foreman_puppet/api/v2/override_values/show'
+        end
+
+        private
+
+        def find_override_values
+          return unless @smart_class_parameter
+
+          @override_values = @smart_class_parameter.lookup_values.paginate(paginate_options)
+          @total = @override_values.count
+        end
+
+        def find_override_value
+          @override_value = LookupValue.find_by(id: params[:id])
+          @override_value ||= @smart_class_parameter.lookup_values.friendly.find(params[:id]) if @smart_class_parameter
+        end
+
+        def return_if_override_mismatch
+          return unless (@override_values && @override_value && !@override_values.find_by(id: @override_value.id)) || (@override_values && !@override_value) || !@override_values
+
+          not_found "Override value not found by id '#{params[:id]}'"
+        end
+
+        # overwrite Api::BaseController
+        def resource_class
+          LookupValue
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_puppet/api/v2/puppetclasses_controller.rb

@@ -0,0 +1,99 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class PuppetclassesController < BaseController
+        include ForemanPuppet::Parameters::Puppetclass
+
+        before_action :find_optional_nested_object
+        before_action :find_resource, only: %w[show update destroy]
+
+        api :GET, '/puppetclasses/', N_('List all Puppet classes')
+        api :GET, '/hosts/:host_id/puppetclasses', N_('List all Puppet classes for a host')
+        api :GET, '/hostgroups/:hostgroup_id/puppetclasses', N_('List all Puppet classes for a host group')
+        api :GET, '/environments/:environment_id/puppetclasses', N_('List all Puppet classes for an environment')
+        param :host_id, String, desc: N_('ID of host')
+        param :hostgroup_id, String, desc: N_('ID of host group')
+        param :environment_id, String, desc: N_('ID of environment')
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(Puppetclass)
+
+        def index
+          values   = Puppetclass.authorized(:view_puppetclasses).search_for(*search_options) unless nested_obj
+          values ||= case nested_obj
+                     when Host::Base, Hostgroup
+                       # NOTE: no search_for on array generated by all_puppetclasses
+                       nested_obj.puppet.all_puppetclasses
+                     else
+                       nested_obj.puppetclasses.search_for(*search_options)
+                     end
+          @total   = Puppetclass.count unless nested_obj
+          @total ||= case nested_obj
+                     when Host::Base, Hostgroup
+                       values.count
+                     else
+                       nested_obj.puppetclasses.count
+                     end
+          @subtotal = values.count
+          if params[:style] == 'list'
+            @puppetclasses = values
+            render :list
+          else
+            @puppetclasses = Puppetclass.classes2hash_v2(values.paginate(paginate_options))
+          end
+        end
+
+        api :GET, '/puppetclasses/:id', N_('Show a Puppet class')
+        api :GET, '/hosts/:host_id/puppetclasses/:id', N_('Show a Puppet class for host')
+        api :GET, '/hostgroups/:hostgroup_id/puppetclasses/:id', N_('Show a Puppet class for a host group')
+        api :GET, '/environments/:environment_id/puppetclasses/:id', N_('Show a Puppet class for an environment')
+        param :host_id, String, desc: N_('ID of host')
+        param :hostgroup_id, String, desc: N_('ID of host group')
+        param :environment_id, String, desc: N_('ID of environment')
+        param :id, String, required: true, desc: N_('ID of Puppet class')
+
+        def show
+        end
+
+        def_param_group :puppetclass do
+          param :puppetclass, Hash, required: true, action_aware: true do
+            param :name, String, required: true
+          end
+        end
+
+        api :POST, '/puppetclasses/', N_('Create a Puppet class')
+        param_group :puppetclass, as: :create
+
+        def create
+          @puppetclass = Puppetclass.new(puppetclass_params)
+          process_response @puppetclass.save
+        end
+
+        api :PUT, '/puppetclasses/:id/', N_('Update a Puppet class')
+        param :id, String, required: true
+        param_group :puppetclass
+
+        def update
+          class_params = puppetclass_params.merge(smart_class_parameter_ids: @puppetclass.smart_class_parameters.map(&:id))
+          process_response @puppetclass.update(class_params)
+        end
+
+        api :DELETE, '/puppetclasses/:id/', N_('Delete a Puppet class')
+        param :id, String, required: true
+
+        def destroy
+          process_response @puppetclass.destroy
+        end
+
+        def resource_class
+          ForemanPuppet::Puppetclass
+        end
+
+        private
+
+        def allowed_nested_id
+          %w[environment_id host_id hostgroup_id]
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_puppet/api/v2/smart_class_parameters_controller.rb

@@ -0,0 +1,76 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class SmartClassParametersController < ForemanPuppet::Api::V2::LookupsCommonController
+        include ForemanPuppet::Parameters::PuppetclassLookupKey
+
+        resource_description do
+          api_version '2'
+          api_base_url '/foreman_puppet/api'
+        end
+
+        alias_method :resource_scope, :smart_class_parameters_resource_scope
+
+        api :GET, '/smart_class_parameters', N_('List all smart class parameters')
+        api :GET, '/hosts/:host_id/smart_class_parameters', N_('List of smart class parameters for a specific host')
+        api :GET, '/hostgroups/:hostgroup_id/smart_class_parameters', N_('List of smart class parameters for a specific host group')
+        api :GET, '/puppetclasses/:puppetclass_id/smart_class_parameters', N_('List of smart class parameters for a specific Puppet class')
+        api :GET, '/environments/:environment_id/smart_class_parameters', N_('List of smart class parameters for a specific environment')
+        api :GET, '/environments/:environment_id/puppetclasses/:puppetclass_id/smart_class_parameters',
+          N_('List of smart class parameters for a specific environment/Puppet class combination')
+        param :host_id, :identifier, required: false
+        param :hostgroup_id, :identifier, required: false
+        param :puppetclass_id, :identifier, required: false
+        param :environment_id, :identifier, required: false
+        param :show_hidden, :bool, desc: N_('Display hidden values')
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(PuppetclassLookupKey)
+
+        def index
+        end
+
+        # no create action for API
+        # smart class parameters are imported by PuppetClassImporter
+
+        api :GET, '/smart_class_parameters/:id/', N_('Show a smart class parameter')
+        param :id, :identifier, required: true
+        param :show_hidden, :bool, desc: N_('Display hidden values')
+
+        def show
+        end
+
+        api :PUT, '/smart_class_parameters/:id', N_('Update a smart class parameter')
+        param :id, :identifier, required: true
+        param :smart_class_parameter, Hash, required: true do
+          # can't update parameter/key name for :parameter, String, :required => true
+          param :override, :bool, desc: N_('Whether the smart class parameter value is managed by Foreman')
+          param :description, String, desc: N_('Description of smart class')
+          param :default_value, :any_type, of: LookupKey::KEY_TYPES, desc: N_('Value to use when there is no match')
+          param :hidden_value, :bool, desc: N_('When enabled the parameter is hidden in the UI')
+          param :omit, :bool, desc: N_('Foreman will not send this parameter in classification output.'\
+                                       'Puppet will use the value defined in the Puppet manifest for this parameter')
+          param :path, String, desc: N_('The order in which values are resolved')
+          param :validator_type, LookupKey::VALIDATOR_TYPES, desc: N_('Types of validation values')
+          param :validator_rule, String, desc: N_('Used to enforce certain values for the parameter values')
+          param :override_value_order, String, desc: N_('The order in which values are resolved')
+          param :parameter_type, LookupKey::KEY_TYPES, desc: N_('Types of variable values')
+          param :required, :bool, desc: N_('If true, will raise an error if there is no default value and no matcher provide a value')
+          param :merge_overrides, :bool, desc: N_('Merge all matching values (only array/hash type)')
+          param :merge_default, :bool, desc: N_('Include default value when merging all matching values')
+          param :avoid_duplicates, :bool, desc: N_('Remove duplicate values (only array type)')
+        end
+
+        def update
+          # NOTE:  User must manually set :override => true. It is not automatically updated if optional input validator fields are updated.
+          @smart_class_parameter.update!(puppetclass_lookup_key_params)
+          render 'foreman_puppet/api/v2/smart_class_parameters/show'
+        end
+
+        # overwrite Api::BaseController
+        def resource_class
+          LookupKey
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_puppet/config_groups_controller.rb

@@ -0,0 +1,46 @@
+module ForemanPuppet
+  class ConfigGroupsController < ::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanPuppet::Parameters::ConfigGroup
+
+    before_action :find_resource, only: %i[edit update destroy]
+
+    helper PuppetclassesHelper
+
+    def index
+      @config_groups = resource_base_search_and_page
+    end
+
+    def new
+      @config_group = ForemanPuppet::ConfigGroup.new
+    end
+
+    def edit
+    end
+
+    def create
+      @config_group = ForemanPuppet::ConfigGroup.new(config_group_params)
+      if @config_group.save
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def update
+      if @config_group.update(config_group_params)
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def destroy
+      if @config_group.destroy
+        process_success
+      else
+        process_error
+      end
+    end
+  end
+end

data/app/controllers/foreman_puppet/environments_controller.rb

@@ -0,0 +1,51 @@
+module ForemanPuppet
+  class EnvironmentsController < ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanPuppet::EnvironmentsImport
+    include ForemanPuppet::Parameters::Environment
+
+    before_action :find_resource, only: %i[edit update destroy]
+
+    def index
+      @environments = resource_base_search_and_page
+      # AuthorizerHelper#authorizer uses controller_name as variable name, but it fails with namespaces
+      @authorizer = Authorizer.new(User.current, collection: @environments)
+    end
+
+    def new
+      @environment = model_of_controller.new
+    end
+
+    def create
+      @environment = model_of_controller.new(environment_params)
+      if @environment.save
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      if @environment.update(environment_params)
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def destroy
+      if @environment.destroy
+        process_success
+      else
+        process_error
+      end
+    end
+
+    def resource_class
+      model_of_controller
+    end
+  end
+end

data/app/controllers/foreman_puppet/puppet_smart_proxies_controller.rb

@@ -0,0 +1,39 @@
+module ForemanPuppet
+  class PuppetSmartProxiesController < ApplicationController
+    before_action :find_resource
+    before_action :find_status, only: [:environments]
+
+    def environments
+      render partial: 'foreman_puppet/puppet_smart_proxies/environments', locals: { environments: @proxy_status[:puppet].environment_stats }
+    rescue Foreman::Exception => e
+      process_ajax_error e
+    end
+
+    def dashboard
+      @data = Dashboard::Data.new("puppet_proxy_id = \"#{@smart_proxy.id}\"")
+      render partial: 'foreman_puppet/puppet_smart_proxies/dashboard'
+    rescue Foreman::Exception => e
+      process_ajax_error e
+    end
+
+    private
+
+    def find_status
+      @proxy_status = @smart_proxy.statuses
+    end
+
+    def action_permission
+      case params[:action]
+      when 'environments', 'dashboard'
+        :view
+      else
+        super
+      end
+    end
+
+    def resource_name(resource = controller_name)
+      resource = 'smart_proxies' if resource == 'puppet_smart_proxies'
+      super(resource)
+    end
+  end
+end

data/app/controllers/foreman_puppet/puppetclass_lookup_keys_controller.rb

@@ -0,0 +1,33 @@
+module ForemanPuppet
+  class PuppetclassLookupKeysController < ::LookupKeysController
+    include Parameters::PuppetclassLookupKey
+
+    before_action :setup_search_options, only: :index
+
+    def index
+      @lookup_keys = resource_base_search_and_page.distinct.preload(:lookup_values)
+      environment_classes = EnvironmentClass.where(puppetclass_lookup_key_id: @lookup_keys.map(&:id)).select(:puppetclass_id, :puppetclass_lookup_key_id).distinct.preload(:puppetclass)
+      puppetclass_ids = environment_classes.map(&:puppetclass_id).uniq
+      @puppetclass_authorizer = Authorizer.new(User.current, collection: puppetclass_ids)
+      @lookup_keys_to_class = Hash[environment_classes.map { |environment_class| [environment_class.puppetclass_lookup_key_id, environment_class.puppetclass] }]
+    end
+
+    def resource_class
+      ForemanPuppet::PuppetclassLookupKey
+    end
+
+    private
+
+    def resource
+      @puppetclass_lookup_key
+    end
+
+    def controller_permission
+      'external_parameters'
+    end
+
+    def resource_params
+      puppetclass_lookup_key_params
+    end
+  end
+end