erp_products 4.0.0 → 4.2.0

data/app/models/product_feature_type_product_feature_value.rb

@@ -0,0 +1,16 @@
+# create_table :product_feature_type_product_feature_values do |t|
+#   t.references :product_feature_type
+#   t.references :product_feature_value
+#
+#   t.timestamps
+# end
+#
+# add_index :product_feature_type_product_feature_values, :product_feature_type_id, :name => 'prod_feature_type_feature_value_type_idx'
+# add_index :product_feature_type_product_feature_values, :product_feature_value_id, :name => 'prod_feature_type_feature_value_value_idx'#
+
+class ProductFeatureTypeProductFeatureValue < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :product_feature_type
+  belongs_to :product_feature_value
+end

data/app/models/product_feature_value.rb

@@ -0,0 +1,42 @@
+# create_table :product_feature_values do |t|
+#   t.string :value
+#   t.string :internal_identifier
+#   t.string :external_identifier
+#   t.string :external_id_source
+#   t.string :description
+#
+#   t.timestamps
+# end
+#
+# add_index :product_feature_values, :internal_identifier, name: 'product_ft_vals_iid_idx'
+
+class ProductFeatureValue < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  tracks_created_by_updated_by
+
+  has_many :product_feature_type_product_feature_values, dependent: :destroy
+  has_many :product_feature_types, through: :product_feature_type_product_feature_values
+
+  has_many :product_features, dependent: :destroy
+
+  def self.find_or_create(internal_identifier, description, product_feature_type=nil)
+    product_feature_value = ProductFeatureValue.joins(:product_feature_type_product_feature_values)
+                                .where(internal_identifier: internal_identifier).readonly(false).first
+
+    unless product_feature_value
+      product_feature_value = ProductFeatureValue.create(description: description,
+                                                         internal_identifier: internal_identifier)
+
+    end
+
+    if product_feature_type
+      unless product_feature_value.product_feature_types.collect(&:id).include?(product_feature_type.id)
+        product_feature_value.product_feature_types << product_feature_type
+        product_feature_value.save
+      end
+    end
+
+    product_feature_value
+  end
+end

data/app/models/product_instance.rb

@@ -18,5 +18,9 @@ class ProductInstance < ActiveRecord::Base
   def prod_instance_relns_from
     ProdInstanceReln.where('prod_instance_id_from = ?',id)
   end
+
+  def taxable?
+    self.product_type.taxable?
+  end
   
 end

data/app/models/product_offer.rb

@@ -1,12 +1,34 @@
 class ProductOffer < ActiveRecord::Base
   attr_protected :created_at, :updated_at
-  
-	belongs_to :product_offer_record, :polymorphic => true   
+
+  tracks_created_by_updated_by
+
+  belongs_to :product_offer_record, :polymorphic => true
+
+  def valid_from=(date)
+    if date.is_a? String
+      write_attribute(:valid_from, date.to_date)
+    else
+      super
+    end
+  end
+
+  def valid_to=(date)
+    if date.is_a? String
+      write_attribute(:valid_to, date.to_date)
+    else
+      super
+    end
+  end
 
   def after_destroy
     if self.product_offer_record && !self.product_offer_record.frozen?
       self.product_offer_record.destroy
     end 
-  end	
+  end
+
+  def taxable?
+    self.product_offer_record.taxable?
+  end
   
 end

data/app/models/product_type.rb

