huginn_acumen_product_agent 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6d6febab93205d4676c198c74dc8eb8d956f775eaa3ce800387c1b84e849921
+  data.tar.gz: 5dd201cfb88672b67a8e4350056c30204843a9460afb2573c0e0587acabfff8f
+SHA512:
+  metadata.gz: a1bd50ef65b8361ebfbd2b1b6e938c971790426620b4d56f62d95d1ccc7b19eca6a6f017336fd23b840d446472d65cd9f133f0e0e5635a67fb160af81c22dadb
+  data.tar.gz: 6931f53b778d415e2e3f4a51a242bb9a97e47fcb6692818d2e9c6489a7c96864dee5264a7fd6351d2541d07da5f25b014e30358991eb22084aeb96f17bc52c8f

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2020 Jacob Spizziri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/huginn_acumen_product_agent.rb

@@ -0,0 +1,6 @@
+require 'huginn_agent'
+
+HuginnAgent.load 'huginn_acumen_product_agent/concerns/acumen_product_query_concern'
+HuginnAgent.load 'huginn_acumen_product_agent/acumen_client'
+
+HuginnAgent.register 'huginn_acumen_product_agent/acumen_product_agent'

data/lib/huginn_acumen_product_agent/acumen_client.rb

@@ -0,0 +1,257 @@
+class AcumenClient
+  @faraday
+  @auth
+
+  def initialize(faraday, auth)
+    @faraday = faraday
+    @auth = auth
+  end
+
+  def get_products(ids)
+      body = build_product_request(ids)
+      response = execute_in_list_query(body, {})
+      get_results(response, 'Inv_Product')
+  end
+
+  def get_products_marketing(ids)
+      body = build_product_marketing_query(ids)
+      response = execute_in_list_query(body, {})
+      get_results(response, 'ProdMkt')
+  end
+
+  def get_linked_products(ids)
+      body = build_linked_product_query(ids)
+      response = execute_in_list_query(body, {})
+      get_results(response, 'Product_Link')
+  end
+
+  def get_product_contributors(ids)
+      body = build_product_contributor_link_query(ids)
+      response = execute_in_list_query(body, {})
+      get_results(response, 'ProdMkt_Contrib_Link')
+  end
+
+  def get_product_categories(skus)
+      q = build_product_categories_query(skus)
+      response = execute_in_list_query(q, {})
+      get_results(response, 'ProdMkt_WPC')
+  end
+
+
+  def execute_query(body, headers)
+      response = @faraday.run_request(:post, "#{@auth['endpoint']}/Query", body, headers)
+      ::MultiXml.parse(response.body, {})
+  end
+
+  def execute_in_list_query(body, headers)
+      response = @faraday.run_request(:post, "#{@auth['endpoint']}/QueryByInList", body, headers)
+      ::MultiXml.parse(response.body, {})
+  end
+
+  def get_results(response, name)
+      result_set = response['Envelope']['Body']['acusoapResponse']['result_set.' + name]
+      results = result_set.nil? ? [] : result_set[name]
+      results.is_a?(Array) ? results : [results]
+  end
+
+  private
+
+  def build_product_request(ids)
+      <<~XML
+          <acusoapRequest>
+              #{build_acumen_query_auth()}
+              <query>
+                <statement>
+                  <column_name>Inv_Product.ID</column_name>
+                  <comparator>in</comparator>
+                  <value>#{ids.join(',')}</value>
+                </statement>
+              </query>
+              <requested_output>
+                  <view_owner_table_name>Inv_Product</view_owner_table_name>
+                  <view_name>Inv_ProductAllRead</view_name>
+                  <column_name>Inv_Product.ID</column_name>
+                  <column_name>Inv_Product.ProdCode</column_name>
+                  <column_name>Inv_Product.Title</column_name>
+                  <column_name>Inv_Product.Full_Title</column_name>
+                  <column_name>Inv_Product.SubTitle</column_name>
+                  <column_name>Inv_Product.ISBN_UPC</column_name>
+                  <column_name>Inv_Product.Price_1</column_name>
+                  <column_name>Inv_Product.Price_2</column_name>
+                  <column_name>Inv_Product.Weight</column_name>
+                  <column_name>Inv_Product.Taxable</column_name>
+                  <column_name>Inv_Product.Pub_Date</column_name>
+                  <column_name>Inv_Product.DateTimeStamp</column_name>
+                  <column_name>Inv_Product.OnWeb_LinkOnly</column_name>
+                  <column_name>Inv_Product.Download_Product</column_name>
+                  <column_name>Inv_Product.Info_Alpha_1</column_name>
+                  <column_name>Inv_Product.Info_Boolean_1</column_name>>
+                  <column_name>Inv_Product.Category</column_name>
+              </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_product_marketing_query(ids)
+      <<~XML
+          <acusoapRequest>
+              #{build_acumen_query_auth()}
+              <query>
+                <statement>
+                  <column_name>ProdMkt.Product_ID</column_name>
+                  <comparator>in</comparator>
+                  <value>#{ids.join(',')}</value>
+                </statement>
+              </query>
+              <requested_output>
+                <view_owner_table_name>ProdMkt</view_owner_table_name>
+                <view_name>ProdMktAllRead</view_name>
+                  <column_name>ProdMkt.Product_ID</column_name>
+                  <column_name>ProdMkt.Product_Code</column_name>
+                  <column_name>ProdMkt.ID</column_name>
+                  <column_name>ProdMkt.DateTimeStamp</column_name>
+                  <column_name>ProdMkt.Pages</column_name>
+                  <column_name>ProdMkt.Publisher</column_name>
+                  <column_name>ProdMkt.Description_Short</column_name>
+                  <column_name>ProdMkt.Description_Long</column_name>
+                  <column_name>ProdMkt.Height</column_name>
+                  <column_name>ProdMkt.Width</column_name>
+                  <column_name>ProdMkt.Thickness</column_name>
+                  <column_name>ProdMkt.Meta_Keywords</column_name>
+                  <column_name>ProdMkt.Meta_Description</column_name>
+                  <column_name>ProdMkt.Extent_Unit</column_name>
+                  <column_name>ProdMkt.Extent_Value</column_name>
+                  <column_name>ProdMkt.Age_Highest</column_name>
+                  <column_name>ProdMkt.Age_Lowest</column_name>
+                  <column_name>ProdMkt.Awards</column_name>
+                  <column_name>ProdMkt.Dimensions_Unit_Measure</column_name>
+                  <column_name>ProdMkt.Excerpt</column_name>
+                  <column_name>ProdMkt.Grade_Highest</column_name>
+                  <column_name>ProdMkt.Grade_Lowest</column_name>
+                  <column_name>ProdMkt.Status</column_name>
+                  <column_name>ProdMkt.UPC</column_name>
+                  <column_name>ProdMkt.Weight_Unit_Measure</column_name>
+                  <column_name>ProdMkt.Weight</column_name>
+                  <column_name>ProdMkt.Info_Text_01</column_name>
+                  <column_name>ProdMkt.Info_Text_02</column_name>
+                  <column_name>ProdMkt.Religious_Text_Identifier</column_name>
+              </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_product_ids_since_request(since)
+      <<~XML
+          <acusoapRequest>
+            #{build_acumen_query_auth()}
+            <query>
+              <statement>
+                <column_name>Inv_Product.Not_Active</column_name>
+                <comparator>equals</comparator>
+                <value>false</value>
+                <conjunction>and</conjunction>
+              </statement>
+              <statement>
+                <column_name>Inv_Product.Not_On_Website</column_name>
+                <comparator>equals</comparator>
+                <value>false</value>
+                <conjunction>and</conjunction>
+              </statement>
+              <statement>
+                <column_name>Inv_Product.DateTimeStamp</column_name>
+                <comparator>greater than</comparator>
+                <value>#{since}</value>
+                <conjunction>and</conjunction>
+              </statement>
+              <statement>
+                <column_name>Inv_Product.OnWeb_LinkOnly</column_name>
+                <comparator>equals</comparator>
+                <value>false</value>
+                <conjunction>and</conjunction>
+              </statement>
+            </query>
+            <requested_output>
+              <view_owner_table_name>Inv_Product</view_owner_table_name>
+              <view_name>Inv_ProductAllRead</view_name>
+              <column_name>Inv_Product.ID</column_name>
+            </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_linked_product_query(ids)
+      <<~XML
+          <acusoapRequest>
+            #{build_acumen_query_auth()}
+            <query>
+              <statement>
+                <column_name>Product_Link.Link_From_ID</column_name>
+                <comparator>in</comparator>
+                <value>#{ids.join(',')}</value>
+              </statement>
+            </query>
+            <requested_output>
+              <view_owner_table_name>Product_Link</view_owner_table_name>
+              <view_name>Product_LinkAllRead</view_name>
+              <column_name>Product_Link.Link_From_ID</column_name>
+              <column_name>Product_Link.Link_To_ID</column_name>
+              <column_name>Product_Link.Alt_Format</column_name>
+            </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_product_categories_query(ids)
+      <<~XML
+          <acusoapRequest>
+              #{build_acumen_query_auth()}
+              <query>
+                <statement>
+                  <column_name>ProdMkt_WPC.ProdCode</column_name>
+                  <comparator>in</comparator>
+                  <value>#{ids.join(',')}</value>
+                </statement>
+              </query>
+              <requested_output>
+                <view_owner_table_name>ProdMkt_WPC</view_owner_table_name>
+                <view_name>ProdMkt_WPCAllRead</view_name>
+                <column_name>ProdMkt_WPC.ProdCode</column_name>
+                <column_name>ProdMkt_WPC.WPC_ID</column_name>
+                <column_name>ProdMkt_WPC.Inactive</column_name>
+              </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_product_contributor_link_query(ids)
+      <<~XML
+          <acusoapRequest>
+              #{build_acumen_query_auth()}
+              <query>
+                <statement>
+                  <column_name>ProdMkt_Contrib_Link.ProdMkt_ID</column_name>
+                  <comparator>in</comparator>
+                  <value>#{ids.join(',')}</value>
+                </statement>
+              </query>
+              <requested_output>
+                <view_owner_table_name>ProdMkt_Contrib_Link</view_owner_table_name>
+                <view_name>ProdMkt_Contrib_LinkAllRead</view_name>
+                <column_name>ProdMkt_Contrib_Link.ProdMkt_Contrib_ID</column_name>
+                <column_name>ProdMkt_Contrib_Link.ProdMkt_ID</column_name>
+                <column_name>ProdMkt_Contrib_Link.Inactive</column_name>
+              </requested_output>
+          </acusoapRequest>
+      XML
+  end
+
+  def build_acumen_query_auth()
+      <<~XML
+          <authentication>
+            <site_code>#{@auth['site_code']}</site_code>
+            <password>#{@auth['password']}</password>
+          </authentication>
+          <message_version>1.00</message_version>
+      XML
+  end
+end

