erp_products 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd9373780450ef58a539f607556ee88ff417272e
-  data.tar.gz: de281f11a15e17f9b5cc0914d31b104f67b8f5c9
+  metadata.gz: eb72e4e09cd0dec844882476e0cae80ecfb365f3
+  data.tar.gz: 30c5dde2888fd427d1cf601f5a1bab66bf9bafdc
 SHA512:
-  metadata.gz: f86542e4a62072f0ac42a9def7addcaf76b592c5e8c2192e64671917d052c9bd54a6e90cf4cc71386a4d3c2efe25affa4d702c7204db8e73edda27f8752ea682
-  data.tar.gz: 40763f3e853e92126be1fa46ecefe6b8fe5024c9452d1679d86c0d9f9eb293b3575245d9c29cfe7f7e87374b678e4bffe19cf5891ecbae55acfdf95f5a46fbd7
+  metadata.gz: 7257bfbed6ee33d738a5f9618a2a626bca9fe598fcfb86db4c215a0f39a2381df16ff9fe6199f41b4bdacf17693f0d213e4e0e99735cee97bc73258d18f40bcd
+  data.tar.gz: f2d0e65653701d0580ca1bf63648ed9cc5a13beceeb4473275fd8bd22a62bb5e393c9d42dbc28e8a085ceda1a71f6a3b7cea4c83a2a5d092dd6b5533f5c67fc3

data/app/controllers/api/v1/product_types_controller.rb

@@ -0,0 +1,140 @@
+module Api
+  module V1
+    class ProductTypesController < BaseController
+
+      def index
+        sort = nil
+        dir = nil
+        limit = nil
+        start = nil
+
+        unless params[:sort].blank?
+          sort_hash = params[:sort].blank? ? {} : Hash.symbolize_keys(JSON.parse(params[:sort]).first)
+          sort = sort_hash[:property] || 'description'
+          dir = sort_hash[:direction] || 'ASC'
+          limit = params[:limit] || 25
+          start = params[:start] || 0
+        end
+
+        query_filter = params[:query_filter].blank? ? {} : JSON.parse(params[:query_filter]).symbolize_keys
+
+        # hook method to apply any scopes passed via parameters to this api
+        product_types = ProductType.apply_filters(query_filter)
+
+        # scope by dba_organizations if there are no parties passed as filters
+        unless query_filter[:parties]
+          dba_organizations = [current_user.party.dba_organization]
+          dba_organizations = dba_organizations.concat(current_user.party.dba_organization.child_dba_organizations)
+          product_types = product_types.scope_by_dba_organization(dba_organizations)
+        end
+
+        if sort and dir
+          product_types = product_types.order("#{sort} #{dir}")
+        end
+
+        total_count = product_types.count
+
+        if start and limit
+          product_types = product_types.offset(start).limit(limit)
+        end
+
+        render :json => {success: true,
+                         total_count: total_count,
+                         product_types: product_types.collect { |product_type| product_type.to_data_hash }}
+
+      end
+
+      def show
+        product_type = ProductType.find(params[:id])
+
+        render :json => {success: true,
+                         product_type: product_type.to_data_hash}
+      end
+
+      def create
+        begin
+          ActiveRecord::Base.transaction do
+            product_type = ProductType.new
+            product_type.description = params[:description]
+            product_type.sku = params[:sku]
+            product_type.unit_of_measurement_id = params[:unit_of_measurement]
+            product_type.comment = params[:comment]
+
+            product_type.created_by_party = current_user.party
+
+            product_type.save!
+
+            #
+            # For scoping by party, add party_id and role_type 'vendor' to product_party_roles table. However may want to override controller elsewhere
+            # so that default is no scoping in erp_products engine
+            #
+            party_role = params[:party_role]
+            party_id = params[:party_id]
+            unless party_role.blank? or party_id.blank?
+              product_type_party_role = ProductTypePtyRole.new
+              product_type_party_role.product_type = product_type
+              product_type_party_role.party_id = party_id
+              product_type_party_role.role_type = RoleType.iid(party_role)
+              product_type_party_role.save
+            end
+          end
+
+          render :json => {success: true,
+                           product_type: product_type.to_data_hash}
+
+        rescue ActiveRecord::RecordInvalid => invalid
+
+          render :json => {success: false, message: invalid.record.errors.messages}
+
+        rescue => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          # email error
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render :json => {success: false, message: 'Could not create product type'}
+        end
+      end
+
+      def update
+        begin
+          ActiveRecord::Base.transaction do
+            product_type = ProductType.find(params[:id])
+
+            product_type.description = params[:description]
+            product_type.sku = params[:sku]
+            product_type.unit_of_measurement_id = params[:unit_of_measurement]
+            product_type.comment = params[:comment]
+
+            product_type.updated_by_party = current_user.party
+
+            product_type.save!
+
+            render :json => {success: true,
+                             product_type: product_type.to_data_hash}
+          end
+        rescue ActiveRecord::RecordInvalid => invalid
+
+          render :json => {success: false, message: invalid.record.errors.messages}
+
+        rescue => ex
+          Rails.logger.error ex.message
+          Rails.logger.error ex.backtrace.join("\n")
+
+          # email error
+          ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier
+
+          render :json => {success: false, message: 'Could not update product type'}
+        end
+      end
+
+      def destroy
+        ProductType.find(params[:id]).destroy
+
+        render :json => {:success => true}
+      end
+
+    end # ProductTypesController
+  end # V1
+end # Api

