huginn_acumen_product_agent 1.6.1 → 2.0.0

data/lib/huginn_acumen_product_agent/concerns/inv_product_query_concern.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# This module is responsible for reading/processing data recrods from the Inv_Product
+# table in Acumen. This table contains the baseline product information -- name, sku,
+# format, etc.
+module InvProductQueryConcern
+  extend AcumenQueryConcern
+
+  # Fetch/Process the Acumen data,
+  def fetch_inv_product_data(acumen_client, product_ids, digital_format_list)
+    product_data = acumen_client.get_products(product_ids)
+
+    return process_inv_product_response(product_data, digital_format_list)
+  end
+
+  # This function returns an array of Acumen products mapped to Schema.org/Product
+  # objects. We've added additional fields of:
+  #
+  #     *  `isAvailableForPurchase` -- used to control product deletion in external systems
+  #     *  `acumenAttributes` -- Additional acumen data that doesn't have a direct 1:1 field
+  #        on the Product, but may be useful in other platforms
+  def process_inv_product_response(raw_data, digital_format_list)
+    raw_data.map do |p|
+
+      begin
+        product = response_mapper(p, {
+            'Inv_Product.ID' => 'identifier',
+            'Inv_Product.ProdCode' => 'sku',
+            'Inv_Product.Full_Title' => 'name',
+            'Inv_Product.SubTitle' => 'disambiguatingDescription',
+            'Inv_Product.ISBN_UPC' => 'isbn',
+            'Inv_Product.Pub_Date' => 'datePublished',
+            'Inv_Product.Next_Release' => 'releaseDate',
+        })
+
+        product['@type'] = 'Product'
+        product['isTaxable'] = get_field_value(p, 'Inv_Product.Taxable') == '1'
+        product['isAvailableForPurchase'] = get_field_value(p, 'Inv_Product.Not_On_Website') == '0'
+        product['acumenAttributes'] = {
+          'info_alpha_1' => get_field_value(p, 'Inv_Product.Info_Alpha_1'),
+          'info_boolean_1' => get_field_value(p, 'Inv_Product.Info_Boolean_1'), # is_available_on_formed
+        }
+        product['additionalProperty'] = [
+          {
+              '@type' => 'PropertyValue',
+              'propertyID' => 'is_master',
+              'value' => get_field_value(p, 'Inv_Product.OnWeb_LinkOnly') == '0',
+          }
+        ]
+
+        product['offers'] = [{
+          '@type' => 'Offer',
+          'price' => get_field_value(p, 'Inv_Product.Price_1'),
+          'availability' => get_field_value(p, 'Inv_Product.BO_Reason')
+        }]
+
+        if get_field_value(p, 'Inv_Product.Price_2')
+          product['offers'].push({
+            '@type' => 'Offer',
+            'price' => get_field_value(p, 'Inv_Product.Price_2'),
+            'availability' => get_field_value(p, 'Inv_Product.BO_Reason')
+          })
+        end
+
+        weight = get_field_value(p, 'Inv_Product.Weight')
+        product['weight'] = get_quantitative_value(weight, 'oz.')
+
+        # The category used here is the Acumen Product category. Functionally, this
+        # serves as the product's _format_. This field is different from Web Categories
+        # which behave more like traditional category taxonomies.
+        category = get_field_value(p, 'Inv_Product.Category')
+        if category
+          product['acumenAttributes']['category'] = category
+          product['isDigital'] = digital_format_list.find { |f| f == category } ? true : false
+
+          if category == 'Paperback'
+            product['additionalType'] = 'Book'
+            product['bookFormat'] = "http://schema.org/Paperback"
+            product['accessMode'] = "textual"
+          elsif category == 'Hardcover'
+            product['additionalType'] = 'Book'
+            product['bookFormat'] = "http://schema.org/Hardcover"
+            product['accessMode'] = "textual"
+          elsif category == 'eBook'
+            product['additionalType'] = 'Book'
+            product['bookFormat'] = "http://schema.org/EBook"
+            product['accessMode'] = "textual"
+          elsif category == 'CD'
+            product['additionalType'] = 'CreativeWork'
+            product['accessMode'] = "auditory"
+          end
+        end
+
+        product
+
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'process_inv_product_response',
+          'Failed to load Inventory Product Records',
+          { product_ids: product_ids },
+          error,
+        ))
+
+        return
+      end
+    end
+  end
+end

