foreman_puppet 0.0.1

data/app/controllers/concerns/foreman_puppet/extensions/parameters_template_combination.rb

@@ -0,0 +1,21 @@
+module ForemanPuppet
+  module Extensions
+    module ParametersTemplateCombination
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          prepend PrependedClassMethods
+        end
+      end
+
+      module PrependedClassMethods
+        def template_combination_params_filter
+          super.tap do |filter|
+            filter.permit_by_context :environment_id, :environment_name, :environment, nested: true
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/parameters/config_group.rb

@@ -0,0 +1,17 @@
+module ForemanPuppet::Parameters::ConfigGroup
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def config_group_params_filter
+      Foreman::ParameterFilter.new(ForemanPuppet::ConfigGroup).tap do |filter|
+        filter.permit :name,
+          class_environments: [],
+          puppetclass_ids: [], puppetclass_names: []
+      end
+    end
+  end
+
+  def config_group_params
+    self.class.config_group_params_filter.filter_params(params, parameter_filter_context)
+  end
+end

data/app/controllers/concerns/foreman_puppet/parameters/environment.rb

@@ -0,0 +1,21 @@
+module ForemanPuppet
+  module Parameters
+    module Environment
+      extend ActiveSupport::Concern
+      include Foreman::Controller::Parameters::Taxonomix
+
+      class_methods do
+        def environment_params_filter
+          Foreman::ParameterFilter.new(ForemanPuppet::Environment).tap do |filter|
+            filter.permit :name
+            add_taxonomix_params_filter(filter)
+          end
+        end
+      end
+
+      def environment_params
+        self.class.environment_params_filter.filter_params(params, parameter_filter_context)
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/parameters/puppetclass.rb

@@ -0,0 +1,24 @@
+module ForemanPuppet
+  module Parameters
+    module Puppetclass
+      extend ActiveSupport::Concern
+      include Parameters::PuppetclassLookupKey
+
+      class_methods do
+        def puppetclass_params_filter
+          Foreman::ParameterFilter.new(ForemanPuppet::Puppetclass).tap do |filter|
+            filter.permit :name,
+              class_params_attributes: [puppetclass_lookup_key_params_filter],
+              hostgroup_ids: [], hostgroup_names: [],
+              smart_class_parameters: [puppetclass_lookup_key_params_filter],
+              smart_class_parameter_ids: [], smart_class_parameter_names: []
+          end
+        end
+      end
+
+      def puppetclass_params
+        self.class.puppetclass_params_filter.filter_params(params, parameter_filter_context)
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_puppet/parameters/puppetclass_lookup_key.rb

