foreman_templates 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e20876391aee6555fefc6346da21ac4dd54e9e9
-  data.tar.gz: 1cee72d5d2ec7e8e509791f50f7bd7ae2d168b6c
+  metadata.gz: 3889bfa2270632f8e0bfacc4a35a1a85c3eca1e6
+  data.tar.gz: 797795544b68cbb4b2d408e8293e6689d1e3ff02
 SHA512:
-  metadata.gz: 28f7610e8b1b4b3aa1cff6a228db20d3ac4d8835265dd6d646a50d0c3ebe536e2548bf3e9184e72af7096f92a40b226a46303f1c13aad1f322018c3260f4e7ef
-  data.tar.gz: 7e492ef86762d568446c9c1859957be35d38af649b998352c64f10fb401172773e0e4af6ad2b1d7d8b24d0851f80781fffed89c90f77539d1c77bc390642a35c
+  metadata.gz: da4517d69b72c25c3065db6f0afba3621b6165c9c7a8e317a52e0a4c24a81b369fac520cc50ea102ea7accc8b9934452ef38b4a6e270e15d28c2a606e4105688
+  data.tar.gz: ae821ae58dedaaa29a83e41924b1ac30383c0d40e827c6d039397ac7bfd95f7923c94d418fcc1f89bcc59a020ae3b58b385db90bcb71353420384e8b31d4ba01

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

@@ -1,15 +1,17 @@
 module Api
   module V2
     class TemplateController < ::Api::V2::BaseController
-
       api :POST, "/template/import/", N_("Initiate Import")
-      param :repo, String, :required => false, :desc => N_("Import templates from a different repo.")
+      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.")
       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 names matching this regex (case-insensitive; snippets are not filtered).")
+      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, String, :required => false, :desc => N_("Associate to OS's, Locations & Organizations. Options are: always, new or never.")
+      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")
+
       def import
         results = ForemanTemplates::TemplateImporter.new({
           verbose:   params['verbose'],
@@ -20,8 +22,33 @@ module Api
           filter:    params['filter'],
           associate: params['associate'],
           negate:    params['negate'],
+          force:     params['force']
         }).import!
-        render :json => {:message => results}
+        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).")
+      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")
+      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!
+        render :json => { :message => _('Success') }
+      rescue => e
+        logger.debug e
+        render :json => { :message => (_('Something went wrong during export: %s') % e.message) }, :status => 500
       end
     end
   end

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

@@ -1,60 +1,94 @@
-module ForemanTemplates::ProvisioningTemplateImport
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    def import!(name, text, metadata)
-      # Check for snippet type
-      return import_snippet!(name, text) 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? ? 'Created' : 'Updated'
-      id_string = ('id' + template.id) rescue ''
-
-      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)
+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
 
-      if data[:template] != template.template
-        diff = Diffy::Diff.new(
-          template.template,
-          data[:template],
-          :include_diff_info => true
-        ).to_s(:color)
-        status  = template.update_attributes(data)
-        result  = "  #{c_or_u} Template #{id_string}:#{name}"
-        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        result += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        result += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-      elsif data[:operatingsystem_ids] || data[:location_ids] || data[:organization_ids]
-        diff    = nil
-        status  = template.update_attributes(data)
-        result  = "  #{c_or_u} Template Associations #{id_string}:#{name}"
-        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        result += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        result += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-      else
-        diff    = nil
-        status  = true
-        result  = "  No change to Template #{id_string}:#{name}"
+      def template_changed?(data, template)
+        template_content_changed?(template.template, data[:template]) || associations_changed?(data)
       end
-      { :diff => diff, :status => status, :result => result }
     end
   end
 end

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

@@ -1,57 +1,89 @@
-module ForemanTemplates::PtableImport
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    def import!(name, text, metadata)
-      # Check for snippet type
-      return import_snippet!(name, text) 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? ? 'Created' : 'Updated'
-      id_string = ('id' + ptable.id) rescue ''
-
-      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)
+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
 