data/lib/huginn_acumen_product_agent/concerns/prod_mkt_query_concern.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# This module is responsible for reading/processing the ProdMkt table. This table
+# contains more detailed product meta information: Publisher, page counts, age range,
+# description, etc.
+module ProdMktQueryConcern
+  extend AcumenQueryConcern
+
+  # Update the provided products with their associated marketing data
+  # NOTE: The `products` here are Shema.org/Product records mapped from Inv_Product
+  # data
+  def fetch_product_marketing(acumen_client, products)
+
+    product_ids = products.map { |p| p['identifier'] }
+    marketing_data = acumen_client.get_products_marketing(product_ids)
+    marketing_data = process_prod_mkt_response(marketing_data)
+
+    return map_marketing_data(products, marketing_data)
+  end
+
+  # This function parses the raw data returned from the Prod_Mkt table
+  def process_prod_mkt_response(raw_data)
+    results = {}
+    raw_data.map do |product_marketing|
+
+      begin
+        mapped = response_mapper(product_marketing, {
+          'ProdMkt.Product_ID' => 'product_id',
+          'ProdMkt.Product_Code' => 'sku',
+          'ProdMkt.ID' => 'id',
+          'ProdMkt.Pages' => 'pages',
+          'ProdMkt.Publisher' => 'publisher',
+          'ProdMkt.Description_Short' => 'description_short',
+          'ProdMkt.Description_Long' => 'description_long',
+          'ProdMkt.Height' => 'height',
+          'ProdMkt.Width' => 'width',
+          'ProdMkt.Thickness' => 'depth',
+          'ProdMkt.Meta_Keywords' => 'meta_keywords',
+          'ProdMkt.Meta_Description' => 'meta_description',
+          'ProdMkt.Extent_Unit' => 'extent_unit',
+          'ProdMkt.Extent_Value' => 'extent_value',
+          'ProdMkt.Age_Highest' => 'age_highest',
+          'ProdMkt.Age_Lowest' => 'age_lowest',
+          'ProdMkt.Awards' => 'awards',
+          'ProdMkt.Dimensions_Unit_Measure' => 'dimensions_unit_measure',
+          'ProdMkt.Excerpt' => 'excerpt',
+          'ProdMkt.Grade_Highest' => 'grade_highest',
+          'ProdMkt.Grade_Lowest' => 'grade_lowest',
+          'ProdMkt.Status' => 'status',
+          'ProdMkt.UPC' => 'upc',
+          'ProdMkt.Weight_Unit_Measure' => 'weight_unit_measure',
+          'ProdMkt.Weight' => 'weight',
+          'ProdMkt.Info_Text_01' => 'info_text_01',
+          'ProdMkt.Info_Text_02' => 'info_text_02',
+          'ProdMkt.Religious_Text_Identifier' => 'religious_text_identifier',
+          'ProdMkt.Info_Alpha_07' => 'info_alpha_07',
+        })
+
+        results[mapped['product_id']] = mapped
+        # NOTE: In this case, product_id matches the Inv_Product.ID fields
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'process_prod_mkt_response',
+          'Failed while processing Prod_Mkt record',
+          product_marketing,
+          error,
+        ))
+      end
+    end
+
+    results
+  end
+
+  # This function maps parsed Prod_Mkt records to their matching product record
+  # and updates the product object with the additional data
+  def map_marketing_data(products, marketing_data)
+    products.map do |product|
+      marketing = marketing_data[product['identifier']]
+
+      begin
+
+        if marketing
+          product['acumenAttributes']['product_marketing_id'] = marketing['id']
+
+          product['publisher'] = {
+            '@type': 'Organization',
+            'name' => marketing['publisher']
+          };
+          product['description'] = marketing['description_long']
+          product['abstract'] = marketing['description_short']
+          product['keywords'] = marketing['meta_keywords']
+          product['text'] = marketing['excerpt']
+
+          if marketing['age_lowest'] && marketing['age_highest']
+            product['typicalAgeRange'] = "#{marketing['age_lowest']}-#{marketing['age_highest']}"
+          end
+
+          #----------  Product Page Attributes  ----------#
+          if marketing['grade_lowest'] || marketing['grade_highest']
+            # educationalUse? educationalAlignment?
+            product['additionalProperty'].push({
+              '@type' => 'PropertyValue',
+              'name' => 'Grade',
+              'propertyID' => 'grade_range',
+              'minValue' => marketing['grade_lowest'],
+              'maxValue' => marketing['grade_highest'],
+              'value' => "#{marketing['grade_lowest']}-#{marketing['grade_highest']}",
+            })
+          end
+
+          if marketing['awards']
+            product['additionalProperty'].push({
+              '@type' => 'PropertyValue',
+              'propertyID' => 'awards',
+              'name' => 'Awards',
+              'value' => marketing['awards'],
+            })
+          end
+
+          #----------  Acumen Specific Properties  ----------#
+          product['acumenAttributes']['extent_unit'] = marketing['extent_unit']
+          product['acumenAttributes']['extent_value'] = marketing['extent_value']
+          product['acumenAttributes']['info_text_01'] = marketing['info_text_01'] # editorial_reviews
+          product['acumenAttributes']['info_text_02'] = marketing['info_text_02'] # product_samples
+          product['acumenAttributes']['info_alpha_07'] = marketing['info_alpha_07'] # video_urls
+          product['acumenAttributes']['meta_description'] = marketing['meta_description']
+          product['acumenAttributes']['religious_text_identifier'] = marketing['religious_text_identifier']
+          product['acumenAttributes']['status'] = marketing['status']
+
+          product['gtin12'] = marketing['upc']
+          product['numberOfPages'] = marketing['pages']
+
+          product['height'] = get_quantitative_value(
+            marketing['height'], marketing['dimensions_unit_measure']
+          )
+          product['width'] = get_quantitative_value(
+            marketing['width'], marketing['dimensions_unit_measure']
+          )
+          product['depth'] = get_quantitative_value(
+            marketing['thickness'], marketing['dimensions_unit_measure']
+          )
+          if product['weight']['value'] == '0'
+              product['weight'] = get_quantitative_value(
+                marketing['weight'], marketing['weight_unit_measure']
+              )
+          end
+        end
+
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'map_marketing_data',
+          'Failed to map marketing data for product',
+          { product: product, marketing: marketing },
+          error,
+        ))
+      end
+
+      product
+    end
+
+    return products
+  end
+end

