Plugins » Katello » Runcible

module Runcible

  module Extensions

    class Unit < Runcible::Resources::Unit

      # The content type (e.g. rpm, errata)

      def self.content_type

        fail 'Content type not defined'

      end

      def content_type

        self.class.content_type

      end

      # Retrieves all content of a certain @@type

      #

      # @return [RestClient::Response]  list of all content for the given type

      def all

        search(content_type, {})

      end

      # Retrieves a single content by it's content ID

      #

      # @param  [Array]                id   the content ID of the content to retrieve

      # @return [RestClient::Response]      the requested content

      def find(id, optional = {})

        find_all([id], optional).first

      end

      # Retrieves a set of content by the contents IDs

      #

      # @param  [Array]                ids  list of content IDs to retrieve

      # @return [RestClient::Response]      list of content

      def find_all(ids, optional = {})

        optional[:include_repos] = optional.fetch(:include_repos, true)

        search(content_type, { :filters => {'id' => {'$in' => ids}} }, optional)

      end

      # Retrieves a single content by it's unit ID

      #

      # @param  [Array]                id   the unit ID of the content to retrieve

      # @return [RestClient::Response]      the requested content

      def find_by_unit_id(id, optional = {})

        find_all_by_unit_ids([id], [], optional).first

      end

      # Retrieves a set of content by the Pulp unit IDs

      #

      # @param  [Array]                ids    list of content unit IDs to retrieve

      # @param  [Array]                fields optional list of to retrieve

      # @return [RestClient::Response]        list of content

      def find_all_by_unit_ids(ids, fields = [], optional = {})

        optional[:include_repos] = optional.fetch(:include_repos, true)

        criteria = { :filters => { :_id => { '$in' => ids } } }

        criteria[:fields] = fields unless fields.empty?

        search(content_type, criteria, optional)

      end

      # unassociates content units from a repository

      #

      # @param  [String]                repo_id the repository ID to remove units from

      # @param  [Hash]                  filters the filters to find the units  this content type to remove

      # @return [RestClient::Response]          a task representing the unit unassociate operation

      def unassociate_from_repo(repo_id, filters)

        criteria = {:type_ids => [content_type]}

        criteria[:filters] = filters

        Runcible::Extensions::Repository.new(self.config).unassociate_units(repo_id, criteria)

      end

      # unassociates content units from a repository

      #

      # @param  [String]                repo_id the repository ID to remove units from

      # @param  [Array]                 ids  list of content unit ids of this

      #                                      content type, aka metadata id or content id

      #                                       ex: "RHEA-2010:0001" for errata..,

      #                                       Note rpms do not have ids, so cant use this.

      # @return [RestClient::Response]          a task representing the unit unassociate operation

      def unassociate_ids_from_repo(repo_id, ids)

        unassociate_from_repo(repo_id, :unit => {'id' => {'$in' => ids}})

      end

      # unassociates content units from a repository

      #

      # @param  [String]                repo_id the repository ID to remove units from

      # @param  [Array]                 ids list of the unique hash ids of the content unit

      #                                     with respect to this repo. unit_id, id are other names for this.

      #                                     for example: "efdd2d63-b275-4728-a298-f68cf4c174e7"

      #

      # @return [RestClient::Response]          a task representing the unit unassociate operation

      def unassociate_unit_ids_from_repo(repo_id, ids)

        unassociate_from_repo(repo_id, :association => {'unit_id' => {'$in' => ids}})

      end

      #copy contents from source repo to the destination repo

      #

      # @param  [String]                source_repo_id      the source repository ID

      # @param  [String]                destination_repo_id the destination repository ID

      # @param  [Hash]                  optional            container for all optional parameters

      # @return [RestClient::Response]                      a task representing the unit copy operation

      def copy(source_repo_id, destination_repo_id, optional = {})

        criteria = {:type_ids => [content_type], :filters => {}}

        criteria[:filters]['association'] = {'unit_id' => {'$in' => optional[:ids]}} if optional[:ids]

        criteria[:filters] = optional[:filters] if optional[:filters]

        criteria[:fields] = {:unit => optional[:fields]} if optional[:fields]

        payload = {:criteria => criteria}

        payload[:override_config] = optional[:override_config] if optional.key?(:override_config)

        if optional[:copy_children]

          payload[:override_config] ||= {}

          payload[:override_config][:recursive] = true

        end

        Runcible::Extensions::Repository.new(self.config).unit_copy(destination_repo_id, source_repo_id, payload)

      end

    end

  end

end