katello 3.1.0.1 → 3.2.0.rc1

data/app/controllers/katello/concerns/api/v2/hostgroups_controller_extensions.rb

@@ -6,21 +6,24 @@ module Katello
       included do
         def_param_group :hostgroup do
           param :hostgroup, Hash, :required => true, :action_aware => true do
-            param :name, String, :required => true
-            param :parent_id, :number
-            param :environment_id, :number
-            param :operatingsystem_id, :number
-            param :architecture_id, :number
-            param :medium_id, :number
-            param :ptable_id, :number
-            param :puppet_ca_proxy_id, :number
-            param :subnet_id, :number
-            param :domain_id, :number
-            param :realm_id, :number
-            param :puppet_proxy_id, :number
-            param :content_source_id, :number
-            param :content_view_id, :number
-            param :lifecycle_environment_id, :number
+            param :name, String, :required => true, :desc => N_('Name of the host group')
+            param :parent_id, :number, :desc => N_('Parent ID of the host group')
+            param :environment_id, :number, :desc => N_('Environment ID')
+            param :compute_profile_id, :number, :desc => N_('Compute profile ID')
+            param :operatingsystem_id, :number, :desc => N_('Operating system ID')
+            param :architecture_id, :number, :desc => N_('Architecture ID')
+            param :pxe_loader, Operatingsystem.all_loaders, :desc => N_("DHCP filename option (Grub2/PXELinux by default)")
+            param :medium_id, :number, :desc => N_('Media ID')
+            param :ptable_id, :number, :desc => N_('Partition table ID')
+            param :puppet_ca_proxy_id, :number, :desc => N_('Puppet CA proxy ID')
+            param :subnet_id, :number, :desc => N_('Subnet ID')
+            param :domain_id, :number, :desc => N_('Domain ID')
+            param :realm_id, :number, :desc => N_('Realm ID')
+            param :puppet_proxy_id, :number, :desc => N_('Puppet proxy ID')
+            param :root_pass, String, :desc => N_('Root password on provisioned hosts')
+            param :content_source_id, :number, :desc => N_('Content source ID')
+            param :content_view_id, :number, :desc => N_('Content view ID')
+            param :lifecycle_environment_id, :number, :desc => N_('Lifecycle environment ID')
             param_group :taxonomies, ::Api::V2::BaseController
           end
         end
@@ -28,7 +31,7 @@ module Katello
         api :POST, "/hostgroups/", N_("Create a host group")
         param_group :hostgroup, :as => :create
         def create
-          @hostgroup = Hostgroup.new(params[:hostgroup])
+          @hostgroup = Hostgroup.new(hostgroup_params)
           process_response @hostgroup.save
         end
 

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -6,12 +6,12 @@ module Katello
       included do
         include Katello::Concerns::FilteredAutoCompleteSearch
 
-        before_filter :find_repository
-        before_filter :find_optional_organization, :only => [:index, :auto_complete_search]
-        before_filter :find_environment, :only => [:index, :auto_complete_search]
-        before_filter :find_content_view_version, :only => [:index, :auto_complete_search]
-        before_filter :find_filter, :only => [:index, :auto_complete_search]
-        before_filter :find_content_resource, :only => [:show]
+        before_action :find_repository
+        before_action :find_optional_organization, :only => [:index, :auto_complete_search]
+        before_action :find_environment, :only => [:index, :auto_complete_search]
+        before_action :find_content_view_version, :only => [:index, :auto_complete_search]
+        before_action :find_filter, :only => [:index, :auto_complete_search]
+        before_action :find_content_resource, :only => [:show]
       end
 
       extend ::Apipie::DSL::Concern
@@ -200,6 +200,8 @@ module Katello
           _("Docker Tag")
         when "Katello::OstreeBranch"
           _("OSTree Branch")
+        when "Katello::FileUnit"
+          _("File")
         else
           fail "Can't find resource class: #{resource_class}"
         end

data/app/controllers/katello/concerns/authorization/api/v2/content_views_controller.rb

@@ -3,9 +3,9 @@ module Katello
     extend ActiveSupport::Concern
 
     included do
-      before_filter :authorize_destroy, :only => [:destroy]
-      before_filter :authorize_remove_from_environment, :only => [:remove_from_environment]
-      before_filter :authorize_remove, :only => [:remove]
+      before_action :authorize_destroy, :only => [:destroy]
+      before_action :authorize_remove_from_environment, :only => [:remove_from_environment]
+      before_action :authorize_remove, :only => [:remove]
     end
 
     private