data/lib/huginn_acumen_product_agent/concerns/product_categories_query_concern.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# This module is responsible for reading/processing data from the ProdMkt_WPC table
+# NOTE:  Records on this table are linked to products by SKU
+module ProductCategoriesQueryConcern
+  extend AcumenQueryConcern
+
+  # Updates the provided products with their associated category data
+  def fetch_product_categories(acumen_client, products)
+
+    product_skus = products.map { |p| p['sku'] }
+    category_data = acumen_client.get_product_categories(product_skus)
+    category_data = process_product_category_response(category_data)
+
+    return map_category_data(products, category_data)
+  end
+
+  # This function parses the raw data returned from the ProdMkt_WPC table
+  # This table holds the relationship between products and Web Categories
+  # The resulting data contains arrays of Category records keyed to product SKUs
+  #
+  # NOTE: In the Acumen data, some Category assignments are marked as inactive.
+  # This function only returns _active_ categories in the resulting data.
+  def process_product_category_response(raw_data)
+    results = {}
+
+    raw_data.map do |product_category|
+
+      begin
+        mapped = response_mapper(product_category, {
+          'ProdMkt_WPC.ProdCode' => 'sku',
+          'ProdMkt_WPC.WPC_ID' => 'category_id',
+          'ProdMkt_WPC.Inactive' => 'inactive',
+        })
+
+        product_sku = mapped['sku']
+
+        if results[product_sku]
+          results[product_sku].push(mapped) if mapped['inactive'] == '0'
+        else
+          results[product_sku] = [mapped] if mapped['inactive'] == '0'
+        end
+      rescue => error
+        issue_errpr(AcumenAgentError.new(
+          'process_product_category_response',
+          'Failed while processing category data',
+          product_category,
+          error,
+        ))
+      end
+    end
+
+    results
+  end
+
+  # This function maps parsed Web Category records to their matching Product
+  def map_category_data(products, category_data)
+    products.each do |product|
+      product['categories'] = []
+      categories = category_data[product['sku']]
+
+      unless categories.nil?
+        categories.map do |cat|
+          product['categories'].push({
+            '@type' => 'Thing',
+            'identifier' => cat['category_id']
+          })
+        end
+      end
+    end
+
+    return products
+  end
+end