data/lib/huginn_acumen_product_agent/acumen_product_agent.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Agents
+    class AcumenProductAgent < Agent
+        include WebRequestConcern
+        include AcumenProductQueryConcern
+
+        default_schedule '12h'
+
+        can_dry_run!
+        default_schedule 'never'
+
+        description <<-MD
+      Huginn agent for sane ACUMEN product data.
+        MD
+
+        def default_options
+            {
+                'endpoint' => 'https://example.com',
+                'site_code' => '',
+                'password' => '',
+                'attribute_to_property' => {},
+            }
+        end
+
+        def validate_options
+            unless options['endpoint'].present?
+                errors.add(:base, 'endpoint is a required field')
+            end
+
+            unless options['site_code'].present?
+                errors.add(:base, 'site_code is a required field')
+            end
+
+            unless options['password'].present?
+                errors.add(:base, 'password is a required field')
+            end
+
+            unless options['attribute_to_property'].is_a?(Hash)
+                errors.add(:base, "if provided, attribute_to_property must be a hash")
+            end
+        end
+
+        def working?
+            received_event_without_error?
+        end
+
+        def check
+            handle interpolated['payload'].presence || {}
+        end
+
+        def receive(incoming_events)
+            incoming_events.each do |event|
+                handle(event)
+            end
+       end
+
+        private
+
+        def handle(event)
+            endpoint = interpolated['endpoint']
+            site_code = interpolated['site_code']
+            password = interpolated['password']
+
+            auth = {
+                'site_code' => site_code,
+                'password' => password,
+                'endpoint' => endpoint,
+            }
+            client = AcumenClient.new(faraday, auth)
+
+            ids = event.payload['ids']
+            products = get_products_by_ids(client, ids)
+            products = get_product_variants(client, products)
+            products = get_product_categories(client, products)
+            products = get_product_contributors(client, products)
+
+            # map attributes
+            products.map do |product|
+                map_attributes(product)
+
+                product['model'].each do |model|
+                    map_attributes(model)
+                end
+
+                product
+            end
+
+            products.each do |product|
+                create_event payload: product
+            end
+        end
+
+        private
+
+        def map_attributes(product)
+            attribute_to_property = interpolated['attribute_to_property']
+            attributes = product['acumenAttributes']
+
+            attributes.each do |key,val|
+                if attribute_to_property[key] && val
+                    product['additionalProperty'] = [] if product['additionalProperty'].nil?
+                    product['additionalProperty'].push({
+                        '@type' => 'PropertyValue',
+                        'propertyID' => attribute_to_property[key],
+                        'value' => val,
+                    })
+
+                    attributes.delete(key)
+                end
+            end
+        end
+
+    end
+end

