katello 3.16.1.2 → 3.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 808bc23ecac2fda98ac24ce30217831caa4977d250e759baf83ab78150db70f3
-  data.tar.gz: 5531f14549ff16ea0f157a013ebf5ead92ab2acd5fa9a085face6f48fd0a3a50
+  metadata.gz: 45f65da0c274cbc6976755a23d58f5eb77979dceea6cdcb118c1d6445f20b8ad
+  data.tar.gz: c5c8d2e9e58744b2389f9910daadc9656040d37364edfb12f48f5f1f06bf1743
 SHA512:
-  metadata.gz: 40a2c815ff331564ff218ce5d688183b4595d4c423e16f27cdb1d1cfb083bbaaa678d9d09cd5303cc6d56825bd300d33b2192dd5c51edf260a09b37aa7e5102f
-  data.tar.gz: 785618e922bfa8a6f1a9675c4eccf2dc1d0e3038401ed9ac30ca1ddeb2294fbc2ba13987f07b08b96884aa90fcd1fd2a85acf18f28d2c9030a42782544941d0b
+  metadata.gz: 5ac6853c42e650e0a410e0f60b5c5a5f58d6d046142fb846fd39a37124a1a43222d0d22377881cf111c3a7984454ddc937f0fc0eeef6b5fb08fc3ac61630b80e
+  data.tar.gz: 0c87277e1d4a316b374c2f30b86154a607e4619ee5069c1157f0fe3aa07126e6645591e7eba301eca661b230892f66c7d0bc21c3446ea4fb262b1622c8c4865e

data/app/assets/stylesheets/katello/katello.scss

@@ -1,10 +1,3 @@
-/**
- * = require "katello/jquery.loadmask.css"
- * = require "katello/jquery-ui-1.8.11.custom.css"
- * = require "katello/jquery.treeTable.css"
- * = require "katello/ui.spinner.css"
- */
-
 @import "katello/overrides";
 @import "katello/katello_base";
 @import "katello/look";
@@ -18,6 +11,9 @@
 @import "katello/generic";
 @import "katello/notifications";
 
+@import "katello/jquery.treeTable";
+@import "katello/jquery-ui-1.8.11.custom.css";
+
 body {
   background-color: white;
 }

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -10,8 +10,8 @@ module Katello
     before_action :registry_authorize, except: [:token, :v1_search, :catalog]
     before_action :authorize_repository_read, only: [:pull_manifest, :tags_list]
     before_action :authorize_repository_write, only: [:push_manifest]
-    skip_before_action :check_content_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
-                                                   :chunk_upload_blob, :push_manifest]
+    skip_before_action :check_media_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
+                                                 :chunk_upload_blob, :push_manifest]
 
     wrap_parameters false
 
@@ -200,7 +200,9 @@ module Katello
     end
 
     def pull_blob
-      r = Resources::Registry::Proxy.get(@_request.fullpath, 'Accept' => request.headers['Accept'])
+      headers = {}
+      headers['Accept'] = request.headers['Accept'] if request.headers['Accept']
+      r = Resources::Registry::Proxy.get(@_request.fullpath, headers)
       render json: r
     end
 

data/app/controllers/katello/api/rhsm/candlepin_dynflow_proxy_controller.rb

@@ -10,7 +10,7 @@ module Katello
     before_action :find_host, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
     before_action :authorize_client_or_user, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
 
-    skip_before_action :check_content_type
+    skip_before_action :check_media_type
 
     #api :PUT, "/consumers/:id/packages", N_("Update installed packages")
     #api :PUT, "/consumers/:id/profile", N_("Update installed packages")

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -26,7 +26,7 @@ module Katello
     before_action :set_organization_id, :except => [:hypervisors_update, :async_hypervisors_update]
     before_action :find_hypervisor_organization, :only => [:async_hypervisors_update, :hypervisors_update]
 
