foreman_puppet 0.0.1

data/app/helpers/foreman_puppet/puppetclasses_helper.rb

@@ -0,0 +1,59 @@
+module ForemanPuppet
+  module PuppetclassesHelper
+    include PuppetclassesAndEnvironmentsHelper
+    include LookupKeysHelper
+
+    def overridden?(puppetclass)
+      puppetclass.class_params.present? && puppetclass.class_params.map(&:override).all?
+    end
+
+    def puppetclass_in_environment?(environment, puppetclass)
+      return false unless environment
+      environment.puppetclasses.map(&:id).include?(puppetclass.id)
+    end
+
+    def puppetclass_group_with_icon(list, selected)
+      css_options = if (list.last - selected).empty?
+                      { class: 'hide' }
+                    else
+                      {}
+                    end
+      link_to_function(icon_text('plus', list.first, css_options),
+        "tfm.classEditor.expandClassList(this, '#pc_#{list.first}')")
+    end
+
+    def link_to_remove_puppetclass(klass, type)
+      options = options_for_puppetclass_selection(klass, type)
+      text = link_to_remove_function(truncate(klass.name, length: 28), options)
+      tag.span(text) + link_to_remove_function('', options.merge(class: 'glyphicon glyphicon-minus-sign'))
+    end
+
+    def link_to_remove_function(text, options)
+      options.delete_if { |key, _value| !options[key].to_s } # otherwise error during template render
+      title = (_('Click to remove %s') % options[:"data-class-name"])
+      link_to_function(text, 'tfm.classEditor.removePuppetClass(this)', options.merge!('data-original-title': title))
+    end
+
+    def link_to_add_puppetclass(klass, type)
+      options = options_for_puppetclass_selection(klass, type)
+      text = link_to_add_function(truncate(klass.name, length: 28), options)
+      tag.span(text) +
+        link_to_add_function('', options.merge(class: 'glyphicon glyphicon-plus-sign'))
+    end
+
+    def link_to_add_function(text, options)
+      link_to_function(text, 'tfm.classEditor.addPuppetClass(this)',
+        options.merge('data-original-title': _('Click to add %s') % options[:"data-class-name"]))
+    end
+
+    def options_for_puppetclass_selection(klass, type)
+      {
+        'data-class-id': klass.id,
+        'data-class-name': klass.name,
+        'data-type': type,
+        'data-url': foreman_puppet.parameters_puppetclass_path(id: klass.id),
+        rel: 'twipsy',
+      }
+    end
+  end
+end

data/app/helpers/foreman_puppet/template_combinations_helper.rb

@@ -0,0 +1,33 @@
+module ForemanPuppet
+  module TemplateCombinationsHelper
+    def combination(template)
+      template.template_combinations.map do |comb|
+        str = []
+        str << (comb.hostgroup_id.nil? ? _('None') : comb.hostgroup.to_s)
+        str << (comb.environment_id.nil? ? _('None') : comb.environment.to_s)
+        str.join(' / ')
+      end.to_sentence
+    end
+
+    def how_templates_are_determined
+      text = ['<p>']
+      text << _("When editing a template, you must assign a list \
+  of operating systems which this template can be used with. Optionally, you can \
+  restrict a template to a list of host groups and/or environments.")
+      text << '</p><p>'
+      text << _("When a Host requests a template (e.g. during provisioning), Foreman \
+  will select the best match from the available templates of that type, in the \
+  following order:")
+      text << '</p><ul>'
+      text << "<li>#{_('Host group and Environment')}</li>"
+      text << "<li>#{_('Host group only')}</li>"
+      text << "<li>#{_('Environment only')}</li>"
+      text << "<li>#{_('Operating system default')}</li>"
+      text << '</ul>'
+      text << tag.p(_('The final entry, Operating System default, can be set by editing the %s page.') %
+                (link_to _('Operating System'), main_app.operatingsystems_path))
+
+      alert(class: 'alert-info', header: 'How templates are determined', text: safe_join(text))
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/host.rb