-      if data[:layout] != ptable.layout
-        diff = Diffy::Diff.new(
-          ptable.layout,
-          data[:layout],
-          :include_diff_info => true
-        ).to_s(:color)
-        status  = ptable.update_attributes(data)
-        result  = "  #{c_or_u} Ptable #{id_string}:#{name}"
-        result += "\n    Operatingsystem Family:\n    - #{oses.map(&:family).uniq.first}" unless oses.empty?
-        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        result += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        result += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-      elsif data[:os_family] || data[:location_ids] || data[:organization_ids]
-        diff    = nil
-        status  = ptable.update_attributes(data)
-        result  = "  #{c_or_u} Ptable Associations #{id_string}:#{name}"
-        result += "\n    Operatingsystem Family:\n    - #{oses.map(&:family).uniq.first}" unless oses.empty?
-        result += "\n    Operatingsystem Associations:\n    - #{oses.map(&:fullname).join("\n    - ")}" unless oses.empty?
-        result += "\n    Organizations Associations:\n    - #{organizations.map(&:name).join("\n    - ")}" unless organizations.empty?
-        result += "\n    Location Associations:\n    - #{locations.map(&:name).join("\n    - ")}" unless locations.empty?
-      else
-        diff    = nil
-        status  = true
-        result  = "  No change to Ptable #{id_string}:#{name}"
+      def ptable_changed?(data, ptable)
+        ptable_content_changed?(data[:layout], ptable.layout) || associations_changed?(data)
       end
-      { :diff => diff, :status => status, :result => result }
     end
   end
 end

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

@@ -1,53 +1,64 @@
-module ForemanTemplates::TemplateImport
-  extend ActiveSupport::Concern
+module ForemanTemplates
+  module TemplateImport
+    extend ActiveSupport::Concern
 
-  module ClassMethods
-    def import_snippet!(name, text)
-      # Data
-      snippet = self.where(:name => name).first_or_initialize
-      data = {
-        :template => text,
-        :snippet  => true
-      }
+    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? ? 'Created' : 'Updated'
-      id_string = ('id' + snippet.id) rescue ''
+        # Printout helpers
+        c_or_u = snippet.new_record? ? 'Creating' : 'Updating'
+        id_string = snippet.new_record? ? '' : "id #{snippet.id}"
 
-      if data[:template] != snippet.template
-        diff = Diffy::Diff.new(
-          snippet.template,
-          data[:template],
-          :include_diff_info => true
-        ).to_s(:color)
-        status  = snippet.update_attributes(data)
-        result  = "  #{c_or_u} Snippet #{id_string}:#{name}"
-      else
-        diff    = nil
-        status  = true
-        result  = "  No change to Snippet #{id_string}:#{name}"
+        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
-      { :diff => diff, :status => status, :result => result }
-    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|
-            Location.all.map { |db| db.name =~ /^#{loc}/ ? db : nil }
-          end.flatten.compact
-        when 'organizations'
-          metadata[param].map do |org|
-            Organization.all.map { |db| db.name =~ /^#{org}/ ? db : nil }
-          end.flatten.compact
+      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
-      else
-        []
       end
     end
   end

data/app/models/setting/template_sync.rb

@@ -1,54 +1,56 @@
-class Setting::TemplateSync < Setting
-  def self.associate_types
-    {
-      'always' => _('Always'),
-      'new' => _('New'),
-      'never' => _('Never')
-    }
-  end
-
-  def self.metadata_export_mode_types
-    {
-      'refresh' => _('Refresh'),
-      'keep' => _('Keep'),
-      'remove' => _('Remove')
-    }
-  end
-
-
-  def self.load_defaults
-    return unless super
-
-    %w(template_sync_filter template_sync_branch).each { |s| Setting::BLANK_ATTRS << s }
+class Setting
+  class TemplateSync < ::Setting
+    def self.associate_types
+      {
+        'always' => _('Always'),
+        'new' => _('New'),
+        'never' => _('Never')
+      }
+    end
 
-    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_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_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 } })
-      ].compact.each { |s| self.create! s.update(:category => "Setting::TemplateSync") }
+    def self.metadata_export_mode_types
+      {
+        'refresh' => _('Refresh'),
+        'keep' => _('Keep'),
+        'remove' => _('Remove')
+      }
     end
 