@@ -118,14 +118,18 @@ module Katello
       # and also ensure that the environments have the remove permission
       return deny_access unless KTEnvironment.promotable.where(:id => env_ids).count == env_ids.size && view.promotable_or_removable?
 
-      if Katello::System.where(:content_view_id => view, :environment_id => env_ids).count > 0
+      total_count = Katello::Host::ContentFacet.where(:content_view_id => view, :lifecycle_environment_id => env_ids).count
+      if total_count > 0
         unless options[:system_content_view_id] && options[:system_environment_id]
           fail _("Unable to reassign content hosts. Please provide system_content_view_id and system_environment_id.")
         end
 
-        # if we are reassigning systems to a diffent environment or cv
+        # if we are reassigning systems to a different environment or cv
         # make sure all the systems in existing environments are editable.
-        return deny_access unless Katello::System.all_editable?(view, env_ids)
+        if total_count != ::Host::Managed.authorized('edit_hosts').in_content_view_environment(:content_view => view,
+                                            :lifecycle_environment => ::Katello::KTEnvironment.where(:id => env_ids)).count
+          deny_access
+        end
       end
 
       if Katello::ActivationKey.where(:content_view_id => view, :environment_id => env_ids).count > 0

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -26,7 +26,7 @@ module Katello
       def create_with_dynflow
         if taxonomy_class == Organization
           begin
-            @taxonomy = Organization.new(params[:organization])
+            @taxonomy = Organization.new(resource_params)
             sync_task(::Actions::Katello::Organization::Create, @taxonomy)
             @taxonomy.reload
             if @count_nil_hosts > 0

data/app/controllers/katello/concerns/smart_proxies_controller_extensions.rb

@@ -5,7 +5,7 @@ module Katello
 
       included do
         append_view_path('app/views/foreman')
-        before_filter :find_resource_and_status, :only => [:pulp_storage, :pulp_status]
+        before_action :find_resource_and_status, :only => [:pulp_storage, :pulp_status]
         alias_method_chain :action_permission, :katello
         alias_method_chain :show, :content
 

data/app/controllers/katello/errors_controller.rb

@@ -1,7 +1,7 @@
 module Katello
   class ErrorsController < Katello::ApplicationController
-    skip_before_filter :require_user, :require_org
-    skip_before_filter :authorize # ok - is used by warden
+    skip_before_action :require_user, :require_org
+    skip_before_action :authorize # ok - is used by warden
 
     # handles unknown routes from both / and /api namespaces
     def routing

data/app/controllers/katello/organizations_controller.rb

@@ -1,6 +1,6 @@
 module Katello
   class OrganizationsController < Katello::ApplicationController