@@ -1,29 +1,138 @@
+# create_table :product_types do |t|
+#   #these columns are required to support the behavior of the plugin 'better_nested_set'
+#   #ALL products have the ability to act as packages in a nested set-type structure
+#   #
+#   #The package behavior is treated differently from other product_relationship behavior
+#   #which is implemented using a standard relationship structure.
+#   #
+#   #This is to allow quick construction of highly nested product types.
+#   t.column  	:parent_id,              :integer
+#   t.column  	:lft,                    :integer
+#   t.column  	:rgt,                    :integer
+#
+#   #custom columns go here
+#   t.column  :description,              :string
+#   t.column  :product_type_record_id,   :integer
+#   t.column  :product_type_record_type, :string
+#   t.column 	:external_identifier, 	   :string
+#   t.column  :internal_identifier,      :string
+#   t.column 	:external_id_source, 	     :string
+#   t.column  :default_image_url,        :string
+#   t.column  :list_view_image_id,       :integer
+#   t.column  :length,                   :decimal
+#   t.column  :width,                    :decimal
+#   t.column  :height,                   :decimal
+#   t.column  :weight,                   :decimal
+#   t.column  :cylindrical,              :boolean
+#   t.column  :taxable                   :boolean
+#   t.column  :available_on_web          :boolean
+#   t.references :unit_of_measurement
+#   t.references :biz_txn_acct_root
+#
+#   t.timestamps
+# end
+#
+# add_index :product_types, :biz_txn_acct_root_id
+
 class ProductType < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
   acts_as_nested_set
   include ErpTechSvcs::Utils::DefaultNestedSetMethods
- 
+  acts_as_taggable
+
+  tracks_created_by_updated_by
   has_file_assets
   is_describable
-  
-	belongs_to :product_type_record, :polymorphic => true  
-  has_one    :product_instance
+
+  belongs_to :product_type_record, polymorphic: true
   belongs_to :unit_of_measurement
-  has_many :product_type_pty_roles, :dependent => :destroy
-  
+  belongs_to :biz_txn_acct_root
+
+  has_one :product_instance
+  has_many :product_type_pty_roles, dependent: :destroy
+  has_many :simple_product_offers, dependent: :destroy
+  has_many :product_feature_applicabilities, dependent: :destroy, as: :feature_of_record
+
+  validates :internal_identifier, :uniqueness => true, :allow_nil => true
+
+  alias :gl_account :biz_txn_acct_root
+
+  class << self
+    # Filter records
+    #
+    # @param filters [Hash] a hash of filters to be applied,
+    # @param statement [ActiveRecord::Relation] the query being built
+    # @return [ActiveRecord::Relation] the query being built
+    def apply_filters(filters, statement=nil)
+      unless statement
+        statement = ProductType
+      end
+
+      statement
+    end
+
+    #
+    # scoping helpers
+    #
+
+    # scope by dba organization
+    #
+    # @param dba_organization [Party] dba organization to scope by
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_dba_organization(dba_organization)
+      scope_by_party(dba_organization, {role_types: [RoleType.iid('dba_org')]})
+    end
+
+    # scope by party
+    #
+    # @param party [Integer | Party | Array] either a id of Party record, a Party record, an array of Party records
+    # or an array of Party ids
+    # @param options [Hash] options to apply to this scope
+    # @option options [Array] :role_types role types to include in the scope
+    #
+    # @return [ActiveRecord::Relation]
+    def scope_by_party(party, options={})
+      statement = joins(:product_type_pty_roles).where("product_type_pty_roles.party_id" => party).uniq
+
+      if options[:role_types]
+        statement = statement.where("product_type_pty_roles.role_type_id" => RoleType.find_child_role_types(options[:role_types]))
+      end
+
+      statement
+    end
+  end
+
+  # add party with passed role to this ProductType
+  #
+  # @param party [Party] party to add
+  # @param role_type [RoleType] role type to use in the association
+  # @return [ProductTypePtyRole] newly created relationship
+  def add_party_with_role(party, role_type)
+    ProductTypePtyRole.create(
+        product_type: self,
+        party: party,
+        role_type: role_type
+    )
+  end
+
+  def taxable?
+    self.taxable
+  end
+
   def prod_type_relns_to
-    ProdTypeReln.where('prod_type_id_to = ?',id)
+    ProdTypeReln.where('prod_type_id_to = ?', id)
   end
 
   def prod_type_relns_from
-    ProdTypeReln.where('prod_type_id_from = ?',id)
+    ProdTypeReln.where('prod_type_id_from = ?', id)
   end
- 
+
   def to_label
     "#{description}"
   end
-  
+
   def to_s
     "#{description}"
   end
