katello 1.5.0 → 2.2.2

data/app/models/katello/glue/candlepin/owner_info.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2013 Red Hat, Inc.
+# Copyright 2014 Red Hat, Inc.
 #
 # This software is licensed to you under the GNU General Public
 # License as published by the Free Software Foundation; either version
@@ -11,45 +11,43 @@
 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 
 module Katello
-class Glue::Candlepin::OwnerInfo
-
-  def initialize(organization)
-    @info = Resources::Candlepin::OwnerInfo.find(organization.label)
-  end
+  class Glue::Candlepin::OwnerInfo
+    def initialize(organization)
+      @info = Resources::Candlepin::OwnerInfo.find(organization.label)
+    end
 
-  def total_consumers
-    @info['consumerCounts']['system']
-  end
+    def total_consumers
+      @info['consumerCounts']['system']
+    end
 
-  def total_invalid_compliance_consumers
-    i = @info['consumerCountsByComplianceStatus']['invalid'] ||= 0
-    f = @info['consumerCountsByComplianceStatus']['false'] ||= 0
-    return i + f
-  end
+    def total_invalid_compliance_consumers
+      i = @info['consumerCountsByComplianceStatus']['invalid'] ||= 0
+      f = @info['consumerCountsByComplianceStatus']['false'] ||= 0
+      return i + f
+    end
 
-  def total_valid_compliance_consumers
-    # Systems that are hand-created (eg. through "New System" button) are by definition green.
-    # To account for this, simply take the total count and subtract the red and yellow counts.
-    #v = @info['consumerCountsByComplianceStatus']['valid'] ||= 0
-    #t = @info['consumerCountsByComplianceStatus']['true'] ||= 0
+    def total_valid_compliance_consumers
+      # Systems that are hand-created (eg. through "New System" button) are by definition green.
+      # To account for this, simply take the total count and subtract the red and yellow counts.
+      #v = @info['consumerCountsByComplianceStatus']['valid'] ||= 0
+      #t = @info['consumerCountsByComplianceStatus']['true'] ||= 0
 
-    return self.total_consumers - self.total_invalid_compliance_consumers - self.total_partial_compliance_consumers
-  end
+      return self.total_consumers - self.total_invalid_compliance_consumers - self.total_partial_compliance_consumers
+    end
 
-  def total_partial_compliance_consumers
-    @info['consumerCountsByComplianceStatus']['partial'] ||= 0
-  end
+    def total_partial_compliance_consumers
+      @info['consumerCountsByComplianceStatus']['partial'] ||= 0
+    end
 
-  private
+    private
 
-  def find_value(set_key, value_type, entry_type)
-    @info[set_key].each do |hash|
-      if hash['valueType'] == value_type && hash['entryType'] == entry_type
-        return hash['value']
+    def find_value(set_key, value_type, entry_type)
+      @info[set_key].each do |hash|
+        if hash['valueType'] == value_type && hash['entryType'] == entry_type
+          return hash['value']
+        end
       end
+      nil
     end
-    nil
   end
-
-end
 end

data/app/models/katello/glue/candlepin/pool.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2013 Red Hat, Inc.
+# Copyright 2014 Red Hat, Inc.
 #
 # This software is licensed to you under the GNU General Public
 # License as published by the Free Software Foundation; either version
@@ -11,171 +11,190 @@
 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 
 module Katello
-module Glue::Candlepin::Pool
-
-  def self.included(base)
-    base.send :include, LazyAccessor
-    base.send :include, InstanceMethods
-    base.send :extend, ClassMethods
-
-    base.class_eval do
-      lazy_accessor :remote_data, :pool_derived, :product_name, :consumed, :quantity, :available, :support_level, :support_type,
-        :start_date, :end_date, :attrs, :owner, :product_id, :account_number, :contract_number,
-        :source_pool_id, :host_id, :virt_only, :virt_limit, :multi_entitlement, :stacking_id,
-        :arch, :sockets, :cores, :ram, :description, :product_family, :variant, :provided_products,
-        :active, :instance_multiplier, :suggested_quantity,
-        :initializer => (lambda do |s|
-                           json = Resources::Candlepin::Pool.find(cp_id)
-                           # symbol "attributes" is reserved by Rails and cannot be used
-                           json['attrs'] = json['attributes']
-                           json
-                         end)
+  module Glue::Candlepin::Pool
+    def self.included(base)
+      base.send :include, LazyAccessor
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval do
+        lazy_accessor :remote_data, :pool_derived, :product_name, :consumed, :quantity, :available, :support_level, :support_type,
+          :start_date, :end_date, :attrs, :owner, :product_id, :account_number, :contract_number,
+          :source_pool_id, :host_id, :virt_only, :virt_limit, :multi_entitlement, :stacking_id,
+          :arch, :sockets, :cores, :ram, :description, :product_family, :variant, :provided_products,
+          :active, :instance_multiplier, :suggested_quantity, :unmapped_guest,
+          :initializer => (lambda do |_s|
+                             json = Resources::Candlepin::Pool.find(cp_id)
+                             # symbol "attributes" is reserved by Rails and cannot be used
+                             json['attrs'] = json['attributes']
+                             json
+                           end)
+      end
     end