-    before_action :check_content_type, :except => :async_hypervisors_update
+    before_action :check_media_type, :except => :async_hypervisors_update
 
     prepend_before_action :convert_owner_to_organization_id, :except => [:hypervisors_update, :async_hypervisors_update], :if => lambda { params.key?(:owner) }
     prepend_before_action :convert_organization_label_to_id, :only => [:rhsm_index, :consumer_activate, :consumer_create], :if => lambda { params.key?(:organization_id) }

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

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::ActivationKeysController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -11,6 +12,7 @@ module Katello
                                                   :content_override, :add_subscriptions, :remove_subscriptions,
                                                   :subscriptions]
     before_action :authorize
+    before_action :verify_simple_content_access_disabled, :only => [:add_subscriptions]
 
     wrap_parameters :include => (ActivationKey.attribute_names + %w(host_collection_ids service_level auto_attach purpose_role purpose_usage purpose_addons content_view_environment))
 
@@ -348,5 +350,11 @@ module Katello
 
       key_params
     end
+
+    def verify_simple_content_access_disabled
+      if @activation_key.organization.simple_content_access?
+        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
+      end
+    end
   end
 end

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

@@ -5,7 +5,7 @@ module Katello
     include Api::V2::Rendering
     include Api::V2::ErrorHandling
     include ::Foreman::Controller::CsvResponder
-    include Concerns::Api::V2::AssociationsPermissionCheck
+    include Concerns::Api::V2::Authorization
 
     # support for session (thread-local) variables must be the last filter in this class
     include Foreman::ThreadSession::Cleaner

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

@@ -4,7 +4,7 @@ module Katello
     before_action :authorize
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
     before_action :find_content_credential, :only => [:show, :update, :destroy, :content, :set_content]
-    skip_before_action :check_content_type, :only => [:create, :content, :set_content]
+    skip_before_action :check_media_type, :only => [:create, :content, :set_content]
 
     def resource_class
       Katello::GpgKey

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

@@ -1,7 +1,7 @@
 module Katello
   class Api::V2::ContentUploadsController < Api::V2::ApiController
     before_action :find_repository
-    skip_before_action :check_content_type, :only => [:update]
+    skip_before_action :check_media_type, :only => [:update]
 
     include ::Foreman::Controller::FilterParameters
     filter_parameters :content
@@ -13,8 +13,8 @@ module Katello
     param :content_type, RepositoryTypeManager.uploadable_content_types.map(&:label), :required => false, :desc => N_("content type ('deb', 'docker_manifest', 'file', 'ostree', 'puppet_module', 'rpm', 'srpm')")
     def create
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type).default_managed_content_type.label
-      unit_type_id = SmartProxy.pulp_master.content_service(content_type).content_type
-      render :json => @repository.backend_content_service(::SmartProxy.pulp_master).create_upload(params[:size], params[:checksum], unit_type_id)
+      unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
+      render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id)
     end
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")
@@ -24,7 +24,7 @@ module Katello
     param :offset, :number, :required => true, :desc => N_("The offset in the file where the content starts")
     param :content, File, :required => true, :desc => N_("The actual file contents")
     def update
-      @repository.backend_content_service(::SmartProxy.pulp_master)
+      @repository.backend_content_service(::SmartProxy.pulp_primary)
         .upload_chunk(params[:id], params[:offset], params[:content], params[:size])
       head :no_content
     end
@@ -33,7 +33,7 @@ module Katello
     param :repository_id, :number, :required => true, :desc => N_("Repository id")
     param :id, String, :required => true, :desc => N_("Upload request id")
     def destroy
-      @repository.backend_content_service(::SmartProxy.pulp_master).delete_upload(params[:id])
+      @repository.backend_content_service(::SmartProxy.pulp_primary).delete_upload(params[:id])
       head :no_content
     end
 

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

