huginn_bigcommerce_product_agent 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7c7ba2d9c033ac9bcb4e6b918e5061e4a24aefc5969df512976bcb40ba9dff99
+  data.tar.gz: 27ba376c8ae1c70e19e0f0412e742899885aa42946ec4ceec22a3efcac96b409
+SHA512:
+  metadata.gz: dcd14b6b838f97586e9b7d039ef6620074d56cb76cf90623edfc4ddd2b6826e9ad4c675f5fd68c36d393f8933dc86d440372727c13171330f276a5116adb7df1
+  data.tar.gz: 0f73c946976ad3b633635e32c79e823a1a36e57cee63708aac667bbcb86726c6a3761549021636d45cbfaee146baa23c05f584ba38003adf5990e0fe4db78dcb

data/lib/abstract_client.rb

@@ -0,0 +1,80 @@
+
+module BigcommerceProductAgent
+    module Client
+        class AbstractClient
+            @client = nil
+            @uri_base = ''
+
+            def initialize(
+                store_hash,
+                client_id,
+                access_token,
+                params = {
+                    endpoint: 'https://api.bigcommerce.com',
+                    api_version: 'v3',
+                }
+            )
+                @headers = {
+                    'X-Auth-Client' => client_id,
+                    'X-Auth-Token' => access_token,
+                    'Content-Type' => 'application/json',
+                    'Accept' => 'application/json'
+                }
+                @store_hash = store_hash
+                @endpoint = params[:endpoint]
+                @api_version = params[:api_version]
+            end
+
+            def self.uri_base
+                @uri_base
+            end
+
+            def uri_base
+                self.class.uri_base
+            end
+
+            def client
+                if !@client
+                    @client = Faraday.new({ url: @endpoint, headers: @headers }) do |conn|
+                        conn.use Faraday::Response::RaiseError
+                        conn.response :logger, nil, { headers: true, bodies: true }
+                        conn.response :json, :content_type => 'application/json'
+                        conn.adapter Faraday.default_adapter
+                    end
+                end
+
+                return @client
+            end
+
+            def uri(params = {})
+                u = "/stores/#{@store_hash}/#{@api_version}/#{uri_base}"
+
+                params.each do |key,val|
+                  u = u.gsub(":#{key.to_s}", val.to_s)
+                end
+
+                # remove params that weren't provided
+                u = u.gsub(/(\/\:[^\/]+)/, '')
+
+                return u
+            end
+
+            def index(params = {})
+                response = client.get(uri, params)
+                return response.body['data']
+            end
+
+            def create(payload)
+                raise "not implemented yet."
+            end
+
+            def update(payload)
+                raise "not implemented yet."
+            end
+
+            def upsert(payload)
+                raise "not implemented yet."
+            end
+        end
+    end
+end

data/lib/client/custom_field.rb

@@ -0,0 +1,11 @@
+module BigcommerceProductAgent
+    module Client
+        class CustomField < AbstractClient
+            @uri_base = 'catalog/products/:product_id/custom-fields/:custom_field_id'
+
+            def delete(product_id, custom_field_id)
+                client.delete(uri(product_id: product_id, custom_field_id: custom_field_id))
+            end
+        end
+    end
+end

data/lib/client/modifier.rb

@@ -0,0 +1,35 @@
+module BigcommerceProductAgent
+    module Client
+        class Modifier < AbstractClient
+            @uri_base = 'catalog/products/:product_id/modifiers/:modifier_id'
+
+            def delete(product_id, modifier_id)
+                client.delete(uri(product_id: product_id, modifier_id: modifier_id))
+            end
+
+            def upsert(product_id, modifier)
+                begin
+                    if modifier[:id] || modifier['id']
+                        modifier['id'] = modifier[:id] unless modifier[:id].nil?
+                        return update(product_id, modifier)
+                    else
+                        return create(product_id, modifier)
+                    end
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
+
+            def update(product_id, modifier)
+                response = client.put(uri(product_id: product_id, modifier_id: modifier['id']), modifier.to_json)
+                return response.body['data']
+            end
+
+            def create(product_id, modifier)
+                response = client.post(uri(product_id: product_id), modifier.to_json)
+                return response.body['data']
+            end
+        end
+    end
+end