data/app/controllers/erp_products/shared/product_features_controller.rb

@@ -0,0 +1,46 @@
+module ErpProducts
+  module Shared
+    class ProductFeaturesController < ActionController::Base
+
+      def index
+        product_features = []
+        if params[:product_features]
+          params[:product_features].each do |product_feature|
+            found = ProductFeature.where(product_features: {product_feature_type_id: product_feature['type_id'].to_i, product_feature_value_id: product_feature['value_id'].to_i}).first
+            product_features << found if found
+          end
+        end
+
+        feature_type_arr = ProductFeature.get_feature_types(product_features)
+        render :json => {results: feature_type_arr}
+      end
+
+      def get_values
+        if params[:product_feature_type_id].present?
+          product_feature_type = ProductFeatureType.find(params[:product_feature_type_id])
+
+          if params[:product_features].present?
+            product_features = []
+            product_feature_params = params[:product_features].to_a.flatten.delete_if { |o| !o.is_a? Hash }
+            product_feature_params.each do |product_feature_hash|
+              product_features << ProductFeature.where('product_feature_type_id = ? and product_feature_value_id = ?',
+                                                       product_feature_hash['product_feature_type_id'],
+                                                       product_feature_hash['product_feature_value_id']).first
+            end
+
+            value_ids = ProductFeature.get_values(product_feature_type, product_features)
+          else
+            value_ids = ProductFeature.get_values(product_feature_type)
+          end
+
+        else
+          value_ids = []
+        end
+
+        render :json => {results: value_ids.map { |id| ProductFeatureValue.find(id) }}
+      end
+
+    end # ErpProducts
+  end # Shared
+end # ProductFeaturesController
+

data/app/models/extensions/biz_txn_acct_root.rb

@@ -0,0 +1,5 @@
+BizTxnAcctRoot.class_eval do
+
+  has_many :product_types
+
+end

data/app/models/product_feature.rb

@@ -0,0 +1,117 @@
+# 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'
+
+class ProductFeature < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  tracks_created_by_updated_by
+
+  belongs_to :product_feature_type
+  belongs_to :product_feature_value
+  has_many :product_feature_applicabilities, dependent: :destroy
+
+  after_destroy :destroy_interactions
+
+  def self.find_or_create(product_feature_type, product_feature_value)
+    product_feature = ProductFeature.where(product_feature_type_id: product_feature_type.id,
+                                           product_feature_value_id: product_feature_value.id).first
+
+    unless product_feature
+      product_feature = ProductFeature.create(product_feature_type: product_feature_type,
+                                              product_feature_value: product_feature_value)
+    end
+
+    product_feature
+  end
+
+  def self.get_feature_types(product_features)
+    array = []
+    already_filtered_product_features = if product_features
+                                          product_features.map { |pf| pf.product_feature_type }
+                                        else
+                                          []
+                                        end
+    ProductFeatureType.each_with_level(ProductFeatureType.root.self_and_descendants) do |o, level|
+      if !already_filtered_product_features.include?(o) && level != 0
+        array << {feature_type: o, parent_id: o.parent_id, level: level}
+      end
+    end
+
+    block_given? ? yield(array) : array
+  end
+
+  def feature_of_records
+    product_feature_applicabilities.map { |o| o.feature_of_record_type.constantize.find(o.feature_of_record_id) }
+  end
+
+  def self.get_values(feature_type, product_features=[])
+    feature_value_ids = feature_type.product_feature_values.order('description').pluck(:id)
+    valid_feature_value_ids = feature_value_ids.dup
+
+    # if there are a product features passed then it is being scoped by that product feature and
+    # we only what valid interactions
+    unless product_features.empty?
+      product_features.each do |product_feature|
+
+        # check each possible feature type / feature value combination for the given feature_type
+        feature_value_ids.each do |value_id|
+
+          # Is there a product feature to support this feature type / feature value combination?
+          test_product_feature = ProductFeature.where(product_features: {product_feature_type_id: feature_type.id, product_feature_value_id: value_id}).last
+
+          valid_feature_value_ids.delete_at(valid_feature_value_ids.index(value_id)) unless test_product_feature
+          next unless test_product_feature
+
+          unless test_product_feature.find_interactions(:invalid).empty?
+            if test_product_feature.find_interactions(:invalid).where('product_feature_to_id = ?', product_feature.id).count == 1
+              index = valid_feature_value_ids.index(value_id)
+              if index
+                valid_feature_value_ids.delete_at(index)
+              end
+            end
+          end
+
+        end # feature_value_ids loop
+      end # product_features loop
+
+    end
+
+    valid_feature_value_ids.uniq
+  end
+
+  #
+  # Product Feature Interactions
+  #
+  def interactions
+    ProductFeatureInteraction.where('product_feature_from_id = ? or product_feature_to_id = ?', self.id, self.id)
+  end
+
+  def to_interactions
+    ProductFeatureInteraction.where('product_feature_to_id = ?', self.id)
+  end
+
+  def from_interactions
+    ProductFeatureInteraction.where('product_feature_from_id = ?', self.id)
+  end
+
+  # find product feature interactions by ProductFeatureInteractionsType
+  def find_interactions(type)
+    # look up type if iid is passed
+    type = ProductFeatureInteractionType.iid(type.to_s)
+
+    self.from_interactions.where('product_feature_interaction_type_id' => type.id)
+  end
+
+  # destroy all interactions this ProductFeature is part of
+  def destroy_interactions
+    self.interactions.destroy_all
+  end
+
+end