@@ -0,0 +1,47 @@
+module Katello
+  class Api::V2::ContentViewRepositoriesController < Api::V2::ApiController
+    # There are other Content View Repository related endpoints that are in RepositoriesController
+    include Katello::Concerns::FilteredAutoCompleteSearch
+
+    before_action :find_content_view
+    before_action :find_organization_from_cv
+
+    # content_views/:id/repositories/show_all
+    # Shows all repositories, added and available to add, for a content view
+    # Undocumented endpoint since the functionality exists in separate calls already.
+    # This was created for ease of pagination and search for the UI
+    param :id, :number, desc: N_("Content View id"), required: true
+    def show_all
+      kr = Katello::Repository.table_name
+      krr = Katello::RootRepository.table_name
+      kcvr = Katello::ContentViewRepository.table_name
+      join_query = <<-SQL
+        LEFT OUTER JOIN #{kcvr}
+        ON #{kr}.id = #{kcvr}.repository_id
+        AND #{kcvr}.content_view_id = #{@content_view.id}
+      SQL
+      order_query = <<-SQL
+        CAST (#{kcvr}.repository_id as BOOLEAN) ASC, #{krr}.name
+      SQL
+
+      query = Katello::Repository.readable.in_default_view.in_organization(@organization)
+      # Use custom sort to perform the join and order since we need to order by specific content_view
+      # and the ORDER BY query needs access to the katello_content_view_repositories table
+      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(order_query) }
+      options = { resource_class: Katello::Repository, custom_sort: custom_sort }
+      repos = scoped_search(query, nil, nil, options)
+
+      respond_for_index(:collection => repos)
+    end
+
+    private
+
+    def find_content_view
+      @content_view = ContentView.find(params[:content_view_id])
+    end
+
+    def find_organization_from_cv
+      @organization = @content_view.organization
+    end
+  end
+end

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

@@ -82,33 +82,72 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :POST, "/content_view_versions/:id/export", N_("Export a content view version"), :deprecated => true
+    api :GET, "/content_view_versions/export_histories", N_("Show the export history for a content view version")
+    param :content_view_version_id, :number, :desc => N_("Content view version identifier"), :required => false
+    param :content_view_id, :number, :desc => N_("Content view identifier"), :required => false
+    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
+    param :organization_id, :number, :desc => N_("Organization identifier"), :required => false
+    param_group :search, Api::V2::ApiController
+    add_scoped_search_description_for(ContentViewVersionExportHistory)
+    def export_histories
+      history = ContentViewVersionExportHistory.readable
+      history = history.where(:content_view_version_id => params[:content_view_version_id]) unless params[:content_view_version_id].blank?
+      history = history.where(:destination_server => params[:destination_server]) unless params[:destination_server].blank?
+      history = history.with_organization_id(params[:organization_id]) unless params[:organization_id].blank?
+      history = history.with_content_view_id(params[:content_view_id]) unless params[:content_view_id].blank?
+      respond_for_index(:collection => scoped_search(history, 'id', 'asc', resource_class: ContentViewVersionExportHistory),
+                        :template => '../../../api/v2/content_view_version_export_histories/index')
+    end
+
+    api :POST, "/content_view_versions/:id/export", N_("Export a content view version")
     param :id, :number, :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
+    param :destination_server, String, :desc => N_("Destination Server name, required for Pulp3")
+    param :export_to_iso, :bool, :desc => N_("Export to ISO format. Relevant only for Pulp 2 repositories"), :required => false
+    param :iso_mb_size, :number, :desc => N_("maximum size of each ISO in MB. Relevant only for Pulp 2 repositories"), :required => false
+    param :since, Date, :desc => N_("Optional date of last export (ex: 2010-01-01T12:00:00Z). Relevant only for Pulp 2 repositories"), :required => false
     def export
-      ::Foreman::Deprecation.api_deprecation_warning("Export is being deprecated and will be removed in a future version of Katello. Use hammer content-view version export instead.")
-      if params[:export_to_iso].blank? && params[:iso_mb_size].present?
-        fail HttpErrors::BadRequest, _("ISO export must be enabled when specifying ISO size")
-      end
+      if SmartProxy.pulp_primary.pulp3_repository_type_support?(Katello::Repository::YUM_TYPE)
+        invalid_params = [:export_to_iso, :iso_mb_size, :since].reject { |param| params[param].blank? }
+        unless invalid_params.empty?
+          fail HttpErrors::BadRequest, _("Invalid parameters provided - %{params}. These are only relevant for Pulp 2 repositories" % { params: invalid_params.join(', ')})
+        end
 