@@ -31,23 +140,78 @@ class ProductType < ActiveRecord::Base
   def self.count_by_status(product_type, prod_availability_status_type)
     ProductInstance.count("product_type_id = #{product_type.id} and prod_availability_status_type_id = #{prod_availability_status_type.id}")
   end
-  
+
   def images_path
     file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
-    File.join(file_support.root,Rails.application.config.erp_tech_svcs.file_assets_location,'products','images',"#{self.description.underscore}_#{self.id}")
+    File.join(file_support.root, Rails.application.config.erp_tech_svcs.file_assets_location, 'products', 'images', "#{self.description.underscore}_#{self.id}")
   end
 
   def to_data_hash
+    to_hash(only: [
+                :id,
+                :description,
+                :internal_identifier,
+                :sku,
+                :comment,
+                :created_at,
+                :updated_at
+            ],
+            unit_of_measurement: try(:unit_of_measurement).try(:to_data_hash),
+            price: try(:get_current_simple_plan).try(:money_amount),
+            gl_account: try(:gl_account).try(:to_data_hash))
+  end
+
+  def to_display_hash
     {
-        :id => self.id,
-        :description => self.description,
-        :sku => self.sku,
-        :unit_of_measurement_id => self.unit_of_measurement_id,
-        :unit_of_measurement_description => (self.unit_of_measurement.description rescue nil),
-        :comment => self.comment,
-        :created_at => self.created_at,
-        :updated_at => self.updated_at
+        id: id,
+        description: description,
+        offer_list_description: find_descriptions_by_view_type('list_description').first.try(:description),
+        offer_short_description: find_descriptions_by_view_type('short_description').first.try(:description),
+        offer_long_description: find_descriptions_by_view_type('long_description').first.try(:description),
+        offer_base_price: get_current_simple_amount_with_currency,
+        images: images.pluck(:id)
     }
   end
-  
+
+  def parent_dba_organizations(dba_orgs=[])
+    ProductTypePtyRole.
+        where('product_type_id = ?', id).
+        where('role_type_id' => RoleType.iid('dba_org').id).each do |prod_party_reln|
+
+      dba_orgs.push(prod_party_reln.party)
+      prod_party_reln.party.parent_dba_organizations(dba_orgs)
+    end
+
+    dba_orgs.uniq
+  end
+
+  def add_party_with_role_type(party, role_type)
+    if role_type.is_a?(String)
+      role_type = RoleType.iid(role_type)
+    end
+
+    ProductTypePtyRole.create(party: party, role_type: role_type, product_type: self)
+  end
+
+  def has_dimensions?
+    (cylindrical && length && width && weight) or (length && width && height && weight)
+  end
 end
+
+module Arel
+  class SelectManager
+    def polymorphic_join(hash={polytable: nil, table: nil, model: nil, polymodel: nil, record_type_name: nil, record_id_name: nil, table_model: nil})
+      # Left Outer Join with 2 possible hash argument sets:
+      #   1) model (AR model), polymodel (AR model), record_type_name (symbol), record_id_name (symbol)
+      #   2) polytable (arel_table), table (arel_table), record_type_name (symbol), record_id_name (symbol), table_model (string)
+
+      if hash[:model] && hash[:polymodel]
+        self.join(hash[:polymodel].arel_table, Arel::Nodes::OuterJoin).on(hash[:polymodel].arel_table[hash[:record_id_name]].eq(hash[:model].arel_table[:id]).and(hash[:polymodel].arel_table[hash[:record_type_name]].eq(hash[:model].to_s)))
+      elsif hash[:polytable] && hash[:record_type_name]
+        self.join(hash[:polytable], Arel::Nodes::OuterJoin).on(hash[:polytable][hash[:record_id_name]].eq(hash[:table][:id]).and(hash[:polytable][hash[:record_type_name]].eq(hash[:table_model])))
+      else
+        raise 'Invalid Args'
+      end
+    end
+  end
+end

data/app/models/product_type_pty_role.rb

@@ -1,4 +1,6 @@
 class ProductTypePtyRole < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
   belongs_to :product_type
   belongs_to :party
   belongs_to :role_type