data/lib/client/modifier_value.rb

@@ -0,0 +1,11 @@
+module BigcommerceProductAgent
+    module Client
+        class ModifierValue < AbstractClient
+            @uri_base = 'catalog/products/:product_id/modifiers/:modifier_id/values/:value_id'
+
+            def delete(product_id, modifier_id, value_id)
+                client.delete(uri(product_id: product_id, modifier_id: modifier_id, value_id: value_id))
+            end
+        end
+    end
+end

data/lib/client/product.rb

@@ -0,0 +1,46 @@
+module BigcommerceProductAgent
+    module Client
+        class Product < AbstractClient
+            @uri_base = 'catalog/products/:product_id'
+
+            def update(id, payload)
+                response = client.put(uri(product_id: id), { data: payload }.to_json)
+                return response.body['data']
+            end
+
+            def create(payload)
+                response = client.post(uri, payload.to_json)
+                return response.body['data']
+            end
+
+            def upsert(payload)
+                begin
+                    if payload['id']
+                        return update(payload['id'], payload)
+                    else
+                        return create(payload)
+                    end
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
+
+            def get_by_skus(skus, include = %w[custom_fields modifiers])
+                products = index({
+                    'sku:in': skus.join(','),
+                    include: include.join(','),
+                })
+
+                map = {}
+
+                products.each do |product|
+                    map[product['sku']] = product
+                end
+
+                map
+            end
+
+        end
+    end
+end

data/lib/huginn_bigcommerce_product_agent.rb

@@ -0,0 +1,15 @@
+require 'huginn_agent'
+require 'json'
+
+# load clients
+HuginnAgent.load 'abstract_client'
+Dir[File.join(__dir__, 'client', '*.rb')].each do |file|
+    HuginnAgent.load file
+end
+
+# load mappers
+Dir[File.join(__dir__, 'mapper', '*.rb')].each do |file|
+    HuginnAgent.load file
+end
+
+HuginnAgent.register 'huginn_bigcommerce_product_agent/bigcommerce_product_agent'