@@ -0,0 +1,24 @@
+module ForemanPuppet
+  module Parameters::PuppetclassLookupKey
+    extend ActiveSupport::Concern
+    include Foreman::Controller::Parameters::LookupKey
+
+    class_methods do
+      def puppetclass_lookup_key_params_filter
+        Foreman::ParameterFilter.new(ForemanPuppet::PuppetclassLookupKey).tap do |filter|
+          filter.permit environments: [], environment_ids: [], environment_names: [],
+                        environment_classes: [], environment_classes_ids: [], environment_classes_names: [],
+                        param_classes: [], param_classes_ids: [], param_classes_names: []
+          filter.permit_by_context :required, nested: true
+          filter.permit_by_context :id, ui: false, api: false, nested: true
+
+          add_lookup_key_params_filter(filter)
+        end
+      end
+    end
+
+    def puppetclass_lookup_key_params
+      self.class.puppetclass_lookup_key_params_filter.filter_params(params, parameter_filter_context)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class BaseController < ::Api::V2::BaseController
+        resource_description do
+          api_version '2'
+          api_base_url '/foreman_puppet/api'
+        end
+
+        before_action :show_deprecation_for_core_routes
+
+        protected
+
+        def show_deprecation_for_core_routes
+          return if request.path.starts_with?('/foreman_puppet')
+          Foreman::Deprecation.api_deprecation_warning(
+            format(
+              '/api/v2/%{controller} API endpoints are deprecated, please use /foreman_puppet/api/v2/%{controller} instead',
+              controller: controller_name
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class ConfigGroupsController < BaseController
+        include ForemanPuppet::Parameters::ConfigGroup
+
+        wrap_parameters ConfigGroup, include: config_group_params_filter.accessible_attributes(parameter_filter_context)
+
+        before_action :find_resource, only: %i[show update destroy]
+
+        api :GET, '/config_groups', N_('List of config groups')
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(ConfigGroup)
+
+        def index
+          @config_groups = resource_scope_for_index
+        end
+
+        api :GET, '/config_groups/:id/', N_('Show a config group')
+        param :id, :identifier, required: true
+
+        def show
+        end
+
+        def_param_group :config_group do
+          param :config_group, Hash, required: true, action_aware: true do
+            param :name, String, required: true
+            param :puppetclass_ids, Array
+          end
+        end
+
+        api :POST, '/config_groups/', N_('Create a config group')
+        param_group :config_group, as: :create
+
+        def create
+          @config_group = ConfigGroup.new(config_group_params)
+          process_response @config_group.save
+        end
+
+        api :PUT, '/config_groups/:id/', N_('Update a config group')
+        param :id, String, required: true
+        param_group :config_group
+
+        def update
+          process_response @config_group.update(config_group_params)
+        end
+
+        api :DELETE, '/config_groups/:id/', N_('Delete a config group')
+        param :id, String, required: true
+
+        def destroy
+          process_response @config_group.destroy
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class EnvironmentsController < BaseController
+        include ForemanPuppet::Api::ImportPuppetclassesCommonController
+        include ForemanPuppet::Parameters::Environment
+
+        resource_description do
+          api_version '2'
+          api_base_url '/foreman_puppet/api'
+        end
+
+        before_action :find_optional_nested_object
+        before_action :find_resource, only: %w[show update destroy]
+
+        api :GET, '/environments/', N_('List all environments')
+        api :GET, '/puppetclasses/:puppetclass_id/environments', N_('List environments of Puppet class')
+        api :GET, '/locations/:location_id/environments', N_('List environments per location')
+        api :GET, '/organizations/:organization_id/environments', N_('List environments per organization')
+        param :puppetclass_id, String, desc: N_('ID of Puppet class')
+        param_group :taxonomy_scope, ::Api::V2::BaseController
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(Environment)
+
+        def index
+          @environments = resource_scope_for_index
+        end
+
+        api :GET, '/environments/:id/', N_('Show an environment')
+        param :id, :identifier, required: true
+
+        def show
+        end
+
+        def_param_group :environment do
+          param :environment, Hash, required: true, action_aware: true do
+            param :name, String, required: true
+            param_group :taxonomies, ::Api::V2::BaseController
+          end
+        end
+
+        api :POST, '/environments/', N_('Create an environment')
+        param_group :environment, as: :create
+
+        def create
+          @environment = Environment.new(environment_params)
+          process_response @environment.save
+        end
+
+        api :PUT, '/environments/:id/', N_('Update an environment')
+        param :id, :identifier, required: true
+        param_group :environment
+
+        def update
+          process_response @environment.update(environment_params)
+        end
+
+        api :DELETE, '/environments/:id/', N_('Delete an environment')
+        param :id, :identifier, required: true
+
+        def destroy
+          process_response @environment.destroy
+        end
+
+        private
+
+        def action_permission
+          case params[:action]
+          when 'import_puppetclasses'
+            :import_puppetclasses
+          else
+            super
+          end
+        end
+
+        def parent_permission(child_permission)
+          case child_permission.to_s
+          when 'import_puppetclasses'
+            :view
+          else
+            super
+          end
+        end
+
+        def allowed_nested_id
+          %w[puppetclass_id location_id organization_id]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class HostClassesController < V2::BaseController
+        before_action :find_host, only: %i[index create destroy]
+        before_action :find_puppetclass, only: %i[create destroy]
+
+        api :GET, '/hosts/:host_id/puppetclass_ids/', N_('List all Puppet class IDs for host')
+
+        def index
+          render json: { root_node_name => HostClass.authorized(:edit_classes).where(host_puppet_facet_id: @host.puppet.id).pluck('puppetclass_id') }
+        end
+
+        api :POST, '/hosts/:host_id/puppetclass_ids', N_('Add a Puppet class to host')
+        param :host_id, String, required: true, desc: N_('ID of host')
+        param :puppetclass_id, String, required: true, desc: N_('ID of Puppet class')
+
+        def create
+          @host_class = HostClass.create!(host_puppet_facet_id: @host.puppet.id, puppetclass_id: @puppetclass.id)
+          render json: { host_id: @host.id, puppetclass_id: @host_class.puppetclass_id }
+        end
+
+        api :DELETE, '/hosts/:host_id/puppetclass_ids/:id/', N_('Remove a Puppet class from host')
+        param :host_id, String, required: true, desc: N_('ID of host')
+        param :id, String, required: true, desc: N_('ID of Puppet class')
+
+        def destroy
+          @host_class = HostClass.authorized(:edit_classes).where(host_puppet_facet_id: @host.puppet.id, puppetclass_id: @puppetclass.id)
+          process_response @host_class.destroy_all
+        end
+
+        private
+
+        # overwrite resource_name so it's host and and not host_class, since we want to return @host
+        def find_host
+          if params[:host_id].blank?
+            not_found
+            return false
+          end
+          if ::Host::Managed.respond_to?(:authorized) &&
+             ::Host::Managed.authorized('view_host', Host::Managed)
+            @host = resource_finder(::Host.authorized(:view_hosts), params[:host_id])
+            @host.puppet || @host.create_puppet
+            @host
+          end
+        end
+
+        def find_puppetclass
+          puppetclass_id = if params[:action] == 'create'
+                             params[:puppetclass_id]
+                           else
+                             params[:id]
+                           end
+          @puppetclass = resource_finder(Puppetclass.authorized(:view_puppetclasses), puppetclass_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class HostgroupClassesController < V2::BaseController
+        before_action :find_hostgroup, only: %i[index create destroy]
+
+        api :GET, '/hostgroups/:hostgroup_id/puppetclass_ids/', N_('List all Puppet class IDs for host group')
+
+        def index
+          render json: { root_node_name => HostgroupClass.where(hostgroup_puppet_facet_id: @hostgroup.puppet.id).pluck('puppetclass_id') }
+        end
+
+        api :POST, '/hostgroups/:hostgroup_id/puppetclass_ids', N_('Add a Puppet class to host group')
+        param :hostgroup_id, String, required: true, desc: N_('ID of host group')
+        param :puppetclass_id, String, required: true, desc: N_('ID of Puppet class')
+
+        def create
+          @hostgroup_class = HostgroupClass.create!(hostgroup_puppet_facet_id: @hostgroup.puppet.id, puppetclass_id: params[:puppetclass_id].to_i)
+          render json: { hostgroup_id: @hostgroup_class.hostgroup_id, puppetclass_id: @hostgroup_class.puppetclass_id }
+        end
+
+        api :DELETE, '/hostgroups/:hostgroup_id/puppetclass_ids/:id/', N_('Remove a Puppet class from host group')
+        param :hostgroup_id, String, required: true, desc: N_('ID of host group')
+        param :id, String, required: true, desc: N_('ID of Puppet class')
+
+        def destroy
+          @hostgroup_class = HostgroupClass.where(hostgroup_puppet_facet_id: @hostgroup.puppet.id, puppetclass_id: params[:id])
+          process_response @hostgroup_class.destroy_all
+        end
+
+        private
+
+        def find_hostgroup
+          if params[:hostgroup_id].blank?
+            not_found
+            return false
+          end
+          @hostgroup = Hostgroup.find(params[:hostgroup_id]) if Hostgroup.respond_to?(:authorized) &&
+                                                                Hostgroup.authorized('view_hostgroup', Hostgroup)
+          @hostgroup.puppet || @hostgroup.create_puppet
+          @hostgroup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module ForemanPuppet
+  module Api
+    module V2
+      class LookupsCommonController < ::Api::V2::BaseController
+        before_action :find_environment, if: :environment_id?
+        before_action :find_puppetclass, if: :puppetclass_id?
+        before_action :find_host, if: :host_id?
+        before_action :find_hostgroup, if: :hostgroup_id?
+
+        before_action :find_smart_class_parameters
+        before_action :find_smart_class_parameter
+        before_action :return_if_smart_mismatch, only: %i[show update destroy]
+        before_action :cast_default_value, only: %i[create update]
+
+        def show
+        end
+
+        def create
+        end
+
+        def update
+        end
+
+        def destroy
+        end
+
+        ['ForemanPuppet::Puppetclass', 'ForemanPuppet::Environment', 'Host::Base', 'Hostgroup'].each do |klass|
+          model_string = klass.split('::').last.downcase
+          model_string = 'host' if klass == 'Host::Base'
+
+          define_method("#{model_string}_id?") do
+            params.key?("#{model_string}_id")
+          end
+
+          define_method("find_#{model_string}") do
+            scope = klass.constantize.authorized(:"view_#{model_string.pluralize}")
+            begin
+              instance_variable_set("@#{model_string}",
+                resource_finder(scope, params["#{model_string}_id"]))
+            rescue ActiveRecord::RecordNotFound
+              model_not_found(model_string)
+            end
+          end
+        end
+
+        def find_smart_class_parameter
+          id = params.key?('smart_class_parameter_id') ? params['smart_class_parameter_id'] : params['id']
+          @smart_class_parameter = PuppetclassLookupKey.authorized(:view_external_parameters).smart_class_parameters.find_by(id: id.to_i) if id.to_i > 0
+          @smart_class_parameter ||= begin
+            puppet_cond = { 'environment_classes.puppetclass_id' => @puppetclass.id } if @puppetclass
+            env_cond = { 'environment_classes.environment_id' => @environment.id } if @environment
+            PuppetclassLookupKey.authorized(:view_external_parameters).smart_class_parameters.where(puppet_cond).where(env_cond).where(key: id).first
+          end
+          @smart_class_parameter
+        end
+
+        def find_smart_class_parameters
+          @smart_class_parameters = smart_class_parameters_resource_scope.search_for(*search_options).paginate(paginate_options)
+        end
+
+        def smart_class_parameters_resource_scope
+          base = PuppetclassLookupKey.authorized(:view_external_parameters)
+          params = if !@puppetclass && !@environment && !@host && !@hostgroup
+                     base.smart_class_parameters
+                   elsif @puppetclass && @environment
+                     base.smart_class_parameters_for_class(@puppetclass.id, @environment.id)
+                   elsif @puppetclass && !@environment
+                     environment_ids = @puppetclass.environment_classes.pluck(:environment_id).uniq
+                     base.smart_class_parameters_for_class(@puppetclass.id, environment_ids)
+                   elsif !@puppetclass && @environment
+                     puppetclass_ids = @environment.environment_classes.pluck(:puppetclass_id).uniq
+                     base.smart_class_parameters_for_class(puppetclass_ids, @environment.id)
+                   elsif @host || @hostgroup
+                     puppet_facet = (@host || @hostgroup).puppet || (@host || @hostgroup).build_puppet
+                     puppetclass_ids = puppet_facet.all_puppetclasses.map(&:id)
+                     environment_id  = puppet_facet.environment_id
+                     # scope :parameters_for_class uses .override
+                     base.parameters_for_class(puppetclass_ids, environment_id)
+                   end
+          params.distinct
+        end
+
+        def return_if_smart_mismatch
+          return unless @smart_class_parameters && (!smart_param_exists? || !@smart_class_parameter)
+          id = params.key?('smart_class_parameter_id') ? params['smart_variable_id'] : params['id']
+          not_found "Smart class parameter not found by id '#{id}''"
+        end
+
+        def cast_default_value
+          cast_value(:smart_class_parameter, :default_value)
+        end
+
+        def cast_value(obj = :override_value, value = :value)
+          return unless params[obj]&.key?(value)
+          param_value = params[obj][value]
+          return if param_value.is_a?(Hash)
+          params[obj][value] = param_value.to_s
+        end
+
+        private
+
+        def smart_param_exists?
+          @smart_class_parameter && @smart_class_parameters.find_by(id: @smart_class_parameter.id)
+        end
+
+        def model_not_found(model)
+          error_message =
+            format(_("%{model} with id '%{id}' was not found"), id: params["#{model}_id"], model: model.capitalize)
+          not_found(error: { message: error_message })
+        end
+      end
+    end
+  end
+end