-      if (repos = @version.content_view.on_demand_repositories).any?
-        fail HttpErrors::BadRequest, _("This content view has on demand repositories that cannot be exported: %{repos}" % {repos: repos.pluck(:label).join(", ")})
-      end
+        if params[:destination_server].blank?
+          fail HttpErrors::BadRequest, _("Destination Server Name required for Pulp3 repositories")
+        end
 
-      if params[:since].present?
-        begin
-          params[:since].to_datetime
-        rescue
-          raise HttpErrors::BadRequest, _("Invalid date provided.")
+        task = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::Export, @version, destination_server: params[:destination_server])
+      else
+        ::Foreman::Deprecation.api_deprecation_warning("Export is being deprecated and will be removed in a future version of Katello. Use hammer content-view version export instead.")
+        if params[:export_to_iso].blank? && params[:iso_mb_size].present?
+          fail HttpErrors::BadRequest, _("ISO export must be enabled when specifying ISO size")
         end
+
+        if (repos = @version.content_view.on_demand_repositories).any?
+          fail HttpErrors::BadRequest, _("This content view has on demand repositories that cannot be exported: %{repos}" % {repos: repos.pluck(:label).join(", ")})
+        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])
       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 :POST, "/content_view_versions/import", N_("Import a content view version")
+    param :content_view_id, :number, :desc => N_("Content view identifier"), :required => true
+    param :path, String, :desc => N_("Import path"), :required => true
+    def import
+      task = async_task(::Actions::Katello::ContentViewVersion::Import, @view, path: params[:path])
       respond_for_async :resource => task
     end
 

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

@@ -5,7 +5,7 @@ module Katello
     before_action :authorize
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
     before_action :find_gpg_key, :only => [:show, :update, :destroy, :content, :set_content]
-    skip_before_action :check_content_type, :only => [:create, :content, :set_content]
+    skip_before_action :check_media_type, :only => [:create, :content, :set_content]
 
     def_param_group :gpg_key do
       param :name, :identifier, :action_aware => true, :required => true, :desc => N_("identifier of the gpg key")

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

@@ -39,7 +39,9 @@ module Katello
       respond_for_index :collection => @collection
     end
 
-    def index_response
+    def index_response(reload_host = false)
+      # Host needs to be reloaded because of lazy accessor
+      @host.reload if reload_host
       entitlements = @host.subscription_facet.candlepin_consumer.entitlements
       subscriptions = entitlements.map { |entitlement| ::Katello::HostSubscriptionPresenter.new(entitlement) }
       full_result_response(subscriptions)
@@ -53,7 +55,7 @@ module Katello
       end
 
       sync_task(::Actions::Katello::Host::AutoAttachSubscriptions, @host)
-      respond_for_index(:collection => index_response, :template => "index")
+      respond_for_index(:collection => index_response(true), :template => "index")
     end
 
     api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")
@@ -124,7 +126,7 @@ module Katello
       end
 
       sync_task(::Actions::Katello::Host::RemoveSubscriptions, @host, pool_id_quantities.values)
-      respond_for_index(:collection => index_response, :template => "index")
+      respond_for_index(:collection => index_response(true), :template => "index")
     end
 
     api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host")
@@ -134,12 +136,16 @@ module Katello
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def add_subscriptions
+      if @host.organization.simple_content_access?
+        fail ::Katello::HttpErrors::BadRequest, _("This host's organization is in Simple Content Access mode. Attaching subscriptions is disabled.")
+      end
+
       pools_with_quantities = params.require(:subscriptions).map do |sub_params|
         PoolWithQuantities.new(Pool.with_identifier(sub_params['id']), sub_params['quantity'].to_i)
       end
 
       sync_task(::Actions::Katello::Host::AttachSubscriptions, @host, pools_with_quantities)
-      respond_for_index(:collection => index_response, :template => "index")
+      respond_for_index(:collection => index_response(true), :template => "index")
     end
 
     api :PUT, "/hosts/:host_id/subscriptions/content_override", N_("Set content overrides for the host")

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