data/lib/huginn_bigcommerce_product_agent/bigcommerce_product_agent.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Agents
+    class BigcommerceProductAgent < Agent
+
+        include WebRequestConcern
+
+        can_dry_run!
+        default_schedule 'never'
+
+        description <<-MD
+            Takes a generic product interface && upserts that product in BigCommerce.
+        MD
+
+        def default_options
+            {
+                'store_hash' => '',
+                'client_id' => '',
+                'access_token' => '',
+                'custom_fields_map' => {},
+            }
+        end
+
+        def validate_options
+            unless options['store_hash'].present?
+                errors.add(:base, 'store_hash is a required field')
+            end
+
+            unless options['client_id'].present?
+                errors.add(:base, 'client_id is a required field')
+            end
+
+            unless options['access_token'].present?
+                errors.add(:base, 'access_token is a required field')
+            end
+
+            unless options['custom_fields_map'].is_a?(Hash)
+                errors.add(:base, "if provided, custom_fields_map must be a hash")
+            end
+        end
+
+        def working?
+            received_event_without_error?
+        end
+
+        def check
+            initialize_clients()
+            handle interpolated['payload'].presence || {}
+        end
+
+        def receive(incoming_events)
+            initialize_clients()
+            incoming_events.each do |event|
+                handle(event)
+            end
+       end
+
+        def handle(event)
+            product = event.payload
+
+            skus = ::BigcommerceProductAgent::Mapper::ProductMapper.get_product_skus(product)
+            wrapper_sku = ::BigcommerceProductAgent::Mapper::ProductMapper.get_wrapper_sku(product)
+            all_skus = [].push(*skus).push(wrapper_sku)
+            bc_products = @product.get_by_skus(all_skus)
+
+            # upsert child products
+            bc_children = []
+            custom_fields_delete = []
+            skus.each do |sku|
+                bc_product = bc_products[sku]
+                result = upsert(sku, product, bc_product)
+                custom_fields_delete += result[:custom_fields_delete]
+                bc_children.push(result[:product])
+            end
+
+            # upsert wrapper
+            bc_wrapper_product = bc_products[wrapper_sku]
+            result = upsert(wrapper_sku, product, bc_wrapper_product)
+            custom_fields_delete += result[:custom_fields_delete]
+
+            # update modifier
+            sku_option_map = ::BigcommerceProductAgent::Mapper::ProductMapper.get_sku_option_label_map(product)
+            modifier_updates = ::BigcommerceProductAgent::Mapper::ModifierMapper.map(
+                bc_wrapper_product,
+                bc_children,
+                sku_option_map
+            )
+            @modifier.upsert(result[:product]['id'], modifier_updates[:upsert])
+
+            clean_up_custom_fields(custom_fields_delete)
+            clean_up_modifier_values(modifier_updates[:delete])
+
+            product['modifiers'] = modifier_updates[:upsert]
+            create_event payload: {
+                product: product,
+                parent: result[:product],
+                children: bc_children,
+            }
+        end
+
+        private
+
+        def initialize_clients
+            @product = ::BigcommerceProductAgent::Client::Product.new(
+                interpolated['store_hash'],
+                interpolated['client_id'],
+                interpolated['access_token']
+            )
+
+            @custom_field = ::BigcommerceProductAgent::Client::CustomField.new(
+                interpolated['store_hash'],
+                interpolated['client_id'],
+                interpolated['access_token']
+            )
+
+            @modifier = ::BigcommerceProductAgent::Client::Modifier.new(
+                interpolated['store_hash'],
+                interpolated['client_id'],
+                interpolated['access_token']
+            )
+
+            @modifier_value = ::BigcommerceProductAgent::Client::ModifierValue.new(
+                interpolated['store_hash'],
+                interpolated['client_id'],
+                interpolated['access_token']
+            )
+        end
+
+        def upsert(sku, product, bc_product = nil)
+            custom_fields_updates = ::BigcommerceProductAgent::Mapper::CustomFieldMapper.map(
+                interpolated['custom_fields_map'],
+                product,
+                bc_product
+            )
+
+            product_id = bc_product['id'] unless bc_product.nil?
+            payload = ::BigcommerceProductAgent::Mapper::ProductMapper.payload(
+                sku,
+                product,
+                product_id,
+                { custom_fields: custom_fields_updates[:upsert] }
+            )
+
+            bc_product = @product.upsert(payload)
+
+            return {
+                product: bc_product,
+                custom_fields_delete: custom_fields_updates[:delete],
+            }
+        end
+
+        def clean_up_custom_fields(custom_fields)
+            custom_fields.each do |field|
+                @custom_field.delete(field['product_id'], field['id'])
+            end
+        end
+
+        def clean_up_modifier_values(modifier_values)
+            modifier_values.each do |field|
+                @modifier_value.delete(field[:product_id], field[:modifier_id], field[:value_id])
+            end
+        end
+    end
+end

data/lib/mapper/custom_field_mapper.rb

@@ -0,0 +1,81 @@
+module BigcommerceProductAgent
+    module Mapper
+        class CustomFieldMapper
+
+            def self.map(field_map, product, bc_product)
+                fields = {
+                    upsert: [],
+                    delete: [],
+                }
+
+                existing_fields = {}
+
+                if bc_product
+                    bc_product['custom_fields'].each do |cf|
+                        cf['product_id'] = bc_product['id']
+                        existing_fields[cf['name'].to_s] = cf
+                    end
+                end
+
+                if field_map && field_map['additionalProperty']
+                    field_map['additionalProperty'].each do |key, val|
+                        field = self.from_additional_property(product, existing_fields, key, val)
+                        fields[:upsert].push(field) unless field.nil?
+                    end
+                end
+
+                if field_map
+                    field_map.each do |key, val|
+                        if key == 'additionalProperty'
+                            next
+                        end
+
+                        field = self.from_property(product, existing_fields, key, val)
+                        fields[:upsert].push(field) unless field.nil?
+                    end
+                end
+
+                # return values that need deleted
+                fields[:delete] = existing_fields.values
+                return fields
+            end
+
+            private
+
+            def self.from_property(product, existing_fields, from_key, to_key)
+                if !product[from_key].nil?
+                    field = {
+                        name: to_key,
+                        value: product[from_key]
+                    }
+
+                    if existing_fields[to_key]
+                        field[:id] = existing_fields[to_key]['id']
+                        existing_fields.delete(to_key)
+                    end
+
+                    return field
+                end
+            end
+
+            def self.from_additional_property(product, existing_fields, from_key, to_key)
+                # date published
+                item = product['additionalProperty'].select {|p| p['propertyID'] == from_key}.first
+                if !item.nil?
+                    field = {
+                        name: to_key,
+                        value: item['value']
+                    }
+
+                    if existing_fields[to_key]
+                        field[:id] = existing_fields[to_key]['id']
+                        existing_fields.delete(to_key)
+                    end
+
+                    return field
+                end
+            end
+
+        end
+    end
+end

