katello 2.4.5 → 3.0.0.rc1

data/app/controllers/katello/api/v2/activation_keys_controller.rb

@@ -88,16 +88,16 @@ module Katello
       @new_activation_key.user = current_user
       sync_task(::Actions::Katello::ActivationKey::Create, @new_activation_key)
       @new_activation_key.reload
-      @new_activation_key.update_attributes!(
-                                             :service_level => @activation_key.service_level,
-                                             :release_version => @activation_key.release_version,
-                                             :auto_attach => @activation_key.auto_attach
-                                            )
+      sync_task(::Actions::Katello::ActivationKey::Update, @new_activation_key,
+                  :service_level   => @activation_key.service_level,
+                  :release_version => @activation_key.release_version,
+                  :auto_attach     => @activation_key.auto_attach
+               )
       @activation_key.content_overrides.each do |content|
         @new_activation_key.set_content_override(content['contentLabel'], content[:name], content[:value])
       end
-      @activation_key.get_key_pools.each do |pool|
-        @new_activation_key.subscribe(pool[:id], pool[:amount])
+      @activation_key.subscriptions.each do |subscription|
+        @new_activation_key.subscribe(subscription[:id])
       end
       respond_for_show(:resource => @new_activation_key)
     end
@@ -227,6 +227,12 @@ module Katello
                       :subtotal => collection.count }
     end
 
+    def find_activation_key
+      @activation_key = ActivationKey.find(params[:id])
+      fail HttpErrors::NotFound, _("Couldn't find activation key '%s'") % params[:id] if @activation_key.nil?
+      @activation_key
+    end
+
     private
 
     def validate_content_overrides(content_params)
@@ -270,12 +276,6 @@ module Katello
       @environment
     end
 
-    def find_activation_key
-      @activation_key = ActivationKey.find(params[:id])
-      fail HttpErrors::NotFound, _("Couldn't find activation key '%s'") % params[:id] if @activation_key.nil?
-      @activation_key
-    end
-
     def find_host_collections
       ids = params[:activation_key][:host_collection_ids] if params[:activation_key]
       @host_collections = []

data/app/controllers/katello/api/v2/api_controller.rb

@@ -1,5 +1,3 @@
-require 'strong_parameters'
-
 module Katello
   class Api::V2::ApiController < ::Api::V2::BaseController
     include Concerns::Api::ApiController
@@ -38,6 +36,15 @@ module Katello
       @resource_class ||= "Katello::#{resource_name.classify}".constantize
     end
 
+    def full_result_response(collection)
+      { :results => collection,
+        :total => collection.count,
+        :page => 1,
+        :per_page => collection.count,
+        :subtotal => collection.count }
+    end
+
+    # rubocop:disable MethodLength
     def scoped_search(query, default_sort_by, default_sort_order, options = {})
       resource = options[:resource_class] || resource_class
       includes = options.fetch(:includes, [])
@@ -46,21 +53,18 @@ module Katello
       total = query.count
       query = resource.search_for(*search_options).where("#{resource.table_name}.id" => query)
 
-      query = query.select(group).group(group) if group
-      sub_total = query.count
+      if group.present?
+        query = query.select(group).group(group)
+        sub_total = query.count.length
+      else
+        sub_total = query.count
+      end
 
-      sort_attr = (params[:sort_by] || default_sort_by).to_s.downcase
+      sort_attr = params[:sort_by] || default_sort_by
 
       if sort_attr
-        table, column = sort_attr.split(".").length == 2 ? sort_attr.split(".") : [query.table_name, sort_attr]
-        if ActiveRecord::Base.connection.columns(table).map(&:name).include?(column)
-          sort_attr = "#{table}.#{column}"
-        else
-          sort_attr = default_sort_by
-        end
-        sort_order = (params[:sort_order] || default_sort_order).to_s.downcase
-        sort_order = default_sort_order unless ['desc', 'asc'].include?(sort_order)
-        query = query.order("#{sort_attr} #{sort_order}")
+        sort_attr = "#{query.table_name}.#{sort_attr}" unless sort_attr.to_s.include?('.')
+        query = query.order("#{sort_attr} #{params[:sort_order] || default_sort_order}")
       elsif options[:custom_sort]
         query = options[:custom_sort].call(query)
       end