data/app/models/product_feature_applicability.rb

@@ -0,0 +1,17 @@
+# 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'
+
+class ProductFeatureApplicability < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :feature_of_record, polymorphic: true
+  belongs_to :product_feature
+end

data/app/models/product_feature_interaction.rb

@@ -0,0 +1,21 @@
+# 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'
+
+class ProductFeatureInteraction < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :product_feature_from, class_name: "ProductFeature"
+  belongs_to :product_feature_to, class_name: "ProductFeature"
+  belongs_to :product_feature_interaction_type
+
+  is_json :custom_fields
+end

data/app/models/product_feature_interaction_type.rb

@@ -0,0 +1,17 @@
+# create_table :product_feature_interaction_types do |t|
+#   t.string :internal_identifier
+#   t.string :description
+#
+#   t.timestamps
+# end
+#
+# add_index :product_feature_interaction_types, :internal_identifier, name: 'product_ft_int_types_iid_idx'
+
+class ProductFeatureInteractionType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_erp_type
+
+  has_many :product_feature_interactions, dependent: :destroy
+
+end

data/app/models/product_feature_type.rb

@@ -0,0 +1,70 @@
+# 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
+#
+# add_index :product_feature_types, :internal_identifier, name: 'product_ft_types_iid_idx'
+# add_index :product_feature_types, [:rgt, :lft, :parent_id], name: 'product_ft_types_nested_set_idx'
+
+class ProductFeatureType < 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_values, through: :product_feature_type_product_feature_values
+
+  has_many :product_features, dependent: :destroy
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods  # acts_as_nested_set
+
+  def self.iid(description)
+    self.where("lower(description) = ?", description.downcase).first
+  end
+
+  def to_record_representation(root = ProductFeatureType.root)
+    # returns a string of category descriptions like
+    # 'main_category > sub_category n > ... > this category instance'
+    if root?
+      description
+    else
+      crawl_up_from(self, root).split('///').reverse.join(' > ')
+    end
+  end
+
+  def to_representation
+    # returns a string that consists of 1) a number of dashes equal to
+    # the category's level and 2) the category's description attr
+    rep = ''
+    level.times {rep << '- '}
+    rep << description
+  end
+
+  def self.to_all_representation(root = ProductFeatureType.root)
+    # returns an array of hashes which represent all categories in nested set order,
+    # each of which consists of the category's id and representation
+    container_arr = []
+    each_with_level(root.self_and_descendants) do |o, level|
+      container_arr << {:id => o.id, :description => o.to_representation}
+    end
+    container_arr
+  end
+
+  private
+
+  def crawl_up_from(product_feature_type, to_product_feature_type = ProductFeatureType.root)
+    # returns a string that is a '///'-separated list of categories
+    # from child category to root
+    "#{product_feature_type.description}///#{crawl_up_from(product_feature_type.parent, to_product_feature_type) if product_feature_type != to_product_feature_type}"
+  end
+end