data/lib/huginn_acumen_product_agent/concerns/acumen_product_query_concern.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+module AcumenProductQueryConcern
+    extend ActiveSupport::Concern
+
+    UNIT_MAP = {
+      'oz.' => 'OZ',
+      'Inches (US)' => 'INH',
+    }
+
+    def get_products_by_ids(acumen_client, ids)
+        response = acumen_client.get_products(ids)
+        products = parse_product_request(response)
+
+        response = acumen_client.get_products_marketing(ids)
+        marketing = parse_product_marketing_request(response)
+
+        merge_products_and_marketing(products, marketing)
+    end
+
+    def get_variants_for_ids(acumen_client, ids)
+        result = get_linked_products_by_ids(acumen_client, ids)
+        result.select { |link| link['alt_format'].to_s != 0.to_s }
+    end
+
+    def get_linked_products_by_ids(acumen_client, ids)
+        response = acumen_client.get_linked_products(ids)
+        process_linked_product_query(response)
+    end
+
+    def get_product_contributors(acumen_client, products)
+        ids = products.map {|product| product['acumenAttributes']['product_marketing_id']}
+        response = acumen_client.get_product_contributors(ids)
+        product_contributors = process_product_contributor_query(response)
+
+        products.each do |product|
+            id = product['acumenAttributes']['product_marketing_id']
+            product_contributor = product_contributors[id]
+
+            if product_contributor
+                product['contributor'] = product_contributor.map do |pc|
+                    {
+                        '@type' => 'Person',
+                        'identifier' => pc['contributor_id']
+                    }
+                end
+            end
+        end
+        products
+    end
+
+    def get_product_variants(acumen_client, products)
+        ids = products.map { |product| product['identifier'] }
+        # fetch product/variant relationships
+        variant_links = get_variants_for_ids(acumen_client, ids)
+        variant_ids = variant_links.map { |link| link['to_id'] }
+
+        variant_ids = variant_links.map { |link| link['to_id'] }
+
+        # fetch product variants
+        variants = get_products_by_ids(acumen_client, variant_ids)
+
+        # merge variants and products together
+        process_products_and_variants(products, variants, variant_links)
+    end
+
+    def get_product_categories(acumen_client, products)
+        # fetch categories
+        skus = products.map { |product| product['sku'] }
+        response = acumen_client.get_product_categories(skus)
+        categories = process_product_categories_query(response)
+
+        # map categories to products
+        products.each do |product|
+            sku = product['sku']
+            if categories[sku]
+                active = categories[sku].select { |c| c['inactive'] != 0 }
+                product['categories'] = active.map do |category|
+                  {
+                    '@type' => 'Thing',
+                    'identifier' => category['category_id']
+                  }
+                end
+            end
+        end
+
+        products
+    end
+
+    def parse_product_request(products)
+        products.map do |p|
+            variant = response_mapper(p, {
+                'Inv_Product.ID' => 'identifier',
+                'Inv_Product.ProdCode' => 'sku',
+                'Inv_Product.SubTitle' => 'disambiguatingDescription',
+                'Inv_Product.ISBN_UPC' => 'isbn',
+                'Inv_Product.Pub_Date' => 'datePublished',
+            })
+            variant['@type'] = 'ProductModel'
+            variant['isDefault'] = field_value(p, 'Inv_Product.OnWeb_LinkOnly') == '0'
+            variant['isTaxable'] = field_value(p, 'Inv_Product.Taxable') == '1'
+
+            variant['offers'] = [{
+                '@type' => 'Offer',
+                'price' => field_value(p, 'Inv_Product.Price_1'),
+            }]
+            if field_value(p, 'Inv_Product.Price_2')
+              variant['offers'].push({
+                  '@type' => 'Offer',
+                  'price' => field_value(p, 'Inv_Product.Price_2'),
+              })
+            end
+
+            weight = field_value(p, 'Inv_Product.Weight')
+            variant['weight'] = quantitative_value(weight, 'oz.')
+
+            product = {
+                '@type' => 'Product',
+                'identifier' => variant['identifier'],
+                'sku' => variant['sku'],
+                'name' => field_value(p, 'Inv_Product.Full_Title'),
+                'model' => [
+                    variant
+                ],
+                'additionalProperty' => [],
+                'acumenAttributes' => {
+                    'info_alpha_1' => field_value(p, 'Inv_Product.Info_Alpha_1'),
+                    'info_boolean_1' => field_value(p, 'Inv_Product.Info_Boolean_1'),
+                },
+            }
+
+            category = field_value(p, 'Inv_Product.Category')
+            if category
+
+              if variant['acumenAttributes']
+                variant['acumenAttributes']['category'] = category
+              else
+                 variant['acumenAttributes'] = { 'category' => category }
+              end
+
+              if category == 'Paperback'
+                product['additionalType'] = variant['additionalType'] = 'Book'
+                variant['bookFormat'] = "http://schema.org/Paperback"
+                variant['accessMode'] = "textual"
+                variant['isDigital'] = false
+              elsif category == 'Hardcover'
+                product['additionalType'] = variant['additionalType'] = 'Book'
+                variant['bookFormat'] = "http://schema.org/Hardcover"
+                variant['accessMode'] = "textual"
+                variant['isDigital'] = false
+              elsif category == 'eBook'
+                product['additionalType'] = variant['additionalType'] = 'Book'
+                variant['bookFormat'] = "http://schema.org/EBook"
+                variant['accessMode'] = "textual"
+                variant['isDigital'] = true
+              elsif category == 'CD'
+                product['additionalType'] = variant['additionalType'] = 'CreativeWork'
+                variant['accessMode'] = "auditory"
+                variant['isDigital'] = false
+              else
+                variant['isDigital'] = false
+              end
+            end
+
+            product
+        end
+    end
+
+    def process_linked_product_query(links)
+        links.map do |link|
+            response_mapper(link, {
+                'Product_Link.Link_From_ID' => 'from_id',
+                'Product_Link.Link_To_ID' => 'to_id',
+                'Product_Link.Alt_Format' => 'alt_format',
+            })
+        end
+    end
+
+    def parse_product_marketing_request(products)
+        results = {}
+        products.each do |product|
+            mapped = response_mapper(product, {
+                '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',
+            })
+
+            results[mapped['product_id']] = mapped
+        end
+
+        results
+    end
+
+    def merge_products_and_marketing(products, product_marketing)
+        products.each do |product|
+            marketing = product_marketing[product['identifier']]
+            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
+
+                # properties for product pages
+                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']
+                product['acumenAttributes']['info_text_02'] = marketing['info_text_02']
+                product['acumenAttributes']['meta_description'] = marketing['meta_description']
+                product['acumenAttributes']['religious_text_identifier'] = marketing['religious_text_identifier']
+                product['acumenAttributes']['status'] = marketing['status']
+
+                variant = product['model'][0]
+                variant['gtin12'] = marketing['upc']
+                variant['numberOfPages'] = marketing['pages']
+
+                variant['height'] = quantitative_value(
+                  marketing['height'], marketing['dimensions_unit_measure']
+                )
+                variant['width'] = quantitative_value(
+                  marketing['width'], marketing['dimensions_unit_measure']
+                )
+                variant['depth'] = quantitative_value(
+                  marketing['thickness'], marketing['dimensions_unit_measure']
+                )
+                variant['weight'] = quantitative_value(
+                  marketing['weight'], marketing['weight_unit_measure']
+                )
+            end
+        end
+
+        products
+    end
+
+    def process_product_categories_query(categories)
+        results = {}
+        categories.each do |category|
+            mapped = response_mapper(category, {
+                'ProdMkt_WPC.ProdCode' => 'sku',
+                'ProdMkt_WPC.WPC_ID' => 'category_id',
+                'ProdMkt_WPC.Inactive' => 'inactive',
+            })
+
+            if results[mapped['sku']]
+                results[mapped['sku']].push(mapped)
+            else
+                results[mapped['sku']] = [mapped]
+            end
+        end
+
+        results
+    end
+
+    def process_product_contributor_query(contributors)
+        results = {}
+        contributors.each do |contributor|
+            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 results[mapped['product_marketing_id']]
+                results[mapped['product_marketing_id']].push(mapped)
+            else
+                results[mapped['product_marketing_id']] = [mapped]
+            end
+        end
+        results
+    end
+
+    def process_products_and_variants(products, variants, links)
+        products_map = {}
+        products.each { |product| products_map[product['identifier']] = product }
+
+        variants_map = {}
+        variants.each { |variant| variants_map[variant['identifier']] = variant }
+
+        links.each do |link|
+            from_id = link['from_id']
+            to_id = link['to_id']
+            variant = variants_map[to_id]
+            variant['isDefault'] = false
+            products_map[from_id]['model'].push(*variant['model'])
+        end
+
+        result = []
+        products_map.each_value { |p| result.push(p) }
+        result
+    end
+
+    private
+
+    def response_mapper(data, map)
+        result = {}
+        map.each do |key,val|
+            result[val] = field_value(data, key)
+        end
+
+        result
+    end
+
+    def field_value(field, key)
+        field[key]['__content__'] if field[key]
+    end
+
+    def quantitative_value(value, unit)
+      {
+        '@type' => 'QuantitativeValue',
+        'value' => value,
+        'unitText' => unit,
+        'unitCode' => (UNIT_MAP[unit] if unit),
+      } if value
+    end
+end