-  end
 
-  module ClassMethods
-    def find_by_organization_and_id(organization, pool_id)
-      pool = Katello::Pool.find_by_cp_id(pool_id) || Pool.new(Resources::Candlepin::Pool.find(pool_id))
-      if pool.organization == organization
-        return pool
+    module ClassMethods
+      def find_by_organization_and_id(organization, pool_id)
+        pool = Katello::Pool.find_by_cp_id(pool_id.to_s) || Pool.new(Resources::Candlepin::Pool.find(pool_id))
+        if pool.organization == organization
+          return pool
+        end
       end
-    end
 
-    def find_by_organization_and_id!(organization, pool_id)
-      subscription = find_by_organization_and_id(organization, pool_id)
-      fail ActiveRecord::RecordNotFound if subscription.nil?
-      subscription
-    end
-  end
+      def find_by_organization_and_id!(organization, pool_id)
+        subscription = find_by_organization_and_id(organization, pool_id)
+        fail ActiveRecord::RecordNotFound if subscription.nil?
+        subscription
+      end
 
-  module InstanceMethods
+      def find_by_id(pool_id)
+        Katello::Pool.find_by_cp_id(pool_id) || Pool.new(Resources::Candlepin::Pool.find(pool_id))
+      end
 
-    def initialize(attrs = nil, options = {})
-      if !attrs.nil? && attrs.member?('id')
-        # initializing from candlepin json
-        load_remote_data(attrs)
-        super({:cp_id => attrs['id']}, options)
-      else
-        super
+      def find_by_id!(pool_id)
+        subscription = find_by_id(pool_id)
+        fail ActiveRecord::RecordNotFound if subscription.nil?
+        subscription
       end
     end
 
-    def organization
-      Organization.find_by_label(self.owner["key"])
-    end
+    module InstanceMethods
+      def initialize(attrs = nil, options = {})
+        if !attrs.nil? && attrs.member?('id')
+          # initializing from candlepin json
+          load_remote_data(attrs)
+          super({:cp_id => attrs['id']}, options)
+        else
+          super
+        end
+      end
 
-    # if defined +load_remote_data+ will be used by +lazy_accessors+
-    # to define instance variables
-    # TODO: break up method
-    # rubocop:disable MethodLength
-    def load_remote_data(attrs)
-      @remote_data = attrs
-      @product_name = attrs["productName"]
-      @start_date = Date.parse(attrs["startDate"]) if attrs["startDate"]
-      @end_date = Date.parse(attrs["endDate"]) if attrs["endDate"]
-      @consumed = attrs["consumed"]
-      @quantity = attrs["quantity"]
-      if attrs["quantity"].is_a?(Integer) && attrs["consumed"].is_a?(Integer)
-        @available = attrs["quantity"] - attrs["consumed"]
-      else
-        @available = 0
+      def organization
+        Organization.find_by_label(self.owner["key"])
       end
