foreman_templates 5.0.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3889bfa2270632f8e0bfacc4a35a1a85c3eca1e6
-  data.tar.gz: 797795544b68cbb4b2d408e8293e6689d1e3ff02
+  metadata.gz: 756a604ec2486b327c246ae19a1c2b153c4217b7
+  data.tar.gz: 563b26321d12a2fad2b8d3f8f9202bcba689cf70
 SHA512:
-  metadata.gz: da4517d69b72c25c3065db6f0afba3621b6165c9c7a8e317a52e0a4c24a81b369fac520cc50ea102ea7accc8b9934452ef38b4a6e270e15d28c2a606e4105688
-  data.tar.gz: ae821ae58dedaaa29a83e41924b1ac30383c0d40e827c6d039397ac7bfd95f7923c94d418fcc1f89bcc59a020ae3b58b385db90bcb71353420384e8b31d4ba01
+  metadata.gz: 5cc02e60ced60af1126efed7dda4c89c167a8a59f8a009c3eb9c2fcd855d4f4c61cc4083d15c41993e4583f5fe367b5114c3fa38d9f44a388d8422385ca9f37b
+  data.tar.gz: 8638ebcf4335c45bf137ece2bd534a94e3f7dbc30040e4d5ee7c9c020c1258a159d10a769acc89a19c99174fe13d479d450181bf0d16cdad168fc07f6b280fd4

data/README.md

@@ -26,7 +26,7 @@ These can be overriden for each import by passing options directly to a Rake tas
 
 ## Usage
 
-### Import
+### Import via Rake task
 
 The plugin provides a Rake task to import the templates. To use it, simply do
 
@@ -49,6 +49,7 @@ template will be automatically associated with the OS
 * dirname   => The directory within the git tree containing the templates [/]
 * filter    => Import names matching this regex (case-insensitive; snippets are not filtered)
 * associate => Associate to OS, "always", when "new" or "never"  [new]
+* lock      => Lock imported templates [false]
 
 The `branch` default will use *develop* if you're on Foreman-nightly; or the
 matching *1.X-stable* branch for your version of Foreman (if it exists); or
@@ -102,6 +103,15 @@ Purge all templates that do not begin with 'Community '
 
     foreman-rake templates:purge negate=true
 