data/app/models/simple_product_offer.rb

@@ -1,6 +1,8 @@
 class SimpleProductOffer < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  is_json :custom_fields
   acts_as_product_offer
-  belongs_to :product
+
+  belongs_to :product_type
 end

data/config/routes.rb

@@ -1,9 +1,20 @@
+Rails.application.routes.draw do
+
+  namespace :api do
+    namespace :v1 do
+
+      resources :product_types, defaults: { :format => 'json' }
+
+    end
+  end
+
+end
+
 ErpProducts::Engine.routes.draw do
-  #product_manager
-  match '/erp_app/desktop/product_manager(/:action(/:id))' => 'erp_app/desktop/product_manager/base'
 
   namespace 'shared' do
-    resources 'product_types'
-    get 'product_types/show_details(/:id)' => 'product_types#show_details'
+    resources :product_features, except: [:show]
+    get '/product_features/get_values' => 'product_features#get_values'
   end
+
 end

data/db/data_migrations/20141222195727_add_product_type_view_types.rb

@@ -0,0 +1,24 @@
+class AddProductTypeViewTypes
+
+  def self.up
+    product_type_view_type = ViewType.create(description: 'Product Type Descriptions',
+                                             internal_identifier: 'product_type_description')
+
+    list = ViewType.create(description: 'List Description',
+                            internal_identifier: 'list_description')
+    list.move_to_child_of(product_type_view_type)
+
+    short = ViewType.create(description: 'Short Description',
+                            internal_identifier: 'short_description')
+    short.move_to_child_of(product_type_view_type)
+
+    long = ViewType.create(description: 'Long Description',
+                            internal_identifier: 'long_description')
+    long.move_to_child_of(product_type_view_type)
+  end
+
+  def self.down
+    #remove data here
+  end
+
+end

data/db/migrate/20080805000040_base_products.rb

@@ -1,6 +1,7 @@
 class BaseProducts < ActiveRecord::Migration
   def self.up
-    
+
+    # product_types
     unless table_exists?(:product_types)
       create_table :product_types do |t|
         #these columns are required to support the behavior of the plugin 'better_nested_set'
@@ -10,23 +11,34 @@ class BaseProducts < ActiveRecord::Migration
         #which is implemented using a standard relationship structure.
         #
         #This is to allow quick construction of highly nested product types.
-        t.column  	:parent_id,    :integer
-        t.column  	:lft,          :integer
-        t.column  	:rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
 
         #custom columns go here   
-        t.column  :description,                 :string			
-        t.column  :product_type_record_id,      :integer
-        t.column  :product_type_record_type,    :string
-        t.column 	:external_identifier, 	      :string
-        t.column  :internal_identifier,         :string
-        t.column 	:external_id_source, 	        :string
-        t.column  :default_image_url,           :string
-        t.column  :list_view_image_id,          :integer
+        t.column :description, :string
+        t.column :product_type_record_id, :integer
+        t.column :product_type_record_type, :string
+        t.column :external_identifier, :string
+        t.column :internal_identifier, :string
+        t.column :external_id_source, :string
+        t.column :default_image_url, :string
+        t.column :list_view_image_id, :integer
+        t.column :type, :string
+        t.string :sku
+        t.text :comment
+        t.references :unit_of_measurement
         t.timestamps
       end
+
+      add_index :product_types, :parent_id, :name => "prod_type_parent_id_idx"
+      add_index :product_types, :lft, :name => "prod_type_lft_idx"
+      add_index :product_types, :rgt, :name => "prod_type_rgt_idx"
+      add_index :product_types, :unit_of_measurement_id, :name => "prod_type_uom_idx"
+      add_index :product_types, [:product_type_record_id, :product_type_record_type], :name => "prod_type_poly_idx"
     end
-    
+
+    # product_instances
     unless table_exists?(:product_instances)
       create_table :product_instances do |t|
         #these columns are required to support the behavior of the plugin 'better_nested_set'
@@ -36,194 +48,330 @@ class BaseProducts < ActiveRecord::Migration
         #which is implemented using a standard relationship structure.
         #
         #This is to allow quick construction of highly nested product types.