-      @attrs = attrs["attributes"]
-      @owner = attrs["owner"]
-      @product_id = attrs["productId"]
-      @cp_id = attrs['id']
-      @account_number = attrs['accountNumber']
-      @contract_number = attrs['contractNumber']
-      @provided_products = attrs['providedProducts']
-      @active = attrs['activeSubscription']
-      @source_pool_id = nil
-      @host_id = nil
-      @virt_only = false
-      @pool_derived = false
-      attrs['attributes'].each do |attr|
-        case attr['name']
-        when 'source_pool_id'
-          @source_pool_id = attr['value']
-        when 'requires_host'
-          @host_id = attr['value']
-        when 'virt_only'
-          @virt_only = attr['value'] == 'true' ? true : false
-        when 'pool_derived'
-          @pool_derived = attr['value'] == 'true' ? true : false
-        end
-      end if attrs['attributes']
-      @virt_limit = 0
-      @support_type = ""
-      @arch = ""
-      @support_level = ""
-      @sockets = 0
-      @ram = 0
-      @cores = 0
-      @description = ""
-      @product_family = ""
-      @variant = ""
-      @multi_entitlement = false
-      @stacking_id = ""
-      attrs['productAttributes'].each do |attr|
-        case attr['name']
-        when 'virt_limit'
-          @virt_limit = attr['value'].to_i
-        when 'support_type'
-          @support_type = attr['value']
-        when 'arch'
-          @arch = attr['value']
-        when 'support_level'
-          @support_level = attr['value']
-        when 'sockets'
-          @sockets = attr['value'].to_i
-        when 'cores'
-          @cores = attr['value'].to_i
-        when 'ram'
-          @ram = attr['value'].to_i
-        when 'description'
-          @description = attr['value']
-        when 'product_family'
-          @product_family = attr['value']
-        when 'variant'
-          @variant = attr['value']
-        when 'multi-entitlement'
-          @multi_entitlement = (attr['value'] == 'true' || attr['value'] == 'yes') ? true : false
-        when 'stacking_id'
-          @stacking_id = attr['value']
-        when 'instance_multiplier'
-          @instance_multiplier = attr['value'].to_i
-        end
-      end if attrs['productAttributes']
 
-      @suggested_quantity = 1
-      attrs['calculatedAttributes'].each_key do |key|
-        case key
-        when 'suggested_quantity'
-          @suggested_quantity = attrs['calculatedAttributes']['suggested_quantity'].to_i
+      # if defined +load_remote_data+ will be used by +lazy_accessors+
+      # to define instance variables
+      # TODO: break up method
+      # rubocop:disable MethodLength
+      # rubocop:disable CyclomaticComplexity
+      def load_remote_data(attrs)
+        @amount = attrs["amount"]
+        @remote_data = attrs
+        @product_name = attrs["productName"]
+        @start_date = Date.parse(attrs["startDate"]) if attrs["startDate"]
+        @end_date = Date.parse(attrs["endDate"]) if attrs["endDate"]
+        @consumed = attrs["consumed"]
+        @quantity = attrs["quantity"]
+        if attrs["quantity"].is_a?(Integer) && attrs["consumed"].is_a?(Integer)
+          @available = attrs["quantity"] - attrs["consumed"]
+        else
+          @available = 0
         end
-      end if attrs['calculatedAttributes']
-    end
+        @attrs = attrs["attributes"]
+        @owner = attrs["owner"]
+        @product_id = attrs["productId"]
+        @cp_id = attrs['id']
+        @account_number = attrs['accountNumber']
+        @contract_number = attrs['contractNumber']
+        @provided_products = attrs['providedProducts']
+        @active = attrs['activeSubscription']
+        @source_pool_id = nil
+        @host_id = nil
+        @virt_only = false
+        @pool_derived = false
+        @unmapped_guest = false
+        attrs['attributes'].each do |attr|
+          case attr['name']
+          when 'source_pool_id'
+            @source_pool_id = attr['value']
+          when 'requires_host'
+            @host_id = attr['value']
+          when 'virt_only'
+            @virt_only = attr['value'] == 'true' ? true : false
+          when 'pool_derived'
+            @pool_derived = attr['value'] == 'true' ? true : false
+          when 'unmapped_guests_only'
+            @unmapped_guest = attr['value'] == 'true' ? true : false
+          end
+        end if attrs['attributes']
+        @virt_limit = 0
+        @support_type = ""
+        @arch = ""
+        @support_level = ""
+        @sockets = 0
+        @ram = 0
+        @cores = 0
+        @description = ""
+        @product_family = ""
+        @variant = ""
+        @multi_entitlement = false
+        @stacking_id = ""
+        attrs['productAttributes'].each do |attr|
+          case attr['name']
+          when 'virt_limit'
+            @virt_limit = attr['value'].to_i
+          when 'support_type'
+            @support_type = attr['value']
+          when 'arch'
+            @arch = attr['value']
+          when 'support_level'
+            @support_level = attr['value']
+          when 'sockets'
+            @sockets = attr['value'].to_i
+          when 'cores'
+            @cores = attr['value'].to_i
+          when 'ram'
+            @ram = attr['value'].to_i
+          when 'description'
+            @description = attr['value']
+          when 'product_family'
+            @product_family = attr['value']
+          when 'variant'
+            @variant = attr['value']
+          when 'multi-entitlement'
+            @multi_entitlement = (attr['value'] == 'true' || attr['value'] == 'yes') ? true : false
+          when 'stacking_id'
+            @stacking_id = attr['value']
+          when 'instance_multiplier'
+            @instance_multiplier = attr['value'].to_i
+          end
+        end if attrs['productAttributes']
+
+        @suggested_quantity = 1
+        attrs['calculatedAttributes'].each_key do |key|
+          case key
+          when 'suggested_quantity'
+            @suggested_quantity = attrs['calculatedAttributes']['suggested_quantity'].to_i
+          end
+        end if attrs['calculatedAttributes']
+      end
 