@@ -0,0 +1,88 @@
+module ForemanPuppet
+  module Extensions
+    module Host
+      extend ActiveSupport::Concern
+
+      included do
+        prepend PrependedMethods
+
+        env_assoc = reflect_on_association(:environment)
+        env_assoc&.instance_variable_set(:@class_name, 'ForemanPuppet::Environment')
+
+        include_in_clone puppet: %i[config_groups host_config_groups host_classes]
+
+        scoped_search relation: :environment, on: :name, complete_value: true, rename: :environment
+        scoped_search relation: :puppetclasses, on: :name, complete_value: true, rename: :class, only_explicit: true, operators: ['= ', '~ '],
+                      ext_method: :search_by_deprecated_class
+        scoped_search relation: :puppetclasses, on: :name, complete_value: true, rename: :puppetclass, only_explicit: true, operators: ['= ', '~ '],
+                      ext_method: :search_by_puppetclass
+        scoped_search relation: :config_groups, on: :name, complete_value: true, rename: :config_group, only_explicit: true, operators: ['= ', '~ '],
+                      ext_method: :search_by_config_group
+      end
+
+      class_methods do
+        def search_by_deprecated_class(key, operator, value)
+          Foreman::Deprecation.deprecation_warning('3.2', 'search by `class` has been deprecated, please search by `puppetclass` instead')
+          search_by_puppetclass(key, operator, value)
+        end
+
+        def search_by_puppetclass(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["puppetclasses.name #{operator} ?", value_to_sql(operator, value)])
+          config_group_ids = ForemanPuppet::ConfigGroup.joins(:puppetclasses).where(conditions).pluck(:id)
+          host_ids         = ::Host.authorized(:view_hosts, Host).joins(puppet: :puppetclasses).where(conditions).distinct.pluck(:id)
+          host_ids        += ForemanPuppet::HostConfigGroup
+                             .where(host_type: 'ForemanPuppet::HostPuppetFacet')
+                             .where(config_group_id: config_group_ids)
+                             .pluck(:host_id)
+          hostgroup_ids = ::Hostgroup.unscoped.with_taxonomy_scope.joins(puppet: :puppetclasses).where(conditions).map(&:subtree_ids)
+          if config_group_ids.any?
+            hostgroup_cg_ids = ForemanPuppet::HostgroupPuppetFacet.joins(:host_config_groups)
+                                                                  .where(host_config_groups: { config_group_id: config_group_ids })
+                                                                  .pluck(:hostgroup_id)
+            hostgroup_ids += ::Hostgroup.unscoped.with_taxonomy_scope.where(id: hostgroup_cg_ids).map(&:subtree_ids)
+          end
+
+          conds = []
+          conds << "hosts.id IN(#{host_ids.join(',')})" if host_ids.present?
+          conds << "hosts.hostgroup_id IN(#{hostgroup_ids.uniq.join(',')})" if hostgroup_ids.present?
+          { conditions: conds.join(' OR ').presence || 'hosts.id < 0' }
+        end
+
+        def search_by_config_group(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["config_groups.name #{operator} ?", value_to_sql(operator, value)])
+          host_ids = ::Host::Managed.joins(puppet: :config_groups).where(conditions).pluck(:id).uniq
+          hostgroup_ids = ::Hostgroup.unscoped.with_taxonomy_scope.joins(puppet: :config_groups).where(conditions).distinct.map(&:subtree_ids).flatten.uniq
+
+          conds = []
+          conds << "hosts.id IN(#{host_ids.join(',')})" if host_ids.present?
+          conds << "hosts.hostgroup_id IN(#{hostgroup_ids.join(',')})" if hostgroup_ids.present?
+          { conditions: conds.join(' OR ').presence || 'hosts.id < 0' }
+        end
+      end
+
+      module PrependedMethods
+        def provisioning_template(opts = {})
+          opts[:environment_id] ||= puppet&.environment_id
+          super(opts)
+        end
+
+        def available_template_kinds(provisioning = nil)
+          kinds = template_kinds(provisioning)
+          kinds.map do |kind|
+            ProvisioningTemplate.find_template({ kind: kind.name,
+                                                 operatingsystem_id: operatingsystem_id,
+                                                 hostgroup_id: hostgroup_id,
+                                                 environment_id: puppet&.environment_id })
+          end.compact
+        end
+
+        # rubocop:disable Naming/MethodName
+        def importNode(nodeinfo)
+          facet = puppet || build_puppet
+          facet.import_puppet_node(nodeinfo)
+        end
+        # rubocop:enable Naming/MethodName
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/hostgroup.rb