-        t.column  	:parent_id,    :integer
-        t.column  	:lft,          :integer
-        t.column  	:rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
 
         #custom columns go here   
-        t.column  :description,                   :string	
-	      t.column  :product_instance_record_id,    :integer
-	      t.column  :product_instance_record_type,  :string
-			  t.column 	:external_identifier, 	        :string
-			  t.column 	:external_id_source, 	          :string
-	      t.column	:product_type_id,				        :integer
-	      t.column  :type,                          :string
+        t.column :description, :string
+        t.column :product_instance_record_id, :integer
+        t.column :product_instance_record_type, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
+        t.column :product_type_id, :integer
+        t.column :type, :string
 
         t.references :prod_availability_status_type
 
         t.timestamps
       end
+
+      add_index :product_instances, :parent_id, :name => "prod_ins_parent_id_idx"
+      add_index :product_instances, :lft, :name => "prod_ins_lft_idx"
+      add_index :product_instances, :rgt, :name => "prod_ins_rgt_idx"
+      add_index :product_instances, [:product_instance_record_id, :product_instance_record_type], :name => "prod_ins_poly_idx"
+      add_index :product_instances, :product_type_id, :name => "prod_ins_prod_type_idx"
     end
-    
+
+    # product_offers
     unless table_exists?(:product_offers)
       create_table :product_offers do |t|
-        t.column  :description,                 :string
-	      t.column  :product_offer_record_id,     :integer
-	      t.column  :product_offer_record_type,   :string
-		  	t.column 	:external_identifier, 	      :string
-		  	t.column 	:external_id_source, 	        :string
+        t.references :product_offer_record, :polymorphic => true
+
+        t.string :description
+        t.string :external_identifier
+        t.string :external_id_source
+        t.date :valid_from
+        t.date :valid_to
+
         t.timestamps
       end
+
+      add_index :product_offers, [:product_offer_record_id, :product_offer_record_type], :name => "prod_offer_poly_idx"
+      add_index :product_offers, :valid_from, :name => "prod_offer_valid_from_idx"
+      add_index :product_offers, :valid_to, :name => "prod_offer_valid_to_idx"
     end
-    
+
+    # simple_product_offers
     unless table_exists?(:simple_product_offers)
       create_table :simple_product_offers do |t|
-        t.column  :description,   :string
-        t.column  :product_id,    :integer
-        t.column  :base_price,    :decimal, :precision => 8, :scale => 2
-        t.column  :uom,           :integer
+        t.references :product_type
+
+        t.string :description, :string
+        t.decimal :base_price, :precision => 8, :scale => 2
+        t.integer :uom
+
         t.timestamps
       end
+
+      add_index :simple_product_offers, :product_type_id, :name => "simple_prod_offer_product_type_id_idx"
     end
-    
+
+    # prod_instance_reln_types
     unless table_exists?(:prod_instance_reln_types)
       create_table :prod_instance_reln_types do |t|
-        t.column    :parent_id,    :integer
-        t.column    :lft,          :integer
-        t.column    :rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
 
         #custom columns go here   
-        t.column    :description,           :string
-        t.column    :comments,              :string
-        t.column    :internal_identifier,   :string
-        t.column    :external_identifier,   :string
-        t.column    :external_id_source,    :string
+        t.column :description, :string
+        t.column :comments, :string
+        t.column :internal_identifier, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
         t.timestamps
       end
+
+      add_index :prod_instance_reln_types, :parent_id, :name => "prod_reln_type_parent_id_idx"
+      add_index :prod_instance_reln_types, :lft, :name => "prod_reln_type_lft_idx"
+      add_index :prod_instance_reln_types, :rgt, :name => "prod_reln_type_rgt_idx"
     end
-    
+
+    # prod_instance_role_types
     unless table_exists?(:prod_instance_role_types)
       create_table :prod_instance_role_types do |t|
-        t.column    :parent_id,    :integer
-        t.column    :lft,          :integer
-        t.column    :rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
         #custom columns go here   