-    def products
-      Product.where(:cp_id => provided_products.map { |prod| prod[:productId] })
-    end
+      def products
+        Katello::Product.where(:cp_id => provided_products.map { |prod| prod[:productId] })
+      end
 
-    def systems
-      System.all_by_pool(cp_id)
-    end
+      def systems
+        System.all_by_pool(cp_id)
+      end
 
-    def activation_keys
-      ActivationKey.joins(:pools).where("#{self.class.table_name}.cp_id" => cp_id)
-    end
+      def activation_keys
+        keys = Resources::Candlepin::ActivationKey.get(nil, "?include=id&include=pools.pool.id")
+        activation_key_ids = keys.collect do |key|
+          key['id'] if key['pools'].any? { |pool| pool['pool']['id'] == cp_id }
+        end
 
-    def distributors
-      Distributor.all_by_pool(cp_id)
-    end
+        return Katello::ActivationKey.where(:cp_id => activation_key_ids.compact)
+      end
 
-    def host
-      System.find_by_uuid(host_id) if host_id
-    end
+      def distributors
+        Distributor.all_by_pool(cp_id)
+      end
 
+      def host
+        System.find_by_uuid(host_id) if host_id
+      end
+
+      attr_reader :amount
+    end
   end
 end
-end

data/app/models/katello/glue/candlepin/product.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2013 Red Hat, Inc.
+# Copyright 2014 Red Hat, Inc.
 #
 # This software is licensed to you under the GNU General Public
 # License as published by the Free Software Foundation; either version
@@ -11,355 +11,179 @@
 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
 
 module Katello