data/lib/mapper/modifier_mapper.rb

@@ -0,0 +1,83 @@
+module BigcommerceProductAgent
+    module Mapper
+        class ModifierMapper
+
+            def self.map(bc_product, bc_children, sku_option_map)
+                modifier = {
+                    display_name: 'Option',
+                    type: 'product_list',
+                    required: true,
+                    sort_order: 1,
+                    config: {
+                        product_list_adjusts_inventory: true,
+                        product_list_adjusts_pricing: true,
+                        product_list_shipping_calc: 'none'
+                    },
+                    option_values: []
+                }
+
+                existing_modifier = nil
+                existing_option_ids = []
+                if bc_product && !bc_product['modifiers'].nil?
+                    existing_modifier = bc_product['modifiers'].select {|m| m['display_name'] == modifier[:display_name]}.first
+                    modifier[:product_id] = bc_product['id']
+
+                    if !existing_modifier.nil?
+                        modifier[:id] = existing_modifier['id']
+                        existing_option_ids = existing_modifier['option_values'].map {|value| value['id']}
+                    end
+                end
+
+                bc_children.each do |child|
+                    existing_option = nil
+                    if existing_modifier
+                        existing_option = existing_modifier['option_values'].select do |val|
+                            val['value_data'] && val['value_data']['product_id'] == child['id']
+                        end.first
+                    end
+
+                    option = {
+                        label: sku_option_map[child['sku']],
+                        sort_order: 0,
+                        value_data: {
+                            product_id: child['id']
+                        },
+                        is_default: false,
+                        adjusters: {
+                            price: nil,
+                            weight: nil,
+                            image_url: '',
+                            purchasing_disabled: {
+                                status: false,
+                                message: ''
+                            }
+                        }
+                    }
+
+                    if existing_option
+                        option[:id] = existing_option['id']
+                        option[:option_id] = existing_option['option_id']
+                        existing_option_ids.delete(existing_option['id'])
+                    end
+
+                    modifier[:option_values].push(option)
+                end
+
+                # any left over option value should be removed
+                modifier_values_delete = existing_option_ids.map do |id|
+                    {
+                        product_id: bc_product['id'],
+                        modifier_id: existing_modifier['id'],
+                        value_id: id
+                    }
+                end
+
+                return {
+                    upsert: modifier,
+                    delete: modifier_values_delete
+                }
+            end
+
+        end
+    end
+end

data/lib/mapper/product_mapper.rb