-        t.column    :description,           :string
-        t.column    :comments,              :string
-        t.column    :internal_identifier,   :string
-        t.column    :external_identifier,   :string
-        t.column    :external_id_source,    :string
+        t.column :description, :string
+        t.column :comments, :string
+        t.column :internal_identifier, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
         t.timestamps
       end
+
+      add_index :prod_instance_role_types, :parent_id, :name => "prod_ins_role_type_parent_id_idx"
+      add_index :prod_instance_role_types, :lft, :name => "prod_ins_role_type_lft_idx"
+      add_index :prod_instance_role_types, :rgt, :name => "prod_ins_role_type_rgt_idx"
     end
-    
+
+    # prod_instance_relns
     unless table_exists?(:prod_instance_relns)
       create_table :prod_instance_relns do |t|
-        t.column  :prod_instance_reln_type_id,  :integer
-        t.column  :description,                 :string 
-        t.column  :prod_instance_id_from,       :integer
-        t.column  :prod_instance_id_to,         :integer
-        t.column  :role_type_id_from,           :integer
-        t.column  :role_type_id_to,             :integer
-        t.column  :status_type_id,              :integer
-        t.column  :from_date,                   :date
-        t.column  :thru_date,                   :date 
+        t.column :prod_instance_reln_type_id, :integer
+        t.column :description, :string
+        t.column :prod_instance_id_from, :integer
+        t.column :prod_instance_id_to, :integer
+        t.column :role_type_id_from, :integer
+        t.column :role_type_id_to, :integer
+        t.column :from_date, :date
+        t.column :thru_date, :date
         t.timestamps
       end
+
+      add_index :prod_instance_relns, :prod_instance_reln_type_id, :name => "prod_instance_relns_type_idx"
+      add_index :prod_instance_relns, :prod_instance_id_from, :name => "prod_instance_relns_ins_from_idx"
+      add_index :prod_instance_relns, :prod_instance_id_to, :name => "prod_instance_relns_ins_to_idx"
+      add_index :prod_instance_relns, :role_type_id_from, :name => "prod_instance_relns_type_from_idx"
+      add_index :prod_instance_relns, :role_type_id_to, :name => "prod_instance_relns_type_to_idx"
     end
-    
+
+    # prod_type_reln_types
     unless table_exists?(:prod_type_reln_types)
       create_table :prod_type_reln_types do |t|
-        t.column    :parent_id,    :integer
-        t.column    :lft,          :integer
-        t.column    :rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
         #custom columns go here   
-        t.column    :description,           :string
-        t.column    :comments,              :string
-        t.column    :internal_identifier,   :string
-        t.column    :external_identifier,   :string
-        t.column    :external_id_source,    :string
+        t.column :description, :string
+        t.column :comments, :string
+        t.column :internal_identifier, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
         t.timestamps
       end
+
+      add_index :prod_instance_role_types, :parent_id, :name => "prod_type_reln_type_parent_id_idx"
+      add_index :prod_instance_role_types, :lft, :name => "prod_type_reln_type_lft_idx"
+      add_index :prod_instance_role_types, :rgt, :name => "prod_type_reln_type_rgt_idx"
     end
-    
+
+    # prod_type_role_types
     unless table_exists?(:prod_type_role_types)
       create_table :prod_type_role_types do |t|
-        t.column    :parent_id,    :integer
-        t.column    :lft,          :integer
-        t.column    :rgt,          :integer
+        t.column :parent_id, :integer
+        t.column :lft, :integer
+        t.column :rgt, :integer
         #custom columns go here   
-        t.column    :description,           :string
-        t.column    :comments,              :string
-        t.column    :internal_identifier,   :string
-        t.column    :external_identifier,   :string
-        t.column    :external_id_source,    :string
+        t.column :description, :string
+        t.column :comments, :string
+        t.column :internal_identifier, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
         t.timestamps
       end
+
+      add_index :prod_instance_role_types, :parent_id, :name => "prod_type_role_types_parent_id_idx"
+      add_index :prod_instance_role_types, :lft, :name => "prod_type_role_types_lft_idx"
+      add_index :prod_instance_role_types, :rgt, :name => "prod_type_role_types_rgt_idx"
     end