-module Glue::Candlepin::Product
-
-  def self.included(base)
-    base.send :include, LazyAccessor
-    base.send :include, InstanceMethods
-
-    base.class_eval do
-      lazy_accessor :productContent, :multiplier, :href, :attrs,
-        :initializer => lambda {|s| convert_from_cp_fields(Resources::Candlepin::Product.get(cp_id)[0]) }
-      # Entitlement Certificate for this product
-      lazy_accessor :certificate,
-        :initializer => lambda {|s| Resources::Candlepin::Product.certificate(cp_id, self.organization.label) },
-        :unless => lambda {|s| cp_id.nil? }
-      # Entitlement Key for this product
-      lazy_accessor :key, :initializer => lambda {|s| Resources::Candlepin::Product.key(cp_id, self.organization.label) }, :unless => lambda {|s| cp_id.nil? }
-
-      before_save :save_product_orchestration
-      before_destroy :destroy_product_orchestration
-
-      # we must store custom logger object during product importing so we can log status
-      # from various places like callbacks
-      attr_accessor :import_logger
-
-      attr_accessible :multiplier, :attrs, :productContent, :href, :import_logger
-    end
-  end
-
-  def self.validate_name(name)
-    name.gsub(/[^a-z0-9\-_ ]/i, "")
-  end
-
-  def self.import_from_cp(attrs = nil, &block)
-    product_content_attrs = attrs.delete(:productContent) || []
-    import_logger        = attrs[:import_logger]
-
-    attrs = attrs.merge('name' => validate_name(attrs['name']), 'label' => Util::Model.labelize(attrs['name']))
-
-    product = Product.new(attrs, &block)
-    product.orchestration_for = :import_from_cp_ar_setup
-    product.save!
-    product.productContent_will_change!
-    product.productContent = product.build_product_content(product_content_attrs)
-    product.orchestration_for = :import_from_cp
-    product.save!
-
-  rescue => e
-    [Rails.logger, import_logger].each do |logger|
-      logger.error "Failed to create product #{attrs['name']}: #{e}" if logger
-    end
-    raise e
-  end
-
-  def self.import_marketing_from_cp(attrs, engineering_product_ids, &block)
-    attrs = attrs.merge('name' => validate_name(attrs['name']), 'label' => Util::Model.labelize(attrs['name']))
-
-    product = MarketingProduct.new(attrs, &block)
-    product.orchestration_for = :import_from_cp_ar_setup
-    product.save!
-    engineering_product_ids.each do |engineering_product_id|
-      product.marketing_engineering_products.create(:engineering_product_id => engineering_product_id)
-    end
-    product
-  rescue => e
-    Rails.logger.error "Failed to create product #{attrs['name']}: #{e}, #{e.backtrace.join("\n")}"
-    raise e
-  end
-
-  module InstanceMethods
-
-    def initialize(attribs = nil, options = {})
-      unless attribs.nil?
-        attributes_key = attribs.key?(:attributes) ? :attributes : 'attributes'
-        if attribs.key?(attributes_key)
-          attribs[:attrs] = attribs[attributes_key]
-          attribs.delete(attributes_key)
-        end
-
-        @productContent = [] unless attribs.key?(:productContent)
-
-        # ugh. hack-ish. otherwise we have to modify code every time things change on cp side
-        attribs = attribs.reject do |k, v|
-          !self.class.column_defaults.keys.member?(k.to_s) && (!respond_to?(:"#{k.to_s}=") rescue true)
-        end
+  module Glue::Candlepin::Product
+    def self.included(base)
+      base.send :include, LazyAccessor
+      base.send :include, InstanceMethods
+
+      base.class_eval do
+        lazy_accessor :productContent, :multiplier, :href, :attrs,
+          :initializer => lambda { |_s| convert_from_cp_fields(Resources::Candlepin::Product.get(cp_id)[0]) }
+        # Entitlement Certificate for this product
+        lazy_accessor :certificate,
+          :initializer => lambda { |_s| Resources::Candlepin::Product.certificate(cp_id, self.organization.label) },
+          :unless => lambda { |_s| cp_id.nil? }
+        # Entitlement Key for this product
+        lazy_accessor :key, :initializer => lambda { |_s| Resources::Candlepin::Product.key(cp_id, self.organization.label) }, :unless => lambda { |_s| cp_id.nil? }
+
+        # we must store custom logger object during product importing so we can log status
+        # from various places like callbacks
+        attr_accessor :import_logger
+
+        attr_accessible :multiplier, :attrs, :productContent, :href, :import_logger
       end
-
-      super
     end
 
-    def orphaned?
-      self.provider.redhat_provider? && self.certificate.nil?
+    def self.validate_name(name)
+      name.gsub(/[^a-z0-9\-_ ]/i, "")
     end
 
-    def build_product_content(attrs)
-      @productContent = attrs.collect { |pc| Candlepin::ProductContent.new pc }
-    end
+    def self.import_from_cp(attrs = nil, &block)
+      product_content_attrs = attrs.delete(:productContent) || []
+      import_logger        = attrs[:import_logger]
 
-    def support_level
-      return _attr(:support_level)
-    end
+      attrs = attrs.merge('name' => validate_name(attrs['name']), 'label' => Util::Model.labelize(attrs['name']))
 
-    def arch
-      attrs.each do |attr|
-        if attr[:name] == 'arch'
-          return "noarch" if attr[:value] == 'ALL'
-          return attr[:value]
-        end
-      end
-      default_arch
-    end
+      product = Product.new(attrs, &block)
+      product.orchestration_for = :import_from_cp_ar_setup
+      product.save!
+      product.productContent_will_change!
+      product.productContent = product.build_product_content(product_content_attrs)
+      product.orchestration_for = :import_from_cp
+      product.save!
 