@@ -78,7 +82,7 @@ module Katello
         :subtotal => sub_total,
         :total    => total,
         :page     => params[:page] || 1,
-        :per_page => params[:per_page]  || ::Setting::General.entries_per_page
+        :per_page => params[:per_page] || ::Setting::General.entries_per_page
       }
     end
 
@@ -122,7 +126,7 @@ module Katello
     end
 
     def get_organization(org_id)
-      return Organization.find_by_id(org_id)
+      return Organization.find_by(:id => org_id)
     end
 
     def find_default_organization_and_or_environment
@@ -135,5 +139,10 @@ module Katello
         fail HttpErrors::NotFound, _("You have not set a default organization on the user %s.") % current_user.login
       end
     end
+
+    def find_host_with_subscriptions(id, permission)
+      @host = resource_finder(::Host::Managed.authorized(permission, ::Host::Managed), id)
+      fail HttpErrors::BadRequest, _("Host has not been registered with subscription-manager") if @host.subscription_facet.nil?
+    end
   end
 end

data/app/controllers/katello/api/v2/capsule_content_controller.rb

@@ -6,59 +6,90 @@ module Katello
 
     before_filter :find_capsule
     before_filter :find_environment, :only => [:add_lifecycle_environment, :remove_lifecycle_environment]
+    before_filter :find_optional_organization, :only => [:sync_status]
 
     def_param_group :lifecycle_environments do
-      param :id, Integer, :desc => 'Id of the capsule', :required => true
-      param :organization_id, Integer, :desc => 'Id of the organization to limit environments on'
+      param :id, Integer, :desc => N_('Id of the capsule'), :required => true
+      param :organization_id, Integer, :desc => N_('Id of the organization to limit environments on')
     end
 
     def_param_group :update_lifecycle_environments do
-      param :id, Integer, :desc => 'Id of the capsule', :required => true
-      param :environment_id, Integer, :desc => 'Id of the lifecycle environment', :required => true
+      param :id, Integer, :desc => N_('Id of the capsule'), :required => true
+      param :environment_id, Integer, :desc => N_('Id of the lifecycle environment'), :required => true
     end
 
-    api :GET, '/capsules/:id/content/lifecycle_environments', 'List the lifecycle environments attached to the capsule'
+    api :GET, '/capsules/:id/content/lifecycle_environments', N_('List the lifecycle environments attached to the capsule')
     param_group :lifecycle_environments
     def lifecycle_environments
-      @lifecycle_environments = capsule_content.lifecycle_environments(params[:organization_id]).readable
+      environments = capsule_content.lifecycle_environments(params[:organization_id]).readable
+      respond_for_lifecycle_environments_index(environments)
     end
 
-    api :GET, '/capsules/:id/content/available_lifecycle_environments', 'List the lifecycle environments not attached to the capsule'
+    api :GET, '/capsules/:id/content/available_lifecycle_environments', N_('List the lifecycle environments not attached to the capsule')
     param_group :lifecycle_environments
     def available_lifecycle_environments
-      @lifecycle_environments = capsule_content.available_lifecycle_environments(params[:organization_id]).readable
-      render 'katello/api/v2/capsule_content/lifecycle_environments'
+      environments = capsule_content.available_lifecycle_environments(params[:organization_id]).readable
+      respond_for_lifecycle_environments_index(environments)
     end
 
-    api :POST, '/capsules/:id/content/lifecycle_environments', 'Add lifecycle environments to the capsule'
+    api :POST, '/capsules/:id/content/lifecycle_environments', N_('Add lifecycle environments to the capsule')
     param_group :update_lifecycle_environments
     def add_lifecycle_environment
       capsule_content.add_lifecycle_environment(@environment)
-      @lifecycle_environments = capsule_content.lifecycle_environments
-      render 'katello/api/v2/capsule_content/lifecycle_environments'
+      respond_for_lifecycle_environments_index(capsule_content.lifecycle_environments)
     end
 
-    api :DELETE, '/capsules/:id/content/lifecycle_environments/:environment_id',  'Remove lifecycle environments from the capsule'
+    api :DELETE, '/capsules/:id/content/lifecycle_environments/:environment_id', N_('Remove lifecycle environments from the capsule')
     param_group :update_lifecycle_environments
     def remove_lifecycle_environment
       capsule_content.remove_lifecycle_environment(@environment)