-    true
-  end
+    def self.load_defaults
+      return unless super
+
+      %w(template_sync_filter template_sync_branch).each { |s| Setting::BLANK_ATTRS << s }
+
+      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_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_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')),
+        ].compact.each { |s| self.create! s.update(:category => "Setting::TemplateSync") }
+      end
+
+      true
+    end
 
-  def validate_template_sync_associate(record)
-    values = record.class.associate_types.keys
-    if record.value && !values.include?(record.value)
-      record.errors[:base] << (_("template_sync_associate must be one of %s") % values.join(', '))
+    def validate_template_sync_associate(record)
+      values = record.class.associate_types.keys
+      if record.value && !values.include?(record.value)
+        record.errors[:base] << (_("template_sync_associate must be one of %s") % values.join(', '))
+      end
     end
-  end
 
-  def validate_template_sync_metadata_export_mode(record)
-    values = record.class.metadata_export_mode_types.keys
-    if record.value && !values.include?(record.value)
-      record.errors[:base] << (_("template_sync_metadata_export_mode must be one of %s") % values.join(', '))
+    def validate_template_sync_metadata_export_mode(record)
+      values = record.class.metadata_export_mode_types.keys
+      if record.value && !values.include?(record.value)
+        record.errors[:base] << (_("template_sync_metadata_export_mode must be one of %s") % values.join(', '))
+      end
     end
   end
 end

data/app/services/foreman_templates/action.rb

@@ -14,7 +14,7 @@ module ForemanTemplates
       end
     end
 
-    def repond_to_missing?(method, include_private = false)
+    def respond_to_missing?(method, include_private = false)
       self.class.setting_overrides.include?(method)
     end
 

data/app/services/foreman_templates/template_exporter.rb

@@ -1,3 +1,5 @@
+require 'shellwords'
+
 module ForemanTemplates
   class TemplateExporter < Action
     def self.setting_overrides
@@ -43,7 +45,7 @@ module ForemanTemplates
 
       status = git_repo.status
       if status.added.any? || status.changed.any? || status.deleted.any? || status.untracked.any?
-        logger.debug "committing changes in cloned repo"
+        logger.debug 'committing changes in cloned repo'
         git_repo.commit "Templates export made by Foreman user #{User.current.try(:login) || User::ANONYMOUS_ADMIN}"
 
         logger.debug "pushing to branch #{branch} at origin #{@repo}"
@@ -70,7 +72,7 @@ module ForemanTemplates
     end
 
     def get_template_filename(template)
-      template.name.downcase.tr(' ', '_') + '.erb'
+      Shellwords.escape(template.name.downcase.tr(' /', '_') + '.erb')
     end
 
     def get_dump_dir(template)
@@ -105,6 +107,5 @@ module ForemanTemplates
           raise "Unknown metadata export mode #{@metadata_export_mode}"
       end
     end
-
   end
 end

data/app/services/foreman_templates/template_importer.rb

@@ -1,24 +1,18 @@
-class NoKindError < Exception; end
-class MissingKindError < Exception; end
+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)
+      super + %i(associate force)
     end
 
     def initialize(args = {})
       super
-      # Rake hands off strings, not booleans, and "false" is true...
-      if @verbose.is_a?(String)
-        @verbose = if @verbose == 'false'
-                     false
-                   else
-                     true
-                   end
-      end
+      @verbose = parse_bool(@verbose)
+      @force = parse_bool(@force)
     end
 
     def import!
@@ -69,23 +63,23 @@ module ForemanTemplates
         if @filter
           matching = name.match(/#{@filter}/i)
           matching = !matching if @negate
-          next if !matching
+          next unless matching
         end
 
         begin
-          # Expects a return of { :diff, :status, :result }
+          # Expects a return of { :diff, :status, :result, :errors }
           data = if metadata['model'].present?
-                   metadata['model'].constantize.import!(name, text, metadata)
+                   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)
+                     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)
+                     ProvisioningTemplate.import!(name, text, metadata, @force)
                    end
                  end
 