-    def _attr(key)
-      puts "Looking for: #{key}"
-      attrs.each do |attr|
-        puts "attr: name: #{attr[:name]} value: #{attr[:value]}"
-        if attr[:name] == key.to_s
-          return attr[:value]
-        end
-      end
-      nil
-    end
-
-    def default_arch
-      "noarch"
-    end
-
-    def convert_from_cp_fields(cp_json)
-      ar_safe_json = cp_json.key?(:attributes) ? cp_json.merge(:attrs => cp_json.delete(:attributes)) : cp_json
-      ar_safe_json[:productContent] = ar_safe_json[:productContent].collect { |pc| Candlepin::ProductContent.new(pc, self.id) }
-      ar_safe_json[:attrs] = remove_hibernate_fields(cp_json[:attrs]) if ar_safe_json.key?(:attrs)
-      ar_safe_json[:attrs] ||= []
-      ar_safe_json.except('id')
-    end
-
-    # Candlepin sends back its internal hibernate fields in the json. However it does not accept them in return
-    # when updating (PUT) objects.
-    def remove_hibernate_fields(elements)
-      return nil if !elements
-      elements.collect{ |e| e.except(:id, :created, :updated)}
-    end
-
-    def add_content(content)
-      Resources::Candlepin::Product.add_content self.cp_id, content.content.id, true
-      self.productContent << content
-    end
-
-    def remove_content_by_id(content_id)
-      Resources::Candlepin::Product.remove_content cp_id, content_id
-    end
-
-    def set_product
-      Rails.logger.debug "Creating a product in candlepin: #{name}"
-      self.attrs ||=  [{:name => "arch", :value => "ALL"}]
-      json = Resources::Candlepin::Product.create(
-        :name => self.name,
-        :multiplier => self.multiplier || 1,
-        :attributes => self.attrs # name collision with ActiveRecord
-      )
-      self.cp_id = json[:id]
     rescue => e
-      Rails.logger.error "Failed to create candlepin product #{name}: #{e}, #{e.backtrace.join("\n")}"
+      [Rails.logger, import_logger].each do |logger|
+        logger.error "Failed to create product #{attrs['name']}: #{e}" if logger
+      end
       raise e
     end
 
-    def del_product
-      return true unless no_other_assignment?
-      Rails.logger.debug "Deleting product in candlepin: #{name}"
-      Resources::Candlepin::Product.destroy self.cp_id
-      true
+    def self.import_marketing_from_cp(attrs, engineering_product_ids, &block)
+      attrs = attrs.merge('name' => validate_name(attrs['name']), 'label' => Util::Model.labelize(attrs['name']))
+
+      product = MarketingProduct.new(attrs, &block)
+      product.orchestration_for = :import_from_cp_ar_setup
+      product.save!
+      engineering_product_ids.each do |engineering_product_id|
+        product.marketing_engineering_products.create(:engineering_product_id => engineering_product_id)
+      end
+      product
     rescue => e
-      Rails.logger.error "Failed to delete candlepin product #{name}: #{e}, #{e.backtrace.join("\n")}"
+      Rails.logger.error "Failed to create product #{attrs['name']}: #{e}, #{e.backtrace.join("\n")}"
       raise e
     end
 
-    def refresh_content(content_id)
-      pc = product_content_by_id(content_id)
-      pc.refresh_repositories
-      pc
-    end
-
-    def disable_content(content_id)
-      pc = product_content_by_id(content_id)
-      pc.disable
-      pc
-    end
+    module InstanceMethods
+      def initialize(attribs = nil, options = {})
+        unless attribs.nil?
+          attributes_key = attribs.key?(:attributes) ? :attributes : 'attributes'
+          if attribs.key?(attributes_key)
+            attribs[:attrs] = attribs[attributes_key]
+            attribs.delete(attributes_key)
+          end
 
-    def product_content_by_id(content_id)
-      self.productContent.find{|pc| pc.content.id == content_id}
-    end
+          @productContent = [] unless attribs.key?(:productContent)
 
-    def product_content_by_name(content_name)
-      self.productContent.find{|pc| pc.content.name == content_name}
-    end
+          # ugh. hack-ish. otherwise we have to modify code every time things change on cp side
+          attribs = attribs.reject do |k, _v|
+            !self.class.column_defaults.keys.member?(k.to_s) && (!respond_to?(:"#{k.to_s}=") rescue true)
+          end
+        end
 
-    def set_content
-      self.productContent.each do |pc|
-        Rails.logger.debug "Creating content in candlepin: #{pc.content.name}"
-        #TODO: use json returned from cp to populate productContent
-        new_content = Resources::Candlepin::Content.create pc.content
-        pc.content.id = new_content[:id]
+        super
       end
-    rescue => e
-      Rails.logger.error "Failed to create content for product #{name} in candlepin: #{e}, #{e.backtrace.join("\n")}"
-      raise e
-    end
 