-    
+
+    # prod_type_relns
     unless table_exists?(:prod_type_relns)
       create_table :prod_type_relns do |t|
-        t.column  :prod_type_reln_type_id,  :integer
-        t.column  :description,             :string 
-        t.column  :prod_type_id_from,       :integer
-        t.column  :prod_type_id_to,         :integer
-        t.column  :role_type_id_from,       :integer
-        t.column  :role_type_id_to,         :integer
-        t.column  :status_type_id,          :integer
-        t.column  :from_date,               :date
-        t.column  :thru_date,               :date 
-        t.timestamps
-      end
-    end
-    
-    unless table_exists?(:product_instance_status_types)
-        create_table :product_instance_status_types do |t|
-          #better nested set colummns
-          t.column :parent_id, :integer
-          t.column :lft,       :integer
-          t.column :rgt,       :integer
-          
-           t.column :description,             :string
-           t.column :internal_identifier,     :string
-           t.column :external_identifier,     :string
-           t.column :external_id_source,      :string
-          
-          t.timestamps
-        end
-    end
-    
-    unless table_exists?(:prod_availability_status_types)
-      create_table :prod_availability_status_types do |t|
-        #better nested set colummns
-        t.column :parent_id, :integer
-        t.column :lft,       :integer
-        t.column :rgt,       :integer
-        
-        t.column :description,             :string
-        t.column :internal_identifier,     :string
-        t.column :external_identifier,     :string
-        t.column :external_id_source,      :string
-        
+        t.column :prod_type_reln_type_id, :integer
+        t.column :description, :string
+        t.column :prod_type_id_from, :integer
+        t.column :prod_type_id_to, :integer
+        t.column :role_type_id_from, :integer
+        t.column :role_type_id_to, :integer
+        t.column :status_type_id, :integer
+        t.column :from_date, :date
+        t.column :thru_date, :date
         t.timestamps
       end
+
+      add_index :prod_type_relns, :prod_type_reln_type_id, :name => "prod_type_relns_type_idx"
+      add_index :prod_type_relns, :prod_type_id_from, :name => "prod_type_relns_type_from_idx"
+      add_index :prod_type_relns, :prod_type_id_to, :name => "prod_type_relns_type_to_idx"
+      add_index :prod_type_relns, :role_type_id_from, :name => "prod_type_relns_role_from_idx"
+      add_index :prod_type_relns, :role_type_id_to, :name => "prod_type_relns_role_to_idx"
     end
-    
+
+    # prod_availability_status_types
     unless table_exists?(:prod_availability_status_types)
       create_table :prod_availability_status_types do |t|
         #better nested set colummns
         t.column :parent_id, :integer
-        t.column :lft,       :integer
-        t.column :rgt,       :integer
-        
-        t.column :description,             :string
-        t.column :internal_identifier,     :string
-        t.column :external_identifier,     :string
-        t.column :external_id_source,      :string
-        
+        t.column :lft, :integer
+        t.column :rgt, :integer
+
+        t.column :description, :string
+        t.column :internal_identifier, :string
+        t.column :external_identifier, :string
+        t.column :external_id_source, :string
+
         t.timestamps
       end
+
+      add_index :prod_availability_status_types, :parent_id, :name => "prod_avail_status_types_parent_id_idx"
+      add_index :prod_availability_status_types, :lft, :name => "prod_avail_status_types_lft_idx"
+      add_index :prod_availability_status_types, :rgt, :name => "prod_avail_status_types_rgt_idx"
     end
-    
 