-    before_filter :search_filter, :only => [:auto_complete_search]
+    before_action :search_filter, :only => [:auto_complete_search]
 
     def rules
       {

data/app/controllers/katello/products_controller.rb

@@ -2,9 +2,9 @@ module Katello
   class ProductsController < Katello::ApplicationController
     respond_to :html, :js
 
-    before_filter :find_product, :only => [:available_repositories, :toggle_repository]
-    before_filter :find_provider, :only => [:available_repositories, :toggle_repository]
-    before_filter :find_content, :only => [:toggle_repository]
+    before_action :find_product, :only => [:available_repositories, :toggle_repository]
+    before_action :find_provider, :only => [:available_repositories, :toggle_repository]
+    before_action :find_content, :only => [:toggle_repository]
 
     include ForemanTasks::Triggers
 
@@ -53,7 +53,7 @@ module Katello
     end
 
     def find_content
-      if product_content = @product.product_content_by_id(params[:content_id])
+      if (product_content = @product.product_content_by_id(params[:content_id]))
         @content = product_content.content
       else
         fail HttpErrors::NotFound, _("Couldn't find content '%s'") % params[:content_id]

data/app/controllers/katello/providers_controller.rb

@@ -1,7 +1,7 @@
 module Katello
   class ProvidersController < Katello::ApplicationController
-    before_filter :find_rh_provider, :only => [:redhat_provider, :redhat_provider_tab]
-    before_filter :search_filter, :only => [:auto_complete_search]
+    before_action :find_rh_provider, :only => [:redhat_provider, :redhat_provider_tab]
+    before_action :search_filter, :only => [:auto_complete_search]
 
     respond_to :html, :js
 

data/app/helpers/katello/application_helper.rb

@@ -6,168 +6,12 @@ module Katello
       User.current
     end
 
-    def current_url(extra_params = {})
-      url_for params.merge(extra_params)
-    end
-
-    def link_to_authorized(*args, &block)
-      if block_given?
-        options      = args.first || {}
-        html_options = args.second
-        link_to_authorized(capture(&block), options, html_options)
-      else
-        name         = args[0]
-        options      = args[1] || {}
-        html_options = args[2]
-
-        if options.key? :controller
-          ctrl   = options[:controller]
-          action = options[:action] || 'index'
-
-          if current_user && current_user.allowed_to?(:controller => ctrl, :action => action)
-            link_to(name, options, html_options)
-          end
-        end
-      end
-    end
-
-    # Headpin inclusion
-    def stats_line(stats, _options = {})
-      render :partial => "katello/commonstats_line",
-             :locals => {:stats => stats}
-    end
-
-    # Headpin inclusion
-    def to_value_list(stats)
-      list = ""
-      prepend = ""
-      stats.each do |stat|
-        list += prepend
-        prepend = ","
-        list += stat.value.to_s
-      end
-      list
-    end
-
-    def two_panel(collection, options)
-      options[:accessor] ||= "id"
-      options[:left_panel_width] ||= nil
-      options[:ajax_load] ||= false
-      enable_create = options[:enable_create]
-      enable_create = true if enable_create.nil?
-      enable_sort = options[:enable_sort] ? options[:enable_sort] : false
-
-      fail ":titles option not provided" unless options[:titles]
-
-      render :partial => "katello/common/panel",
-             :locals => {
-               :title => options[:title],
-               :name => options[:name],
-               :create => options[:create],
-               :enable_create => enable_create,
-               :create_label => options[:create_label] || nil,
-               :enable_sort => enable_sort,
-               :columns => options[:col],
-               :titles => options[:titles],
-               :custom_rows => options[:custom_rows],
-               :collection => collection,
-               :accessor => options[:accessor],
-               :url => options[:url],
-               :left_panel_width => options[:left_panel_width],
-               :ajax_load => options[:ajax_load],
-               :ajax_scroll => options[:ajax_scroll],
-               :search_env => options[:search_env],
-               :initial_action => options[:initial_action] || :edit,
-               :initial_state => options[:initial_state] || false,
-               :actions => options[:actions],
-               :search_class => options[:search_class],
-               :disable_create => options[:disable_create] || false}
-    end
-
-    def one_panel(panel_id, collection, options)
-      options[:accessor] ||= "id"
-      panel_id ||= "panel"
-
-      render :partial => "katello/common/one_panel",
-             :locals => {
-               :single_select => options[:single_select] || false,
-               :hover_text_cb => options[:hover_text_cb],
-               :panel_id => panel_id,
-               :title => options[:title],
-               :name => options[:name],
-               :columns => options[:col],
-               :column_titles => options[:col_titles],
-               :custom_rows => options[:custom_rows],
-               :collection => collection,
-               :accessor => options[:accessor] }
-    end
-
-    def notification_polling_time
-      time = 120
-      return time.to_i * 1_000 if time
-      return 120_000
-    end
-
-    def environment_selector(options = {})
-      options[:library_clickable] = true if options[:library_clickable].nil? # ||= doesn't work if false
-      options[:url_proc] = nil if options[:url_proc].nil? #explicitly set url_method to nil if not provided
-
-      # the path widget and entries classes allow the user to override the classes that will be applied to these
-      # elements.  by default, they are set assuming the env selector will be displayed on a page (vs w/in a panel)
-      options[:path_widget_class] = "" if options[:path_widget_class].nil?
-      options[:path_entries_class] = "grid_10" if options[:path_entries_class].nil?
-
-      render :partial => "/katello/common/env_select", :locals => options
-    end
-
-    def env_select_class(curr_env, selected_env, curr_path, selected_path, accessible_envs, library_clickable)
-      classes = []
-      if (library_clickable || !curr_env.library?) && accessible_envs.member?(curr_env)
-        classes << "path_link"
-      else
-        # if library isn't clickable, disable the hover effect
-        classes << "crumb-nohover"
-      end
-
-      if curr_env.id == selected_env.id
-        if !selected_env.library?
-          classes << "active"
-        else
-          #we only want to highlight the Library along the path that is actually selected
-          classes << "active" if curr_path[1] == selected_path[1]
-        end
-      end
-      classes.join(' ')
-    end
-
-    def env_select_url(proc, env, next_env, org)
-      return nil if proc.nil?
-      proc.call(:environment => env, :next_environment => next_env, :organization => org)
-    end
-
-    # auto_tab_index: this method may be used to simplify adding a tabindex to UI forms.
-    def auto_tab_index
-      @current_index ||= 0
-      @current_index += 1
-    end
-
     #formats the date time if the dat is not nil
     def format_time(date, options = {})
       return I18n.l(date, options) if date
       ""
     end
 
-    def generate_url(path, options, entity)
-      panel_page = options.key?(:panel_page) ? ("&panelpage=" + options[:panel_page]) : ""
-      path + "?list_search=id%3D#{options[:id]}#panel=#{entity}_#{options[:id]}" + panel_page
-    end
-
-    # used for jeditable fields
-    def editable_class(editable = false)
-      return "editable edit_panel_element multiline" if editable
-      "multiline"
-    end
-
     # These 2 methods copied from scoped_search {https://github.com/wvanbergen/scoped_search}
     # which Katello used to use but no longer uses.
     #
@@ -218,21 +62,6 @@ module Katello
       return link.respond_to?(:html_safe) ? link.html_safe : link
     end
 
-    def activation_key_link_helper(key)
-      if ActivationKey.readable? key.organization
-        link_to(key.name, activation_keys_path(key.id, :anchor => "/&list_search=id:#{key.id}&panel=activation_key_#{key.id}"))
-      else
-        key.name
-      end
-    rescue
-      _('Activation key with uuid %s not found') % key.try(:id)
-    end
-
-    def kt_form_for(object, options = {}, &block)
-      options[:builder] = KatelloFormBuilder
-      form_for(object, options, &block)
-    end
-
     def select_content_view
       _('Select Content View')
     end
@@ -241,77 +70,8 @@ module Katello
       _('No Content View')
     end
 
-    def content_view_select_labels(_organization, environment)
-      if environment
-        labels = ContentView.readable.
-            in_environment(environment).collect { |cv| [cv.name, cv.id] }
-      else
-        labels = []
-      end
-      labels
-    end
-
     def selected_content_view(content_view)
       content_view.nil? ? no_content_view : content_view.id
     end
-
-    def to_calendar_date(date)
-      date.strftime('%m/%d/%Y')
-    end
-
-    def subscription_limits_helper(sub)
-      lim = []
-      lim << _("Sockets: %s") % sub.sockets if sub.sockets > 0
-      lim << _("Cores: %s") % sub.cores if sub.cores > 0
-      lim << _("RAM: %s GB") % sub.ram if sub.ram > 0
-      lim.join(", ")
-    end
-
-    def repo_selector(repositories, url, field = :repository_id, record = nil)
-      products = repositories.map(&:product).uniq.sort_by { |product| product[:name] }
-      repo_ids = repositories.map(&:id)
-
-      content_tag "select", :id => "repo_select", :name => field, "data-url" => url do
-        html = ""
-        html << content_tag("option", :value => "") { "None" }
-
-        groups = products.map do |prod|
-          content_tag("optgroup", :label => "#{h(prod.name)}") do
-            options = prod.repositories.select { |repo| repo_ids.include?(repo.id) }.map do |repo|
-              selected = record && record.send(field) == repo.id
-
-              content_tag("option", :value => repo.id, :selected => selected) do
-                h(repo.name)
-              end
-            end
-            options.join.html_safe
-          end
-        end
-
-        (html + groups.join).html_safe
-      end
-    end
-
-    # Using the record provided, return a hash where the
-    # keys are the products associated with the record and the
-    # values are arrays listing the repositories associated
-    # with the given product.
-    # For example: {product1 => [repo1, repo2]}
-    def get_product_and_repos(record, content_types)
-      products_hash = record.resulting_products.inject({}) do |hash, product|
-        if record.repositories.empty?
-          hash[product] = []
-        else
-          repos = product.repos(current_organization.library).where(:content_type => content_types)
-          repos.each do |repo|
-            hash[product] ||= []
-            hash[product] << repo
-          end
-        end
-        hash
-      end
-
-      products_hash
-    end
   end
 end