@@ -0,0 +1,40 @@
+module ForemanPuppet
+  module Extensions
+    module Hostgroup
+      extend ActiveSupport::Concern
+
+      included do
+        class << self
+          prepend PatchedClassMethods
+        end
+
+        env_assoc = reflect_on_association(:environment)
+        env_assoc.instance_variable_set(:@class_name, 'ForemanPuppet::Environment')
+
+        include_in_clone puppet: %i[host_config_groups config_groups hostgroup_classes]
+
+        # will need through relation to work properly
+        scoped_search relation: :environment, on: :name, complete_value: true, rename: :environment, only_explicit: true
+        scoped_search relation: :puppetclasses, on: :name, complete_value: true, rename: :class, only_explicit: true, operators: ['= ', '~ ']
+        scoped_search relation: :config_groups, on: :name,
+                      complete_value: true,
+                      rename: :config_group,
+                      only_explicit: true,
+                      operators: ['= ', '~ '],
+                      ext_method: :search_by_config_group
+      end
+
+      # Temporary, can be ordinary class_methods do, when removed from core
+      module PatchedClassMethods
+        def search_by_config_group(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["config_groups.name #{operator} ?", value_to_sql(operator, value)])
+          hostgroup_ids = ::Hostgroup.unscoped.with_taxonomy_scope.joins(puppet: :config_groups).where(conditions).map(&:subtree_ids).flatten.uniq
+
+          opts = 'hostgroups.id < 0'
+          opts = "hostgroups.id IN(#{hostgroup_ids.join(',')})" if hostgroup_ids.present?
+          { conditions: opts }
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/nic_managed.rb

@@ -0,0 +1,11 @@
+module ForemanPuppet
+  module Extensions
+    module NicManaged
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :environment_id, to: :host
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/operatingsystem.rb

@@ -0,0 +1,11 @@
+module ForemanPuppet
+  module Extensions
+    module Operatingsystem
+      extend ActiveSupport::Concern
+
+      included do
+        has_and_belongs_to_many :puppetclasses
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/provisioning_template.rb

@@ -0,0 +1,64 @@
+module ForemanPuppet
+  module Extensions
+    module ProvisioningTemplate
+      extend ActiveSupport::Concern
+
+      included do
+        if ForemanPuppet.extracted_from_core?
+          has_many :environments, through: :template_combinations
+          before_destroy EnsureNotUsedBy.new(:environments)
+
+          scoped_search relation: :environments, on: :name, rename: :environment, complete_value: true
+
+          class << base
+            prepend PrependedClassMethods
+          end
+
+          prepend PrependedMethods
+        else
+          env_assoc = reflect_on_association(:environments)
+          env_assoc&.instance_variable_set(:@class_name, 'ForemanPuppet::Environment')
+        end
+      end
+
+      module PrependedClassMethods
+        def templates_by_template_combinations(templates, hosts_or_conditions)
+          if hosts_or_conditions.is_a?(Hash)
+            conditions = hosts_or_conditions
+            conditions[:hostgroup_id] = Array.wrap(conditions[:hostgroup_id]) | [nil]
+            conditions[:environment_id] = Array.wrap(conditions[:environment_id]) | [nil]
+          else
+            conditions = {}
+            conditions[:hostgroup_id] = hosts_or_conditions.pluck(:hostgroup_id) | [nil]
+            conditions[:environment_id] = hosts_or_conditions.pluck(:environment_id) | [nil]
+          end
+          at = TemplateCombination.arel_table
+          arel = at[:hostgroup_id].in(conditions[:hostgroup_id])
+          arel = arel.and(at[:environment_id].in(conditions[:environment_id]))
+          templates.joins(:template_combinations).where(arel).distinct
+        end
+
+        def template_includes
+          includes = super
+          tc_include = includes.detect { |i| i.key?(:template_combinations) }
+          tc_include ||= includes << {}
+          tc_include[:template_combinations] = %i[hostgroup environment]
+          includes
+        end
+      end
+
+      module PrependedMethods
+        def reject_template_combination_attributes?(params)
+          params[:environment_id].blank? && super(params)
+        end
+
+        # check if our template is a snippet, and remove its associations just in case they were selected.
+        def check_for_snippet_assoications
+          super
+          return unless snippet
+          environments.clear
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/report.rb

@@ -0,0 +1,11 @@
+module ForemanPuppet
+  module Extensions
+    module Report
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :environment, through: :host
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/taxonomy.rb

@@ -0,0 +1,19 @@
+module ForemanPuppet
+  module Extensions
+    module Taxonomy
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :environments, through: :taxable_taxonomies, source: :taxable, source_type: 'ForemanPuppet::Environment'
+
+        has_many :puppetclasses, through: :environments
+      end
+
+      def dup
+        new = super
+        new.environments = environments
+        new
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/template_combination.rb

@@ -0,0 +1,23 @@
+module ForemanPuppet
+  module Extensions
+    module TemplateCombination
+      extend ActiveSupport::Concern
+
+      included do
+        if ForemanPuppet.extracted_from_core?
+          belongs_to :environment
+
+          validates :environment_id, uniqueness: { scope: %i[hostgroup_id provisioning_template_id] }
+
+          callback = __callbacks[:validate].detect do |v|
+            v.filter.is_a?(ActiveRecord::Validations::UniquenessValidator) && v.filter.attributes.include?(:hostgroup_id)
+          end
+          callback.filter.options[:scope] << :environment_id
+        else
+          env_assoc = reflect_on_association(:environment)
+          env_assoc&.instance_variable_set(:@class_name, 'ForemanPuppet::Environment')
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/extensions/user.rb