-      @lifecycle_environments = capsule_content.lifecycle_environments
-      render 'katello/api/v2/capsule_content/lifecycle_environments'
+      respond_for_lifecycle_environments_index(capsule_content.lifecycle_environments)
     end
 
-    api :POST, '/capsules/:id/content/sync',  'Synchronize the content to the capsule'
-    param :id, Integer, :desc => 'Id of the capsule', :required => true
-    param :environment_id, Integer, :desc => 'Id of the environment to limit the synchronization on'
+    api :POST, '/capsules/:id/content/sync', N_('Synchronize the content to the capsule')
+    param :id, Integer, :desc => N_('Id of the capsule'), :required => true
+    param :environment_id, Integer, :desc => N_('Id of the environment to limit the synchronization on')
     def sync
       find_environment if params[:environment_id]
       task = async_task(::Actions::Katello::CapsuleContent::Sync, capsule_content, :environment => @environment)
       respond_for_async :resource => task
     end
 
+    api :GET, '/capsules/:id/content/sync', N_('Get current capsule synchronization status')
+    param :id, Integer, :desc => N_('Id of the capsule'), :required => true
+    param :organization_id, Integer, :desc => N_('Id of the organization to get the status for'), :required => false
+    def sync_status
+      @capsule_content = capsule_content
+      @lifecycle_environments = @capsule_content.lifecycle_environments(@organization)
+    end
+
+    api :DELETE, '/capsules/:id/content/sync', N_('Cancel running capsule synchronization.')
+    param :id, Integer, :desc => N_('Id of the capsule'), :required => true
+    def cancel_sync
+      tasks = capsule_content.cancel_sync
+      if tasks.empty?
+        render_message _('There\'s no running synchronization for this capsule.')
+      else
+        render_message _('Trying to cancel the synchronization...')
+      end
+    end
+
     protected
 
+    def respond_for_lifecycle_environments_index(environments)
+      collection = {
+        :results => environments,
+        :total => environments.size,
+        :subtotal => environments.size
+      }
+      respond_for_index(:collection => collection, :template => :lifecycle_environments)
+    end
+
     def find_capsule
-      @capsule = SmartProxy.authorized(:manage_capsule_content).with_features(SmartProxy::PULP_NODE_FEATURE).find(params[:id])
+      @capsule = SmartProxy.authorized(:manage_capsule_content).find(params[:id])
+      unless @capsule && @capsule.has_feature?(SmartProxy::PULP_NODE_FEATURE)
+        fail _("This request may only be performed on a Capsule that has the Pulp Node feature.")
+      end
     end
 
     def find_environment

data/app/controllers/katello/api/v2/content_view_filter_rules_controller.rb

@@ -28,6 +28,7 @@ module Katello
     param :start_date, String, :desc => N_("erratum: start date (YYYY-MM-DD)")
     param :end_date, String, :desc => N_("erratum: end date (YYYY-MM-DD)")
     param :types, Array, :desc => N_("erratum: types (enhancement, bugfix, security)")
+    param :date_type, String, :desc => N_("erratum: search using the 'Issued On' or 'Updated On' column of the errata. Values are 'issued'/'updated'")
     def create
       rule_clazz = ContentViewFilter.rule_class_for(@filter)
 
@@ -106,7 +107,7 @@ module Katello
 
       params.fetch(:content_view_filter_rule, {}).
             permit(:uuid, :name, :version, :min_version, :max_version,
-                    :errata_id, :start_date, :end_date,
+                    :errata_id, :start_date, :end_date, :date_type,
                     :types => [], :errata_ids => [])
     end
 

data/app/controllers/katello/api/v2/content_view_filters_controller.rb

@@ -70,17 +70,13 @@ module Katello
 
     private
 
-    def deprecated
-      ::Foreman::Deprecation.api_deprecation_warning("it will be changed in Katello 2.4, where it will be /content_view_filters/:id/package_groups?available_for=content_view_filter")
-    end
-
     def find_content_view
       @view = ContentView.find(params[:content_view_id]) if params[:content_view_id]
     end
 
     def find_filter
       if @view