-    def del_content
-      self.productContent.each do |pc|
-        Rails.logger.debug "Deleting content in candlepin: #{pc.content.name}"
-        Resources::Candlepin::Content.destroy(pc.content.id)
+      def orphaned?
+        self.provider.redhat_provider? && self.certificate.nil?
       end
-    rescue => e
-      Rails.logger.error "Failed to delete content for product #{name} in candlepin"
-      raise e
-    end
-
-    def remove_all_content
-      return true unless no_other_assignment?
-      # engineering products handle content deletion when destroying
-      # repositories
-      return true unless self.is_a? MarketingProduct
 
-      self.productContent.each do |pc|
-        Rails.logger.debug "Removing content from product '#{self.cp_id}' in candlepin: #{pc.content.name}"
-        self.remove_content_by_id pc.content.id
+      def build_product_content(attrs)
+        @productContent = attrs.collect { |pc| Candlepin::ProductContent.new pc }
       end
-      true
-    rescue => e
-      Rails.logger.error "Failed to remove content form a product in candlepin #{name}."
-      raise e
-    end
 
-    def no_other_assignment?
-      Product.where(["cp_id = ? AND id != ?", self.cp_id, self.id]).empty?
-    end
-
-    def update_content
-      return true unless productContent_changed?
-
-      deleted_content.each do |content|
-        Rails.logger.debug "deleting content #{content.id}"
-        Resources::Candlepin::Product.remove_content cp_id, content.id
-        Resources::Candlepin::Content.destroy(content.id)
+      def support_level
+        return _attr(:support_level)
       end
 
-      added_content.each do |pc|
-        Rails.logger.debug "creating content #{pc.content.name}"
-        new_content = Resources::Candlepin::Content.create pc.content
-        pc.content.id = new_content[:id] # candlepin generates id for new content
+      def arch
+        attrs.each do |attr|
+          if attr[:name] == 'arch'
+            return "noarch" if attr[:value] == 'ALL'
+            return attr[:value]
+          end
+        end
+        default_arch
+      end
 
-        Rails.logger.debug "adding content #{pc.content.id}"
-        Resources::Candlepin::Product.add_content cp_id, pc.content.id, pc.enabled
+      def _attr(key)
+        puts "Looking for: #{key}"
+        attrs.each do |attr|
+          puts "attr: name: #{attr[:name]} value: #{attr[:value]}"
+          if attr[:name] == key.to_s
+            return attr[:value]
+          end
+        end
+        nil
       end
-    end
 
-    def set_unlimited_subscription
-      # we create unlimited subscriptions only for generic yum providers
-      if self.provider && self.provider.yum_repo?
-        Rails.logger.debug "Creating unlimited subscription for product #{name} in candlepin"
-        Resources::Candlepin::Product.create_unlimited_subscription self.organization.label, self.cp_id
+      def default_arch
+        "noarch"
       end
-      true
-    rescue => e
-      Rails.logger.error "Failed to create unlimited subscription for product in candlepin #{name}: #{e}, #{e.backtrace.join("\n")}"
-      raise e
-    end
 
-    def del_unlimited_subscription
-      # we create unlimited subscriptions only for generic yum providers
-      if self.provider && self.provider.yum_repo?
-        self.del_subscriptions
+      def convert_from_cp_fields(cp_json)
+        ar_safe_json = cp_json.key?(:attributes) ? cp_json.merge(:attrs => cp_json.delete(:attributes)) : cp_json
+        ar_safe_json[:productContent] = ar_safe_json[:productContent].collect { |pc| Candlepin::ProductContent.new(pc, self.id) }
+        ar_safe_json[:attrs] = remove_hibernate_fields(cp_json[:attrs]) if ar_safe_json.key?(:attrs)
+        ar_safe_json[:attrs] ||= []
+        ar_safe_json.except('id')
       end
-    end
 
-    def del_pools
-      Rails.logger.debug "Deleting pools for product #{name} in candlepin"
-      Resources::Candlepin::Product.pools(organization.label, self.cp_id).each do |pool|
-        Katello::Pool.find_all_by_cp_id(pool['id']).each(&:destroy)
-        Resources::Candlepin::Pool.destroy(pool['id'])
+      # Candlepin sends back its internal hibernate fields in the json. However it does not accept them in return
+      # when updating (PUT) objects.
+      def remove_hibernate_fields(elements)
+        return nil unless elements
+        elements.collect { |e| e.except(:id, :created, :updated) }
       end