@@ -1,6 +1,11 @@
 module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
-    before_action :find_host, :only => :index
+    before_action :find_host
+
+    resource_description do
+      api_version 'v2'
+      api_base_url "/api"
+    end
 
     api :GET, "/hosts/:host_id/traces", N_("List services that need restarting on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
@@ -9,43 +14,18 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/traces/resolve", N_("Resolve Traces")
+    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve Traces")
+    param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
     def resolve
-      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
-
-      traces.each do |trace|
-        if trace.reboot_required?
-          trace.helper = 'reboot'
-        end
-      end
-
-      traces_by_host_id = traces.group_by(&:host_id)
-      traces_by_helper = traces.group_by(&:helper)
-
-      composers = []
-
-      if traces_by_host_id.size < traces_by_helper.size
-        traces_by_host_id.each do |host_id, trace|
-          needed_traces = trace.map(&:helper).join(',')
-          joined_helpers = { :helper => needed_traces }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, [host_id], joined_helpers)
-        end
-      else
-        traces_by_helper.each do |helper, trace|
-          helpers = { :helper => helper }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, trace.map(&:host_id), helpers)
-        end
-      end
-
-      job_invocations = []
-
-      composers.each do |composer|
-        composer.trigger
-        job_invocations << composer.job_invocation
-      end
-
-      render json: job_invocations
+      traces = @host.host_traces.resolvable.where(id: params[:trace_ids])
+      fail HttpErrors::BadRequest, _("The requested traces were not found for this host") if traces.empty?
+
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      task = ForemanTasks::Task.find(result.first.task_id)
+
+      respond_for_async(resource: task)
     end
 
     protected

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

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -6,13 +7,15 @@ module Katello
     before_action :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, :only => [:environment_content_view]
     before_action :find_content_view, :only => [:environment_content_view]
-    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata]
+    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata, :resolve_traces]
     before_action :find_deletable_hosts, :only => [:destroy_hosts]
     before_action :find_readable_hosts, :only => [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, :only => [:available_incremental_updates]
+    before_action :find_organization, :only => [:add_subscriptions]
     before_action :deprecate_katello_agent, :only => [:install_content, :update_content, :remove_content]
 
     before_action :validate_content_action, :only => [:install_content, :update_content, :remove_content]
+    before_action :validate_organization, :only => [:add_subscriptions]
 
     # disable *_count fields on erratum rabl, since they perform N+1 queries
     before_action :disable_erratum_hosts_count
@@ -173,6 +176,10 @@ module Katello
       param :quantity, :number, :desc => N_("Quantity of this subscriptions to add"), :required => true
     end
     def add_subscriptions
+      if @organization.simple_content_access?
+        fail HttpErrors::BadRequest, _("The specified organization is in Simple Content Access mode. Attaching subscriptions is disabled")
+      end
+
       pools_with_quantities = params.require(:subscriptions).map do |sub_params|
         PoolWithQuantities.new(Pool.find(sub_params['id']), sub_params['quantity'])
       end
@@ -230,6 +237,16 @@ module Katello
       respond_for_index(:collection => collection, :template => '../../../api/v2/host_tracer/index')
     end
 
+    api :PUT, "/hosts/bulk/resolve_traces", N_("Resolve traces for one or more hosts")
+    param_group :bulk_params
+    param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
+    def resolve_traces
+      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      render json: result
+    end
+
     api :POST, "/hosts/bulk/available_incremental_updates", N_("Given a set of hosts and errata, lists the content view versions" \
                                                                  " and environments that need updating.")
     param_group :bulk_params
@@ -295,6 +312,10 @@ module Katello
       find_bulk_hosts(:destroy_hosts, params)
     end
 
+    def validate_organization
+      fail HttpErrors::BadRequest, _("Organization ID is required") if @organization.blank?
+    end
+
     def validate_host_collection_membership_limit
       max_hosts_exceeded = []
       host_ids = @hosts.map(&:id)