-        @filter = @view.filters.find_by_id(params[:id])
+        @filter = @view.filters.find_by(:id => params[:id])
         fail HttpErrors::NotFound, _("Couldn't find ContentViewFilter with id=%s") % params[:id] unless @filter
       else
         @filter = ContentViewFilter.find(params[:id])

data/app/controllers/katello/api/v2/content_view_versions_controller.rb

@@ -3,7 +3,7 @@ module Katello
     include Concerns::Api::V2::BulkSystemsExtensions
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_filter :find_content_view_version, :only => [:show, :promote, :destroy]
+    before_filter :find_content_view_version, :only => [:show, :promote, :destroy, :export]
     before_filter :find_content_view, :except => [:incremental_update]
     before_filter :find_environment, :only => [:promote, :index]
     before_filter :authorize_promotable, :only => [:promote]
@@ -53,6 +53,31 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_view_versions/:id/export", N_("Export a content view version")
+    param :id, :identifier, :desc => N_("Content view version identifier"), :required => true
+    param :export_to_iso, :bool, :desc => N_("Export to ISO format"), :required => false
+    param :iso_mb_size, :number, :desc => N_("maximum size of each ISO in MB"), :required => false
+    param :since, Date, :desc => N_("Optional date of last export (ex: 2010-01-01T12:00:00Z)"), :required => false
+    def export
+      if !params[:export_to_iso].present? && params[:iso_mb_size].present?
+        fail HttpErrors::BadRequest, _("ISO export must be enabled when specifying ISO size")
+      end
+
+      if params[:since].present?
+        begin
+          params[:since].to_datetime
+        rescue
+          raise HttpErrors::BadRequest, _("Invalid date provided.")
+        end
+      end
+
+      task = async_task(::Actions::Katello::ContentViewVersion::Export, @version,
+                        ::Foreman::Cast.to_bool(params[:export_to_iso]),
+                        params[:since].try(:to_datetime),
+                        params[:iso_mb_size])
+      respond_for_async :resource => task
+    end
+
     api :DELETE, "/content_view_versions/:id", N_("Remove content view version")
     param :id, :identifier, :desc => N_("Content view version identifier"), :required => true
     def destroy

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

@@ -26,6 +26,7 @@ module Katello
     param :environment_id, :identifier, :desc => N_("environment identifier")
     param :nondefault, :bool, :desc => N_("Filter out default content views")
     param :noncomposite, :bool, :desc => N_("Filter out composite content views")
+    param :composite, :bool, :desc => N_("Filter only composite content views")
     param :without, Array, :desc => N_("Do not include this array of content views")
     param :name, String, :desc => N_("Name of the content view"), :required => false
     param_group :search, Api::V2::ApiController
@@ -42,6 +43,7 @@ module Katello
       content_views = content_views.in_environment(@environment) if @environment
       content_views = content_views.non_default if params[:nondefault]
       content_views = content_views.non_composite if params[:noncomposite]
+      content_views = content_views.composite if params[:composite]
       content_views = content_views.where(:name => params[:name]) if params[:name]
       content_views = content_views.where("#{ContentView.table_name}.id NOT IN (?)", params[:without]) if params[:without]
       content_views

data/app/controllers/katello/api/v2/{docker_images_controller.rb → docker_manifests_controller.rb}

@@ -1,12 +1,12 @@
 module Katello
-  class Api::V2::DockerImagesController < Api::V2::ApiController
-    apipie_concern_subst(:a_resource => N_("a docker image"), :resource => "docker_images")
+  class Api::V2::DockerManifestsController < Api::V2::ApiController
+    apipie_concern_subst(:a_resource => N_("a docker manifest"), :resource => "docker_manifests")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
     private
 
     def resource_class
-      DockerImage
+      DockerManifest
     end
 
     def filter_by_content_view_filter(filter)

data/app/controllers/katello/api/v2/docker_tags_controller.rb

@@ -6,7 +6,10 @@ module Katello
     def index
       if params[:grouped]
         # group docker tags by name, repo, and product
-        collection = Katello::DockerTag.grouped
+        repos = Repository.readable
+        repos = repos.in_organization(@organization) if @organization
+        collection = Katello::DockerTag.in_repositories(repos).grouped
+
         respond(:collection => scoped_search(collection, "name", "DESC"))
       else
         super

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