+    # product_type_pty_roles
+    unless table_exists?(:product_type_pty_roles)
+      create_table :product_type_pty_roles do |t|
+        t.references :party
+        t.references :role_type
+        t.references :product_type
+
+        t.timestamps
+      end
+
+      add_index :product_type_pty_roles, :party_id, :name => "product_type_pty_roles_party_idx"
+      add_index :product_type_pty_roles, :role_type_id, :name => "product_type_pty_roles_role_idx"
+      add_index :product_type_pty_roles, :product_type_id, :name => "product_type_pty_roles_prod_type_idx"
+    end
+
+    # product_features
+    unless table_exists?(:product_feature_types)
+      create_table :product_feature_types do |t|
+
+        t.integer :parent_id
+        t.integer :lft
+        t.integer :rgt
+
+        t.string :description
+        t.string :internal_identifier
+        t.string :external_identifier
+        t.string :external_id
+
+        t.timestamps
+      end
+    end
+
+    # product_feature_applicabilities
+    unless table_exists?(:product_feature_applicabilities)
+      create_table :product_feature_applicabilities do |t|
+        t.references :feature_of_record, :polymorphic => true
+        t.references :product_feature
+
+        t.boolean :is_mandatory
+
+        t.timestamps
+      end
+
+      add_index :product_feature_applicabilities, [:feature_of_record_type, :feature_of_record_id], :name => 'prod_feature_record_idx'
+    end
+
+    # product_feature_type_product_feature_values
+    unless table_exists?(:product_feature_type_product_feature_values)
+      create_table :product_feature_type_product_feature_values do |t|
+        t.references :product_feature_type
+        t.references :product_feature_value
+
+        t.timestamps
+      end
+
+      add_index :product_feature_type_product_feature_values, :product_feature_type_id, :name => 'prod_feature_type_feature_value_type_idx'
+      add_index :product_feature_type_product_feature_values, :product_feature_value_id, :name => 'prod_feature_type_feature_value_value_idx'
+    end
+
+    # product_features
+    unless table_exists?(:product_features)
+      create_table :product_features do |t|
+        t.references :product_feature_type
+        t.references :product_feature_value
+
+        t.timestamps
+      end
+
+      add_index :product_features, :product_feature_type_id, :name => 'prod_feature_type_idx'
+      add_index :product_features, :product_feature_value_id, :name => 'prod_feature_value_idx'
+    end
+
+    # product_feature_values
+    unless table_exists?(:product_feature_values)
+      create_table :product_feature_values do |t|
+        t.string :value
+        t.string :internal_identifier
+        t.string :external_identifier
+        t.string :external_id_source
+        t.string :description
+
+        t.timestamps
+      end
+    end
+
+    # product_feature_interactions
+    unless table_exists?(:product_feature_interactions)
+      create_table :product_feature_interactions do |t|
+        t.references :product_feature
+        t.references :interacted_product_feature
+        t.references :product_feature_interaction_type
+
+        t.timestamps
+      end
+
+      add_index :product_feature_interactions, :product_feature_id, :name => 'prod_feature_int_feature_idx'
+      add_index :product_feature_interactions, :interacted_product_feature_id, :name => 'prod_feature_int_interacted_feature_idx'
+      add_index :product_feature_interactions, :product_feature_interaction_type_id, :name => 'prod_feature_int_interacted_feature_type_idx'
+    end
+
+    # product_feature_interaction_types
+    unless table_exists?(:product_feature_interaction_types)
+      create_table :product_feature_interaction_types do |t|
+        t.string :internal_identifier
+        t.string :description
+
+        t.timestamps
+      end
+    end
   end
 
   def self.down
     [
-      :prod_type_relns, :prod_type_role_types, :prod_type_reln_types, 
-      :prod_instance_relns, :prod_instance_role_types, :prod_instance_reln_types, 
-      :simple_product_offers, :product_offers, :product_instances, 
-      :product_types,:prod_availability_status_types
+        :prod_type_relns, :prod_type_role_types, :prod_type_reln_types,
+        :prod_instance_relns, :prod_instance_role_types, :prod_instance_reln_types,
+        :simple_product_offers, :product_offers, :product_instances,
+        :product_types, :prod_availability_status_types, :product_type_pty_roles,
+        :product_features, :product_feature_type_product_feature_values,
+        :product_feature_applicabilities, :product_features, :product_feature_values,
+        :product_feature_interactions, :product_feature_interaction_types
     ].each do |tbl|
       if table_exists?(tbl)
         drop_table tbl