+### Import and Export via API
+
+There is an API (`/template/import/`) to initiate import from external
+repository. The API uses Foreman's authorization and authentication
+mechanisms. There is also an export action available.
+
+Unfortunately, there is no CLI support yet. For examples about how to
+use the API, [visit our documentation](https://theforeman.org/plugins/foreman_templates/5.0/index.html#5.API).
+
 ## Integration with other Foreman Plugins
 
 `templates` will start processing a template by looking for a metadata entry of
@@ -135,10 +145,6 @@ get written to a file in `/tmp`.
   * `:old` and `:new` (in which case this plugin will calculate the diff)
 * :result` (text, may be nil).
 
-## TODO
-
-* Add a button to the UI with Deface to run the rake task
-
 ## Copyright
 
 Copyright (c) 2013 Greg Sutcliffe

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

@@ -1,54 +1,37 @@
 module Api
   module V2
     class TemplateController < ::Api::V2::BaseController
-      api :POST, "/template/import/", N_("Initiate Import")
-      param :verbose, :bool, :required => false, :desc => N_("Set verbosity of import")
-      param :repo, String, :required => false, :desc => N_("Override the default repo from settings.")
-      param :branch, String, :required => false, :desc => N_("Branch in Git repo.")
+      include ::Foreman::Controller::Parameters::TemplateParams
+
+      def_param_group :foreman_template_sync_params do
+        param :branch, String, :required => false, :desc => N_("Branch in Git repo.")
+        param :repo, String, :required => false, :desc => N_("Override the default repo from settings.")
+        param :filter, String, :required => false, :desc => N_("Export templates with names matching this regex (case-insensitive; snippets are not filtered).")
+        param :negate, :bool, :required => false, :desc => N_("Negate the prefix (for purging).")
+        param :dirname, String, :required => false, :desc => N_("The directory within Git repo containing the templates")
+        param :verbose, :bool, :required => false, :desc => N_("Set verbosity of import")
+      end
+
+      api :POST, "/templates/import/", N_("Initiate Import")
       param :prefix, String, :required => false, :desc => N_("The string all imported templates should begin with.")
-      param :dirname, String, :required => false, :desc => N_("The directory within the git tree containing the templates.")
-      param :filter, String, :required => false, :desc => N_("Import templates with names matching this regex (case-insensitive; snippets are not filtered).")
-      param :negate, :bool, :required => false, :desc => N_("Negate the prefix (for purging).")
       param :associate, Setting::TemplateSync.associate_types.keys, :required => false, :desc => N_("Associate to OS's, Locations & Organizations. Options are: always, new or never.")
       param :force, :bool, :required => false, :desc => N_("Update templates that are locked")
-
+      param :lock, :bool, :required => false, :desc => N_("Lock imported templates")
+      param_group :foreman_template_sync_params
       def import
-        results = ForemanTemplates::TemplateImporter.new({
-          verbose:   params['verbose'],
-          repo:      params['repo'],
-          branch:    params['branch'],
-          prefix:    params['prefix'],
-          dirname:   params['dirname'],
-          filter:    params['filter'],
-          associate: params['associate'],
-          negate:    params['negate'],
-          force:     params['force']
-        }).import!
+        results = ForemanTemplates::TemplateImporter.new(template_import_params).import!
         render :json => { :message => results }
       end
 
-      api :POST, "/template/export", N_("Initiate Export")
-      param :verbose, :bool, :required => false, :desc => N_("Set verbosity of export")
-      param :repo, String, :required => false, :desc => N_("Override the default repo from settings")
-      param :branch, String, :required => false, :desc => N_("Branch in Git repo.")
-      param :filter, String, :required => false, :desc => N_("Export templates with names matching this regex (case-insensitive; snippets are not filtered).")
-      param :negate, :bool, :required => false, :desc => N_("Negate the prefix (for purging).")
+      api :POST, "/templates/export", N_("Initiate Export")
       param :metadata_export_mode, Setting::TemplateSync.metadata_export_mode_types.keys, :required => false, :desc => N_("Specify how to handle metadata")
-      param :dir, String, :required => false, :desc => N_("The directory within Git repo")
+      param_group :foreman_template_sync_params
       def export
-        ForemanTemplates::TemplateExporter.new({
-          verbose:              params['verbose'],
-          repo:                 params['repo'],
-          branch:               params['branch'],
-          filter:               params['filter'],
-          negate:               params['negate'],
-          metadata_export_mode: params['metadata_export_mode'],
-          dir:                  params['dir']
-        }).export!
+        ForemanTemplates::TemplateExporter.new(template_export_params).export!
         render :json => { :message => _('Success') }
-      rescue => e
+      rescue StandardError => e
         logger.debug e
-        render :json => { :message => (_('Something went wrong during export: %s') % e.message) }, :status => 500
+        render :json => { :message => (_('Something went wrong during export: %s') % e.message) }, :status => :internal_server_error
       end
     end
   end

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

@@ -0,0 +1,37 @@
+module Foreman
+  module Controller
+    module Parameters
+      module TemplateParams
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def filter_params_list
+            %i(verbose repo branch dirname filter negate metadata_export_mode dirname)
+          end
+
+          def extra_import_params
+            %i(associate force prefix lock)
+          end
+
+          def extra_export_params
+            [:metadata_export_mode]
+          end
+
+          def template_params_filter(extra_params = [])
+            Foreman::ParameterFilter.new(Hash).tap do |filter|
+              filter.permit filter_params_list.concat(extra_params)
+            end
+          end
+        end
+
+        def template_import_params
+          self.class.template_params_filter(self.class.extra_import_params).filter_params(params, parameter_filter_context, :none)
+        end
+
+        def template_export_params
+          self.class.template_params_filter(self.class.extra_export_params).filter_params(params, parameter_filter_context, :none)
+        end
+      end
+    end
+  end
+end

data/app/models/setting/template_sync.rb

@@ -19,20 +19,22 @@ class Setting
     def self.load_defaults
       return unless super
 
-      %w(template_sync_filter template_sync_branch).each { |s| Setting::BLANK_ATTRS << s }
+      %w(template_sync_filter template_sync_branch template_sync_prefix).each { |s| Setting::BLANK_ATTRS << s }
+      Setting::NOT_STRIPPED << 'template_sync_prefix'
 
       self.transaction do
         [
           self.set('template_sync_verbose', N_('Choose verbosity for Rake task importing templates'), false, N_('Verbosity')),
-          self.set('template_sync_associate', N_('Associate templates to OS'), 'new', N_('Associate'), nil, { :collection => Proc.new { self.associate_types } }),
-          self.set('template_sync_prefix', N_('The string all imported templates should begin with'), "Community ", N_('Prefix')),
+          self.set('template_sync_associate', N_('Associate templates to OS, organization and location'), 'new', N_('Associate'), nil, { :collection => Proc.new { self.associate_types } }),
+          self.set('template_sync_prefix', N_('The string all imported templates should begin with'), "", N_('Prefix')),
           self.set('template_sync_dirname', N_('The directory within the Git repo containing the templates'), '/', N_('Dirname')),
           self.set('template_sync_filter', N_('Import or export names matching this regex (case-insensitive; snippets are not filtered)'), nil, N_('Filter')),
-          self.set('template_sync_repo', N_('Default Git repo to sync from'), 'https://github.com/theforeman/community-templates.git', N_('Repo')),
+          self.set('template_sync_repo', N_('Target path to import and export. Different protocols can be used, e.g. /tmp/dir, git://example.com, https://example.com, ssh://example.com'), 'https://github.com/theforeman/community-templates.git', N_('Repo')),
           self.set('template_sync_negate', N_('Negate the prefix (for purging) / filter (for importing/exporting)'), false, N_('Negate')),
           self.set('template_sync_branch', N_('Default branch in Git repo'), nil, N_('Branch')),
           self.set('template_sync_metadata_export_mode', N_('Default metadata export mode, refresh re-renders metadata, keep will keep existing metadata, remove exports template withou metadata'), 'refresh', N_('Metadata export mode'), nil, { :collection => Proc.new { self.metadata_export_mode_types } }),
           self.set('template_sync_force', N_('Should importing overwrite locked templates?'), false, N_('Force import')),
+          self.set('template_sync_lock', N_('Should importing lock templates?'), false, N_('Lock templates')),
         ].compact.each { |s| self.create! s.update(:category => "Setting::TemplateSync") }
       end
 

data/app/services/foreman_templates/template_importer.rb

@@ -1,18 +1,16 @@
-class NoKindError < RuntimeError; end
-class MissingKindError < RuntimeError; end
-
 module ForemanTemplates
   class TemplateImporter < Action
     attr_accessor :metadata, :name, :text
 
     def self.setting_overrides
-      super + %i(associate force)
+      super + %i(associate force lock)
     end
 
     def initialize(args = {})
       super
       @verbose = parse_bool(@verbose)
       @force = parse_bool(@force)
+      @lock = parse_bool(@lock)
     end
 
     def import!
@@ -52,55 +50,59 @@ module ForemanTemplates
         text = File.read(template)
         result_lines << 'Parsing: ' + template.gsub(/#{@dir}#{@dirname}/, '') if @verbose
 
-        metadata = parse_metadata(text)
-        metadata['associate'] = @associate
+        metadata = Template.parse_metadata(text)
 
         # Get the name and filter
-        filename = template.split('/').last
-        title    = filename.split('.').first
-        name     = metadata['name'] || title
-        name     = auto_prefix(name)
+        name = metadata['name']
+        name = auto_prefix(name)
         if @filter
           matching = name.match(/#{@filter}/i)
           matching = !matching if @negate
-          next unless matching
+          unless matching
+            result_lines << "Skipping template '#{name}' since it's name is matching filter condition" if @verbose
+            next
+          end
         end
 
+        options = { :force => @force, :associate => @associate, :lock => @lock }
+        template_type = 'Unknown template type'
         begin
-          # Expects a return of { :diff, :status, :result, :errors }
-          data = if metadata['model'].present?
-                   metadata['model'].constantize.import!(name, text, metadata, @force)
-                 else
-                   # For backwards-compat before "model" metadata was added
-                   case metadata['kind']
-                   when 'ptable'
-                     Ptable.import!(name, text, metadata, @force)
-                   when 'job_template'
-                     # TODO: update REX templates to have `model` and delete this
-                     update_job_template(name, text)
-                   else
-                     ProvisioningTemplate.import!(name, text, metadata, @force)
-                   end
-                 end
-
-          if data[:diff].nil? && data[:old].present? && data[:new].present?
-            data[:diff] = calculate_diff(data[:old], data[:new])
+          if metadata.key?('model')
+            template_type = metadata['model'].constantize
+          else
+            result_lines << "Metadata for template '#{name}' do not specify 'model', import failed"
+            next
+          end
+
+          template = template_type.import_without_save(name, text, options)
+
+          data = {}
+          if template.template_changed?
+            data[:old] = template.template_was
+            data[:new] = template.template
+            if data[:diff].nil? && data[:old].present? && data[:new].present?
+              data[:diff] = calculate_diff(data[:old], data[:new])
+            end
           end
 
+          if options[:force]
+            template.ignore_locking { template.save! }
+          else
+            template.save!
+          end
+
+          template_type = template.class.model_name.human
+          data[:status] = template.errors.blank? ? "#{template_type} '#{name}' import successful" : "#{template_type} '#{name}' import failed"
+          data[:errors] = template.errors.full_messages
+
           if @verbose
-            result_lines << data[:result]
             result_lines << data[:diff] unless data[:diff].nil?
           end
-          result_lines << status_to_text(data[:status], name)
+          result_lines << data[:status]
           result_lines << data[:errors] unless data[:errors].empty?
-        rescue MissingKindError
-          result_lines << "  Skipping: '#{name}' - No template kind or model detected"
-          next
-        rescue NoKindError
-          result_lines << "  Skipping: '#{name}' - Unknown template kind '#{metadata['kind']}'"
-          next
-        rescue NameError
-          result_lines << "  Skipping: '#{name}' - Unknown template model '#{metadata['model']}'"
+        rescue => e
+          Foreman::Logging.exception 'error during template import', e, :level => :debug
+          result_lines << "#{template_type} '#{name}' import failed - #{e.message}"
           next
         end
       end
@@ -119,65 +121,19 @@ module ForemanTemplates
       end
     end
 
-    def parse_metadata(text)
-      # Pull out the first erb comment only - /m is for a multiline regex
-      extracted = text.match(/<%\#[\t a-z0-9=:]*(.+?).-?%>/m)
-      extracted.nil? ? {} : YAML.load(extracted[1])
-    end
-
-    def update_job_template(name, text)
-      file = name.gsub(/^#{@prefix}/, '')
-      puts 'Deprecation warning: JobTemplate support is moving to the Remote Execution plugin'
-      puts "- please add 'model: JobTemplate' to the metadata in '#{file}' to call the right method"
-
-      unless defined?(JobTemplate)
-        return {
-          :status => false,
-          :result => 'Skipping job template import, remote execution plugin is not installed.'
-        }
-      end
-      template = JobTemplate.import(
-        text.sub(/^name: .*$/, "name: #{name}"),
-        :update => true
-      )
-
-      c_or_u = template.new_record? ? 'Created' : 'Updated'
-      id_string = ('id' + template.id) rescue ''
-
-      if template.template != template.template_was
-        diff = Diffy::Diff.new(
-          template.template_was,
-          template.template,
-          :include_diff_info => true
-        ).to_s(:color)
-      end
-
-      result = "  #{c_or_u} Template #{id_string}:#{name}"
-      { :diff => diff, :status => template.save, :result => result }
-    end
-
     def purge!
       clause = "name #{@negate ? 'NOT ' : ''}LIKE ?"
       ProvisioningTemplate.where(clause, "#{@prefix}%").each do |template|
         puts template if @verbose
         template.destroy
       end
-    end # :purge
+      # :purge
+    end
 
     private
 
     def parse_bool(bool_name)
       bool_name.is_a?(String) ? bool_name != 'false' : bool_name
     end
-
-    def status_to_text(status, name)
-      msg = "#{name} - import "
-      msg << if status
-               "success"
-             else
-               'failure'
-             end
-      msg
-    end
   end
 end

data/lib/foreman_templates/engine.rb

@@ -10,12 +10,12 @@ module ForemanTemplates
     engine_name 'foreman_templates'
 
     initializer 'foreman_templates.load_default_settings', :before => :load_config_initializers do
-      require_dependency File.expand_path('../../../app/models/setting/template_sync.rb', __FILE__) if (Setting.table_exists? rescue(false))
+      require_dependency File.expand_path('../../app/models/setting/template_sync.rb', __dir__) if (Setting.table_exists? rescue(false))
     end
 
     initializer 'foreman_templates.register_plugin', :before => :finisher_hook do
       Foreman::Plugin.register :foreman_templates do
-        requires_foreman '>= 1.15'
+        requires_foreman '>= 1.18'
 
         apipie_documented_controllers ["#{ForemanTemplates::Engine.root}/app/controllers/api/v2/*.rb"]
 
@@ -30,15 +30,5 @@ module ForemanTemplates
         add_all_permissions_to_default_roles
       end
     end
-
-    config.to_prepare do
-      begin
-        Template.send(:include, ForemanTemplates::TemplateImport)
-        Ptable.send(:include, ForemanTemplates::PtableImport)
-        ProvisioningTemplate.send(:include, ForemanTemplates::ProvisioningTemplateImport)
-      rescue => e
-        puts "#{ForemanTemplates::ENGINE_NAME}: skipping engine hook (#{e})"
-      end
-    end
   end
 end

data/lib/foreman_templates/version.rb

@@ -1,3 +1,3 @@
 module ForemanTemplates
-  VERSION = '5.0.1'.freeze
+  VERSION = '6.0.0'.freeze
 end

data/lib/tasks/foreman_templates_tasks.rake

@@ -2,6 +2,7 @@
 namespace :templates do
   desc 'Import templates according to settings'
   task :import => :environment do
+    ActiveSupport::Deprecation.warn "You are using a deprecated behavior, 'rake templates:import' will be removed in a future version. Please use appropriate API endpoint for this functionality"
     if Rake.application.top_level_tasks.include?('templates:sync')
       ActiveSupport::Deprecation.warn('templates:sync task has been renamed to templates:import and will be removed in a future version')
     end
@@ -13,6 +14,7 @@ namespace :templates do
     # * dirname   => The directory within the git tree containing the templates [/]
     # * filter    => Import names matching this regex (case-insensitive; snippets are not filtered)
     # * associate => Associate to OS's, Locations & Organizations. Options are: always, new or never  [new]
+    # * lock      => Lock imported templates [false]
 
     User.current = User.anonymous_admin
 
@@ -24,6 +26,7 @@ namespace :templates do
       dirname:   ENV['dirname'],
       filter:    ENV['filter'],
       associate: ENV['associate'],
+      lock:      ENV['lock'],
     }).import!
 
     puts results.join("\n")
@@ -33,6 +36,7 @@ namespace :templates do
 
   desc 'Export templates according to settings'
   task :export => :environment do
+    ActiveSupport::Deprecation.warn "You are using a deprecated behavior, 'rake templates:export' will be removed in a future version. Please use appropriate API endpoint for this functionality"
     User.current = User.anonymous_admin
 
     ForemanTemplates::TemplateExporter.new({
@@ -51,6 +55,7 @@ namespace :templates do
 
   desc 'Purge unwanted templates from foreman'
   task :purge => :environment do
+    ActiveSupport::Deprecation.warn "You are using a deprecated behavior, 'rake templates:purge' will be removed in a future version. Please use appropriate API endpoint for this functionality"
     User.current = User.anonymous_admin
 
     ForemanTemplates::TemplateImporter.new({
@@ -92,7 +97,7 @@ namespace :foreman_templates do
                          "#{ForemanTemplates::Engine.root}/lib/**/*.rb",
                          "#{ForemanTemplates::Engine.root}/test/**/*.rb"]
       end
-    rescue
+    rescue StandardError
       puts 'Rubocop not loaded.'
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_templates
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Greg Sutcliffe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-31 00:00:00.000000000 Z
+date: 2018-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diffy
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Engine to synchronise provisioning templates from GitHub
 email: gsutclif@redhat.com
 executables: []
@@ -50,9 +64,7 @@ files:
 - README.md
 - Rakefile
 - app/controllers/api/v2/template_controller.rb
-- app/models/concerns/foreman_templates/provisioning_template_import.rb
-- app/models/concerns/foreman_templates/ptable_import.rb
-- app/models/concerns/foreman_templates/template_import.rb
+- app/controllers/concerns/foreman/controller/parameters/template_params.rb
 - app/models/setting/template_sync.rb
 - app/services/foreman_templates/action.rb
 - app/services/foreman_templates/cleaner.rb
@@ -83,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Template-syncing engine for Foreman

data/app/models/concerns/foreman_templates/provisioning_template_import.rb

@@ -1,94 +0,0 @@
-module ForemanTemplates
-  module ProvisioningTemplateImport
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def import!(name, text, metadata, force = false)
-        # Check for snippet type
-        return import_snippet!(name, text, force) if metadata['snippet'] || metadata['kind'] == 'snippet'
-
-        # Get template type
-        kind = TemplateKind.find_by(name: metadata['kind'])
-        raise NoKindError unless kind
-
-        # Data
-        template = ProvisioningTemplate.where(:name => name).first_or_initialize
-        data = {
-          :template         => text,
-          :snippet          => false,
-          :template_kind_id => kind.id
-        }
-        oses          = map_metadata(metadata, 'oses')
-        locations     = map_metadata(metadata, 'locations')
-        organizations = map_metadata(metadata, 'organizations')
-
-        # Printout helpers
-        c_or_u = template.new_record? ? 'Creating' : 'Updating'
-        id_string = template.new_record? ? '' : "id #{template.id}"
-        if template.locked? && !template.new_record? && !force
-          return { :diff => nil,
-                   :status => false,
-                   :result => "Skipping Template #{id_string}:#{name} - template is locked" }
-        end
-
-        associate_metadata data, template, metadata, oses, organizations, locations
-
-        diff = nil
-        status = nil
-        if template_changed?(data, template)
-          diff = create_diff(data, template)
-          template.ignore_locking do
-            status = template.update_attributes(data)
-          end
-          result = build_associations_result c_or_u, id_string, name, oses, organizations, locations
-        else
-          status  = true
-          result  = "  No change to Template #{id_string}:#{name}"
-        end
-
-        { :diff => diff, :status => status, :result => result, :errors => template.errors }
-      end
-
-      def associate_metadata(data, template, metadata, oses, organizations, locations)
-        if (metadata['associate'] == 'new' && template.new_record?) || (metadata['associate'] == 'always')
-          data[:operatingsystem_ids] = oses.map(&:id)
-          data[:location_ids]        = locations.map(&:id)
-          data[:organization_ids]    = organizations.map(&:id)
-        end
-        data
-      end
-
-      def build_associations_result(c_or_u, id_string, name, oses, organizations, locations)
-        res  = "  #{c_or_u} Template #{id_string}:#{name}"
-        res += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        res += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        res += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-        res
-      end
-
-      def create_diff(data, template)
-        if template_content_changed?(template.template, data[:template])
-          Diffy::Diff.new(
-            template.template,
-            data[:template],
-            :include_diff_info => true
-          ).to_s(:color)
-        else
-          nil
-        end
-      end
-
-      def template_content_changed?(template_template, data_template)
-        template_template != data_template
-      end
-
-      def associations_changed?(data)
-        !(data[:operatingsystem_ids] || data[:location_ids] || data[:organization_ids]).nil?
-      end
-
-      def template_changed?(data, template)
-        template_content_changed?(template.template, data[:template]) || associations_changed?(data)
-      end
-    end
-  end
-end

data/app/models/concerns/foreman_templates/ptable_import.rb

@@ -1,89 +0,0 @@
-module ForemanTemplates
-  module PtableImport
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def import!(name, text, metadata, force = false)
-        # Check for snippet type
-        return import_snippet!(name, text, force) if metadata['snippet']
-
-        # Data
-        ptable = Ptable.where(:name => name).first_or_initialize
-        data = {
-          :layout => text
-        }
-        oses          = map_metadata(metadata, 'oses')
-        locations     = map_metadata(metadata, 'locations')
-        organizations = map_metadata(metadata, 'organizations')
-
-        # Printout helpers
-        c_or_u = ptable.new_record? ? 'Creating' : 'Updating'
-        id_string = ptable.new_record? ? '' : "id #{ptable.id}"
-        if ptable.locked? && !ptable.new_record? && !force
-          return { :diff => nil,
-                   :status => false,
-                   :result => "Skipping Partition Table #{id_string}:#{name} - partition table is locked" }
-        end
-
-        associate_metadata data, ptable, metadata, oses, organizations, locations
-
-        diff = nil
-        status = nil
-        if ptable_changed?(data, ptable)
-          diff = create_diff(data, ptable)
-          ptable.ignore_locking do
-            status = ptable.update_attributes(data)
-          end
-          result  = build_associations_result c_or_u, id_string, name, oses, organizations, locations
-        else
-          status  = true
-          result  = "  No change to Ptable #{id_string}:#{name}"
-        end
-        { :diff => diff, :status => status, :result => result, :errors => ptable.errors }
-      end
-
-      def associate_metadata(data, ptable, metadata, oses, organizations, locations)
-        if (metadata['associate'] == 'new' && ptable.new_record?) || (metadata['associate'] == 'always')
-          data[:operatingsystem_ids] = oses.map(&:id)
-          data[:os_family]           = oses.map(&:family).uniq.first
-          data[:location_ids]        = locations.map(&:id)
-          data[:organization_ids]    = organizations.map(&:id)
-        end
-        data
-      end
-
-      def ptable_content_changed?(data_layout, ptable_layout)
-        data_layout != ptable_layout
-      end
-
-      def associations_changed?(data)
-        !(data[:os_family] || data[:location_ids] || data[:organization_ids]).nil?
-      end
-
-      def create_diff(data, ptable)
-        if ptable_content_changed?(data[:layout], ptable.layout)
-          Diffy::Diff.new(
-            ptable.layout,
-            data[:layout],
-            :include_diff_info => true
-          ).to_s(:color)
-        else
-          nil
-        end
-      end
-
-      def build_associations_result(c_or_u, id_string, name, oses, organizations, locations)
-        res  = "  #{c_or_u} Ptable #{id_string}:#{name}"
-        res += "\n    Operatingsystem Family:\n    - #{oses.map(&:family).uniq.first}" unless oses.empty?
-        res += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        res += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        res += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-        res
-      end
-
-      def ptable_changed?(data, ptable)
-        ptable_content_changed?(data[:layout], ptable.layout) || associations_changed?(data)
-      end
-    end
-  end
-end

data/app/models/concerns/foreman_templates/template_import.rb

@@ -1,65 +0,0 @@
-module ForemanTemplates
-  module TemplateImport
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def import_snippet!(name, text, force = false)
-        # Data
-        snippet = self.where(:name => name).first_or_initialize
-        data = {
-          :template => text,
-          :snippet  => true
-        }
-
-        # Printout helpers
-        c_or_u = snippet.new_record? ? 'Creating' : 'Updating'
-        id_string = snippet.new_record? ? '' : "id #{snippet.id}"
-
-        if snippet.locked? && !snippet.new_record? && !force
-          return { :diff => nil,
-                   :status => false,
-                   :result => "Skipping snippet #{id_string}:#{name} - template is locked" }
-        end
-
-        status = nil
-        if data[:template] != snippet.template
-          diff = Diffy::Diff.new(
-            snippet.template,
-            data[:template],
-            :include_diff_info => true
-          ).to_s(:color)
-          snippet.ignore_locking do
-            status = snippet.update_attributes(data)
-          end
-          result  = "  #{c_or_u} Snippet #{id_string}:#{name}"
-        else
-          diff    = nil
-          status  = true
-          result  = "  No change to Snippet #{id_string}:#{name}"
-        end
-        { :diff => diff, :status => status, :result => result, :errors => snippet.errors }
-      end
-
-      def map_metadata(metadata, param)
-        if metadata[param]
-          case param
-          when 'oses'
-            metadata[param].map do |os|
-              Operatingsystem.all.map { |db| db.to_label =~ /^#{os}/ ? db : nil }
-            end.flatten.compact
-          when 'locations'
-            metadata[param].map do |loc|
-              User.current.my_locations.map { |db| db.name =~ /^#{loc}/ ? db : nil }
-            end.flatten.compact
-          when 'organizations'
-            metadata[param].map do |org|
-              User.current.my_organizations.map { |db| db.name =~ /^#{org}/ ? db : nil }
-            end.flatten.compact
-          end
-        else
-          []
-        end
-      end
-    end
-  end
-end