-      true
-    rescue => e
-      Rails.logger.error "Failed to delete pools for product in candlepin #{name}: #{e}, #{e.backtrace.join("\n")}"
-      raise e
-    end
 
-    def del_subscriptions
-      Rails.logger.debug "Deleting subscriptions for product #{name} in candlepin"
-      job = Resources::Candlepin::Product.delete_subscriptions self.organization.label, self.cp_id
-      wait_for_job(job) if job
-      true
-    rescue => e
-      Rails.logger.error "Failed to delete subscription for product in candlepin #{name}: #{e}, #{e.backtrace.join("\n")}"
-      raise e
-    end
+      def add_content(content)
+        Resources::Candlepin::Product.add_content self.cp_id, content.content.id, true
+        self.productContent << content
+      end
 
-    # preventing of going into race-condition described in BZ_788932 by waiting
-    # for each job to finish before proceeding.
-    def wait_for_job(job)
-      while Resources::Candlepin::Job.not_finished?(Resources::Candlepin::Job.get(job[:id]))
-        sleep 0.5
+      def remove_content_by_id(content_id)
+        Resources::Candlepin::Product.remove_content cp_id, content_id
       end
-    end
 
-    def save_product_orchestration
-      case self.orchestration_for
-      when :create
-        pre_queue.create(:name => "candlepin product: #{self.name}",                          :priority => 1, :action => [self, :set_product])
-        pre_queue.create(:name => "create unlimited subscription in candlepin: #{self.name}", :priority => 2, :action => [self, :set_unlimited_subscription])
-      when :import_from_cp
-        # we leave it as it is - to not break re-import logic
-      when :import_from_cp_ar_setup
-        # skip creating product in candlepin as its already there
-      when :update
-        #called when sync schedule changed, repo added, repo deleted
-        pre_queue.create(:name => "update content in candlein: #{self.name}", :priority => 1, :action => [self, :update_content])
-      when :promote
-        #queue.create(:name => "update candlepin product: #{self.name}", :priority => 3, :action => [self, :update_content])
+      def product_content_by_id(content_id)
+        self.productContent.find { |pc| pc.content.id == content_id }
       end
-    end
 
-    def destroy_product_orchestration
-      pre_queue.create(:name => "delete pools for product in candlepin: #{self.name}", :priority => 7,  :action => [self, :del_pools])
-      pre_queue.create(:name => "delete subscriptions for product in candlepin: #{self.name}", :priority => 8,  :action => [self, :del_subscriptions])
-      pre_queue.create(:name => "remove candlepin content from a product: #{self.name}",       :priority => 9,  :action => [self, :remove_all_content])
-      pre_queue.create(:name => "candlepin product: #{self.name}",                             :priority => 10, :action => [self, :del_product])
-    end
+      def product_content_by_name(content_name)
+        self.productContent.find { |pc| pc.content.name == content_name }
+      end
 
-    protected
+      protected
 
-    def added_content
-      old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map {|pc| pc.content.label}
-      new_content_ids = productContent_change[1].map {|pc| pc.content.label}
+      def added_content
+        old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map { |pc| pc.content.label }
+        new_content_ids = productContent_change[1].map { |pc| pc.content.label }
 
-      added_content_ids = new_content_ids - old_content_ids
+        added_content_ids = new_content_ids - old_content_ids
 
-      added_content = productContent_change[1].select {|pc| added_content_ids.include?(pc.content.label)}
-      added_content
-    end
+        added_content = productContent_change[1].select { |pc| added_content_ids.include?(pc.content.label) }
+        added_content
+      end
 
-    def deleted_content
-      old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map {|pc| pc.content.label}
-      new_content_ids = productContent_change[1].map {|pc| pc.content.label}
+      def deleted_content
+        old_content_ids = productContent_change[0].nil? ? [] : productContent_change[0].map { |pc| pc.content.label }
+        new_content_ids = productContent_change[1].map { |pc| pc.content.label }
 
-      deleted_content_ids = old_content_ids - new_content_ids
+        deleted_content_ids = old_content_ids - new_content_ids
 
-      deleted_content = productContent_change[0].select {|pc| deleted_content_ids.include?(pc.content.label)}
-      deleted_content
+        deleted_content = productContent_change[0].select { |pc| deleted_content_ids.include?(pc.content.label) }
+        deleted_content
+      end
     end
-
   end
 end
-end