data/lib/huginn_acumen_product_agent/concerns/product_contributors_query_concern.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# This module is responsible for reading/processing product Contributor data.
+#
+# The data in question here comes from multiple tables. The `ProdMkt_Contrib_Link`
+# table defines the _relationship_ between products and contributors, and the
+# `ProdMkt_Contributor` table defines the _contribution type_ (Author, Editor, etc)
+module ProductContributorsQueryConcern
+  extend AcumenQueryConcern
+
+  # Updates the provided products with their associared contributor data
+  def fetch_product_contributors(acumen_client, products)
+
+    marketing_ids = products.map { |p| p['acumenAttributes']['product_marketing_id'] }
+    contributor_data = acumen_client.get_product_contributors(marketing_ids)
+    contributor_data = process_product_contributor_response(contributor_data)
+
+    contributor_ids = contributor_data.map { |c| c['contributor_id'] }
+    contributor_type_data = acumen_client.get_contributor_types(contributor_ids)
+    contributor_type_data = process_contributor_type_response(contributor_type_data)
+
+    return map_contributor_data(products, contributor_data, contributor_type_data)
+  end
+
+  # This function parses the raw data returned from the ProdMkt_Contrib_Link table
+  # This table holds the relationship between products and Contributors
+  # The resulting data is a hash mapping contributor arrays to Prod_Mkt.ID values
+  def process_product_contributor_response(raw_data)
+    contributors = []
+
+    raw_data.each do |contributor|
+
+      begin
+        mapped = response_mapper(contributor, {
+          'ProdMkt_Contrib_Link.ProdMkt_Contrib_ID' => 'contributor_id',
+          'ProdMkt_Contrib_Link.ProdMkt_ID' => 'product_marketing_id',
+          'ProdMkt_Contrib_Link.Inactive' => 'inactive',
+        })
+
+        if mapped['inactive'] == '0'
+          contributors.push(mapped)
+        end
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'process_product_contributor_response',
+          'Failed while processing contributor record',
+          contributor,
+          error,
+        ))
+      end
+    end
+
+    return contributors
+  end
+
+  # This function parses the raw data returned from the ProdMkt_Contributor table
+  # This table holds the contributor type (e.g. Author) for the
+  # contributor/product relationship
+  def process_contributor_type_response(raw_data)
+    results = {}
+    raw_data.map do |contributor_type|
+
+      begin
+        mapped = response_mapper(contributor_type, {
+          'ProdMkt_Contributor.ID' => 'contributor_id',
+          'ProdMkt_Contributor.Contrib_Type' => 'type',
+        })
+
+
+        if !results[mapped['contributor_id']]
+          results[mapped['contributor_id']] = mapped['type']
+        end
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'process_contributor_type_response',
+          'Failed while processing contributor type record',
+          contributor_type,
+          error,
+        ))
+      end
+    end
+
+    return results
+  end
+
+  # This function maps parsed Contributor records to their matching Inv_Product record
+  def map_contributor_data(products, contributor_data, contributor_type_data)
+    products.each do |product|
+
+      begin
+        marketing_id = product['acumenAttributes']['product_marketing_id']
+        contributors = contributor_data.select { |c| c['product_marketing_id'] == marketing_id }
+
+        product['contributors'] = contributors.map do |c|
+          {
+            '@type' => 'Person',
+            'identifier' => c['contributor_id'],
+            'acumenAttributes' => {
+              'contrib_type' => contributor_type_data[c['contributor_id']]
+            }
+          }
+        end
+      rescue => error
+        issue_error(AcumenAgentError.new(
+          'map_contributor_data',
+          'Failed while mapping contributor data to products',
+          { product: product, contributors: contributor_data, contributor_types: contributor_type_data },
+          error
+        ))
+      end
+    end
+
+    return products
+  end
+
+end