@@ -72,11 +72,6 @@ module Katello
     param :name, String, :desc => N_("name of the environment"), :required => true
     param :label, String, :desc => N_("label of the environment"), :required => false
     param :description, String, :desc => N_("description of the environment")
-    param :prior, Integer, :deprecated => true, :desc => <<-DESC
-      ID of an environment that is prior to the new environment in the chain. It has to be
-      either the ID of Library or the ID of an environment at the end of a chain.
-      This param exists for backwards compatibility purposes. Please use prior_id.
-    DESC
     param :prior_id, Integer, :required => true, :desc => <<-DESC
       ID of an environment that is prior to the new environment in the chain. It has to be
       either the ID of Library or the ID of an environment at the end of a chain.
@@ -184,7 +179,7 @@ module Katello
     end
 
     def find_content_view
-      @content_view = ContentView.readable.find_by_id(params[:content_view_id])
+      @content_view = ContentView.readable.find_by(:id => params[:content_view_id])
     end
   end
 end

data/app/controllers/katello/api/v2/errata_controller.rb

@@ -4,13 +4,14 @@ module Katello
     include Katello::Concerns::Api::V2::RepositoryContentController
 
     api :GET, "/errata", N_("List errata")
+    param :organization_id, :number, :desc => N_("organization identifier")
     param :content_view_version_id, :identifier, :desc => N_("content view version identifier")
     param :content_view_filter_id, :identifier, :desc => N_("content view filter identifier")
     param :repository_id, :number, :desc => N_("repository identifier")
     param :environment_id, :number, :desc => N_("environment identifier")
     param :cve, String, :desc => N_("CVE identifier")
-    param :errata_restrict_applicable, :bool, :desc => N_("show only errata with one or more applicable systems")
-    param :errata_restrict_installable, :bool, :desc => N_("show only errata with one or more installable systems")
+    param :errata_restrict_applicable, :bool, :desc => N_("show only errata with one or more applicable hosts")
+    param :errata_restrict_installable, :bool, :desc => N_("show only errata with one or more installable hosts")
     param_group :search, Api::V2::ApiController
     def index
       super
@@ -20,20 +21,28 @@ module Katello
       collection = filter_by_content_view(filter, collection)
       ids = Katello::ContentViewErratumFilterRule.where(:content_view_filter_id => filter.id).pluck("errata_id")
       collection = collection.where("errata_id not in (?)", ids) unless ids.empty?
-      collection = collection.where('issued  >= ?', params[:start_date]) if params[:start_date]
-      collection = collection.where('issued  <= ?', params[:end_date]) if params[:end_date]
+
+      date_type = params[:date_type].present? ? params[:date_type] : ContentViewErratumFilterRule::UPDATED
+      unless ContentViewErratumFilterRule::DATE_TYPES.include?(date_type)
+        msg = _("Invalid params provided - date_type must be one of %s" % ContentViewErratumFilterRule::DATE_TYPES.join(","))
+        fail HttpErrors::UnprocessableEntity, msg
+      end
+
+      collection = collection.where("#{date_type} >= ?", params[:start_date]) if params[:start_date]
+      collection = collection.where("#{date_type} <= ?", params[:end_date]) if params[:end_date]
       collection = collection.of_type(params[:types]) if params[:types]
       collection
     end
 
     def custom_index_relation(collection)
       collection = filter_by_cve(params[:cve], collection) if params[:cve]
+      hosts = ::Host::Managed.authorized("view_hosts")
       if ::Foreman::Cast.to_bool(params[:errata_restrict_applicable])
-        collection = collection.applicable_to_systems(System.readable)
+        collection = collection.applicable_to_hosts(hosts)
       end
 
       if ::Foreman::Cast.to_bool(params[:errata_restrict_installable])
-        collection = collection.installable_for_systems(System.readable)
+        collection = collection.installable_for_hosts(hosts)
       end
       collection
     end

data/app/controllers/katello/api/v2/gpg_keys_controller.rb

@@ -73,7 +73,7 @@ module Katello
 
     api :POST, "/gpg_keys/:id/content", N_("Upload gpg key contents")
     param :id, :number, :desc => N_("gpg key numeric identifier"), :required => true
-    param :content, File, :required => true, :desc => N_("file contents"), :required => true
+    param :content, File, :desc => N_("file contents"), :required => true
     def content
       filepath = params.try(:[], :content).try(:path)