data/spec/acumen_product_agent_spec.rb

@@ -0,0 +1,61 @@
+require 'rails_helper'
+require 'huginn_agent/spec_helper'
+require 'yaml'
+
+require_relative '../lib/huginn_acumen_product_agent/acumen_client'
+
+spec_folder = File.expand_path(File.dirname(__FILE__))
+mock_data = YAML.load(File.read(spec_folder + "/acumen_product_agent_spec.yml"))
+
+def mock_response(ns, ids)
+    records = ids.map {|id| mock_data[ns][id]}
+    response = <<~TEXT
+        <?xml version="1.0" encoding="UTF-8"?>
+        <SOAP-ENV:Envelope
+        SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
+        xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
+        xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
+        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+        <SOAP-ENV:Body>
+        <acusoapResponse>
+          <result_set.#{ns}>#{records.join("\n")}</result_set.#{ns}>
+        </acusoapResponse>
+        </SOAP-ENV:Body>
+        </SOAP-ENV:Envelope>
+    TEXT
+    response = ::MultiXml.parse(response, {})
+    AcumenClient::get_results(response, ns)
+end
+
+allow(AcumenClient).to receive(:get_products) do |ids|
+  mock_response('Inv_Product', ids)
+end
+
+allow(AcumenClient).to receive(:get_products_marketing) do |ids|
+  mock_response('ProdMkt', ids)
+end
+
+allow(AcumenClient).to receive(:get_linked_products) do |ids|
+  mock_response('Product_Link', ids)
+end
+
+allow(AcumenClient).to receive(:get_product_contributors) do |ids|
+  mock_response('ProdMkt_Contrib_Link', ids)
+end
+
+allow(AcumenClient).to receive(:get_product_categories) do |ids|
+  mock_response('ProdMkt_WPC', ids)
+end
+
+
+describe Agents::AcumenProductAgent do
+  before(:each) do
+    @valid_options = Agents::AcumenProductAgent.new.default_options
+    @checker = Agents::AcumenProductAgent.new(:name => "AcumenProductAgent", :options => @valid_options)
+    @checker.user = users(:bob)
+    @checker.save!
+  end
+
+  pending "add specs here"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: huginn_acumen_product_agent
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jacob Spizziri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: huginn_agent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Huginn ACUMEN Product Agent takes in an array of ACUMEN product ID's,
+  queries the relevant ACUMEN tables, and emits a set of events with a sane data interface
+  for each those events.
+email:
+- jacob.spizziri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/huginn_acumen_product_agent.rb
+- lib/huginn_acumen_product_agent/acumen_client.rb
+- lib/huginn_acumen_product_agent/acumen_product_agent.rb
+- lib/huginn_acumen_product_agent/concerns/acumen_product_query_concern.rb
+- spec/acumen_product_agent_spec.rb
+homepage: https://github.com/5-Stones/huginn_acumen_product_agent
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Huginn agent for sane ACUMEN product data.
+test_files:
+- spec/acumen_product_agent_spec.rb