@@ -0,0 +1,114 @@
+module BigcommerceProductAgent
+    module Mapper
+        class ProductMapper
+
+            def self.map(product, variant, additional_data = {})
+                product = {
+                    name: variant.nil? ? product['name'] : "#{product['name']} (#{self.get_option(variant)})",
+                    sku: variant ? variant['sku'] : self.get_wrapper_sku(product),
+                    type: variant && variant['isDigital'] == true ? 'digital' : 'physical',
+                    description: product['description'],
+                    price: variant && variant['offers'] && variant['offers'][0] ? variant['offers'][0]['price'] : '0',
+                    categories: self.get_categories(product),
+                    available: 'available',
+                    weight: variant && variant['weight'] ? variant['weight']['value'] : '0',
+                    width: variant && variant['width'] ? variant['width']['value'] : '0',
+                    depth: variant && variant['depth'] ? variant['depth']['value'] : '0',
+                    height: variant && variant['height'] ? variant['height']['value'] : '0',
+                    meta_keywords: self.meta_keywords(product),
+                    meta_description: self.meta_description(product),
+                    search_keywords: self.meta_keywords(product).join(','),
+                    is_visible: variant.nil? ? true : false,
+                }.merge(additional_data)
+
+
+                upc = variant ? variant['gtin12'] : product['gtin12']
+
+                if upc
+                    product[:upc] = upc
+                end
+
+                return product
+            end
+
+            def self.get_wrapper_sku(product)
+                "#{product['sku']}-W"
+            end
+
+            def self.payload(sku, product, product_id = nil, additional_data = {})
+                variant = self.get_variant_by_sku(sku, product)
+                payload = self.map(product, variant, additional_data)
+                payload['id'] = product_id unless product_id.nil?
+
+                return payload
+            end
+
+            def self.get_product_skus(product)
+                product['model'].map { |model| model['sku'] }
+            end
+
+            def self.get_sku_option_label_map(product)
+                map = {}
+
+                product['model'].each do |model|
+                    map[model['sku']] = self.get_option(model)
+                end
+
+                return map
+            end
+
+            private
+
+            def self.get_categories(product)
+                categories = []
+
+                if product['categories']
+                    categories = product['categories'].map do |category|
+                        category['identifier'].to_i
+                    end
+                end
+
+                return categories
+            end
+
+            def self.get_option(variant)
+                if variant['encodingFormat']
+                    return variant['encodingFormat']
+                elsif variant['bookFormat']
+                    parts = variant['bookFormat'].split('/')
+                    return parts[parts.length - 1]
+                else
+                    return self.get_additional_property_value(variant, 'option')
+                end
+            end
+
+            def self.meta_description(product)
+                return self.get_additional_property_value(product, 'meta_description', '')
+            end
+
+            def self.meta_keywords(product)
+                meta_keywords = []
+
+                product['keywords'].split(',') unless product['keywords'].nil?
+
+                return meta_keywords
+            end
+
+            def self.get_additional_property_value(product, name, default = nil)
+                value = default
+
+                return value if product['additionalProperty'].nil?
+
+                idx = product['additionalProperty'].index {|item| item['propertyID'] == name}
+                value = product['additionalProperty'][idx]['value'] unless idx.nil?
+
+                return value
+            end
+
+            def self.get_variant_by_sku(sku, product)
+                product['model'].select {|m| m['sku'] == sku}.first
+            end
+
+        end
+    end
+end

data/spec/bigcommerce_product_agent_spec.rb

@@ -0,0 +1,13 @@
+# require 'rails_helper'
+# require 'huginn_agent/spec_helper'
+#
+# describe Agents::BigcommerceProductAgent do
+#   before(:each) do
+#     @valid_options = Agents::BigcommerceProductAgent.new.default_options
+#     @checker = Agents::BigcommerceProductAgent.new(:name => "BigcommerceProductAgent", :options => @valid_options)
+#     @checker.user = users(:bob)
+#     @checker.save!
+#   end
+#
+#   pending "add specs here"
+# end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: huginn_bigcommerce_product_agent
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+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: Agent that takes a generic product interface and upserts that product
+  in BigCommerce.
+email:
+- jspizziri@weare5stones.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/abstract_client.rb
+- lib/client/custom_field.rb
+- lib/client/modifier.rb
+- lib/client/modifier_value.rb
+- lib/client/product.rb
+- lib/huginn_bigcommerce_product_agent.rb
+- lib/huginn_bigcommerce_product_agent/bigcommerce_product_agent.rb
+- lib/mapper/custom_field_mapper.rb
+- lib/mapper/modifier_mapper.rb
+- lib/mapper/product_mapper.rb
+- spec/bigcommerce_product_agent_spec.rb
+homepage: https://github.com/5-stones/huginn_bigcommerce_product_agent
+licenses: []
+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: Agent that takes a generic product interface and upserts that product in
+  BigCommerce.
+test_files:
+- spec/bigcommerce_product_agent_spec.rb