@@ -0,0 +1,22 @@
+module ForemanPuppet
+  module Extensions
+    module User
+      extend ActiveSupport::Concern
+
+      def visible_environments
+        authorized_scope = Environment.unscoped.authorized(:view_environments)
+        authorized_scope = authorized_scope
+                           .joins(:taxable_taxonomies)
+                           .where('taxable_taxonomies.taxonomy_id' => taxonomy_ids[:organizations] + taxonomy_ids[:locations])
+        result = authorized_scope.distinct.pluck(:name)
+        if User.current.admin?
+          # Admin users can also see Environments that do not have any organization or location, even when
+          # organizations and locations are enabled.
+          untaxed_environments = Environment.unscoped.where.not(id: TaxableTaxonomy.where(taxable_type: 'ForemanPuppet::Environment').distinct.select(:taxable_id)).pluck(:name)
+          result += untaxed_environments
+        end
+        result
+      end
+    end
+  end
+end

data/app/models/concerns/foreman_puppet/host_common.rb

@@ -0,0 +1,90 @@
+module ForemanPuppet
+  # Common methods between host and hostgroup
+  # mostly for template rendering consistency
+  module HostCommon
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :environment
+      has_many :host_config_groups, as: :host, dependent: :destroy
+      has_many :config_groups, through: :host_config_groups
+      has_many :config_group_classes, through: :config_groups
+      has_many :group_puppetclasses, through: :config_groups, source: :puppetclasses
+
+      alias_method :all_puppetclasses, :classes
+    end
+
+    def parent_name
+      if is_a?(ForemanPuppet::HostPuppetFacet)
+        host.hostgroup&.name
+      elsif is_a?(ForemanPuppet::HostgroupPuppetFacet)
+        hostgroup.parent&.name
+      end
+    end
+
+    def cg_class_ids
+      cg_ids = if is_a?(ForemanPuppet::HostgroupPuppetFacet)
+                 hostgroup.path.each.map { |hg| hg.puppet&.config_group_ids }.compact.flatten.uniq
+               else
+                 host.hostgroup ? host.hostgroup.path.each.map { |hg| hg.puppet&.config_group_ids }.compact.flatten.uniq : []
+               end
+      ForemanPuppet::ConfigGroupClass.where(config_group_id: (config_group_ids + cg_ids)).pluck(:puppetclass_id)
+    end
+
+    def hg_class_ids
+      hg_ids = if is_a?(HostgroupPuppetFacet)
+                 hostgroup.path_ids
+               elsif host.hostgroup
+                 host.hostgroup.path_ids
+               end
+      ForemanPuppet::HostgroupClass.joins(:hostgroup_puppet_facet)
+                                   .where(ForemanPuppet::HostgroupPuppetFacet.arel_table[:hostgroup_id].in(hg_ids))
+                                   .pluck(:puppetclass_id)
+    end
+
+    def host_class_ids
+      (is_a?(ForemanPuppet::HostPuppetFacet) ? host_classes : hostgroup_classes).map(&:puppetclass_id)
+    end
+
+    def all_puppetclass_ids
+      cg_class_ids + hg_class_ids + host_class_ids
+    end
+
+    def classes(env = environment)
+      conditions = { id: all_puppetclass_ids }
+      if env
+        env.puppetclasses.where(conditions)
+      else
+        ForemanPuppet::Puppetclass.where(conditions)
+      end
+    end
+
+    def puppetclass_ids
+      classes.reorder('').pluck('puppetclasses.id')
+    end
+
+    def classes_in_groups
+      conditions = { id: cg_class_ids }
+      if environment
+        environment.puppetclasses.where(conditions) - parent_classes
+      else
+        ForemanPuppet::Puppetclass.where(conditions) - parent_classes
+      end
+    end
+
+    # Returns Puppetclasses of a Host or Hostgroup
+    #
+    # It does not include Puppetclasses of it's ConfigGroupClasses
+    #
+    def individual_puppetclasses
+      ids = host_class_ids - cg_class_ids
+      return puppetclasses if ids.blank? && new_record?
+      ForemanPuppet::Puppetclass.includes(:environments).where(id: ids)
+    end
+
+    def available_puppetclasses
+      return ForemanPuppet::Puppetclass.all.authorized(:view_puppetclasses) if environment.blank?
+      environment.puppetclasses - parent_classes
+    end
+  end
+end