@@ -93,12 +87,12 @@ module ForemanTemplates
             data[:diff] = calculate_diff(data[:old], data[:new])
           end
 
-          if data[:status] == true && @verbose
+          if @verbose
             result_lines << data[:result]
             result_lines << data[:diff] unless data[:diff].nil?
-          elsif data[:status] == false
-            result_lines << "Template \"#{name}\": #{data[:result]}"
           end
+          result_lines << status_to_text(data[:status], name)
+          result_lines << data[:errors] unless data[:errors].empty?
         rescue MissingKindError
           result_lines << "  Skipping: '#{name}' - No template kind or model detected"
           next
@@ -136,10 +130,12 @@ module ForemanTemplates
       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"
 
-      return {
-        :status => false,
-        :result => 'Skipping job template import, remote execution plugin is not installed.'
-      } unless defined?(JobTemplate)
+      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
@@ -167,5 +163,21 @@ module ForemanTemplates
         template.destroy
       end
     end # :purge
+
+    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/config/routes.rb

@@ -1,13 +1,12 @@
 Rails.application.routes.draw do
-
-  namespace :api, :defaults => {:format => 'json'} do
-    scope "(:apiv)", :module => :v2, :defaults => {:apiv => 'v2'}, :apiv => /v1|v2/, :constraints => ApiConstraints.new(:version => 2) do
-      resources :templates, :controller => :template, :only => :import do
+  namespace :api, :defaults => { :format => 'json' } do
+    scope "(:apiv)", :module => :v2, :defaults => { :apiv => 'v2' }, :apiv => /v1|v2/, :constraints => ApiConstraints.new(:version => 2) do
+      resources :templates, :controller => :template, :only => [] do
         collection do
           post 'import'
+          post 'export'
         end
       end
     end
   end
-
 end

data/lib/foreman_templates/engine.rb

@@ -23,6 +23,9 @@ module ForemanTemplates
           permission :import_templates, {
             :"api/v2/template" => [:import]
           }, :resource_type => 'Template'
+          permission :export_templates, {
+            :"api/v2/template" => [:export]
+          }, :resource_type => 'Template'
         end
         add_all_permissions_to_default_roles
       end

data/lib/foreman_templates/version.rb

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

data/lib/tasks/foreman_templates_tasks.rake

@@ -6,13 +6,13 @@ namespace :templates do
       ActiveSupport::Deprecation.warn('templates:sync task has been renamed to templates:import and will be removed in a future version')
     end
     # Available options:
-    #* verbose   => Print extra information during the run [false]
-    #* repo      => Sync templates from a different Git repo [https://github.com/theforeman/community-templates]
-    #* branch    => Branch in Git repo [default branch]
-    #* prefix    => The string all imported templates should begin with [Community ]
-    #* 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]
+    # * verbose   => Print extra information during the run [false]
+    # * repo      => Sync templates from a different Git repo [https://github.com/theforeman/community-templates]
+    # * branch    => Branch in Git repo [default branch]
+    # * prefix    => The string all imported templates should begin with [Community ]
+    # * 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]
 
     User.current = User.anonymous_admin
 
@@ -54,9 +54,9 @@ namespace :templates do
     User.current = User.anonymous_admin
 
     ForemanTemplates::TemplateImporter.new({
-      #* negate  => negate query [false]
-      #* prefix  => The string all templates to purge should ( or not ) begin with [Community ]
-      #* verbose => Print extra information during the run [false]
+      # * negate  => negate query [false]
+      # * prefix  => The string all templates to purge should ( or not ) begin with [Community ]
+      # * verbose => Print extra information during the run [false]
       negate:  ENV['negate'],
       prefix:  ENV['prefix'],
       verbose: ENV['verbose'],
@@ -69,7 +69,6 @@ namespace :templates do
     ForemanTemplates::Cleaner.new.clean_up!
     puts 'Clean up finished, you can now remove the plugin from your system'
   end
-
 end
 
 # Tests

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_templates
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.0.1
 platform: ruby
 authors:
 - Greg Sutcliffe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-25 00:00:00.000000000 Z
+date: 2017-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diffy