huginn_bigcommerce_product_agent 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adaa89e639b5ab86d9a6d5a7115d600ced404287d7423a6bd916be655812f0e0
-  data.tar.gz: 33ccd02f821ec39473b22c459902e5f8f95d0f43abbf384187a621a1e2a9444d
+  metadata.gz: 0a16c935c5f0593bfe513a750ce449cfa38c408cdae2d1d232a1952e910e0e61
+  data.tar.gz: 198cf4537a7751e48ea4563eee131328c1c6e9815e38f0e0e5d5f710b170ab41
 SHA512:
-  metadata.gz: 473d32273d6e23e5e1fdce6ae6f1cfe423d8d57261c1b6db18493f8b8a914ee687737f290be2632691b2cc2edd3d0a1639cdf2b0a2144cd9fd7361c9610d2baf
-  data.tar.gz: 95c85baae2de9bc618f1e4c39539e2cc1dd33830b5c6306fa5f6c6439e5228e7f76bb4d1ed77cf69e05349ec08f351347979c99303289a61db1ecd517ebc7801
+  metadata.gz: 7b49211e58db9b4c6a84c6ca45009ca08101d9a0fe2163c2b9dbbbf9c91257aa99029e3b4c4dd518d5ce87fe40a03987481d7255339d24b750de1eb0c7e45b62
+  data.tar.gz: 811685124d0e2b4068a8897d24e6130ae2982efb37675f0e3a7c3b4aff6234dc5d839dd5a5afb54edeacb88557716a6d10061f6ec14f9bb0db253906ae2cd3b0

data/lib/abstract_client.rb

@@ -72,9 +72,18 @@ module BigcommerceProductAgent
                 raise "not implemented yet."
             end
 
+            def delete(payload)
+                raise "not implemented yet."
+            end
+
             def upsert(payload)
                 raise "not implemented yet."
             end
+
+            def get(url_params = {}, params = {})
+                response = client.get(uri(url_params), params)
+                return response.body['data']
+            end
         end
     end
 end

data/lib/client/custom_field.rb

@@ -3,9 +3,34 @@ module BigcommerceProductAgent
         class CustomField < AbstractClient
             @uri_base = 'catalog/products/:product_id/custom-fields/:custom_field_id'
 
+            def create(product_id, payload)
+                response = client.post(uri(product_id: product_id), payload.to_json)
+                return response.body['data']
+            end
+
+            def update(product_id, payload)
+                id = payload.delete('id')
+                response = client.put(uri(product_id: product_id, custom_field_id: id), payload.to_json)
+                return response.body['data']
+            end
+
             def delete(product_id, custom_field_id)
                 client.delete(uri(product_id: product_id, custom_field_id: custom_field_id))
             end
+
+            def upsert(product_id, payload)
+                begin
+                    payload['id'] = payload.delete(:id) unless payload[:id].nil?
+                    if payload['id']
+                        return update(product_id, payload)
+                    else
+                        return create(product_id, payload)
+                    end
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
         end
     end
 end

data/lib/client/product.rb

@@ -3,22 +3,33 @@ module BigcommerceProductAgent
         class Product < AbstractClient
             @uri_base = 'catalog/products/:product_id'
 
-            def update(id, payload)
-                response = client.put(uri(product_id: id), payload.to_json)
+            def update(id, payload, params={})
+                response = client.put(uri(product_id: id), payload.to_json) do |request|
+                    request.params.update(params) if params
+                end
+
                 return response.body['data']
             end
 
-            def create(payload)
-                response = client.post(uri, payload.to_json)
+            def delete(id)
+                response = client.delete(uri(product_id: id))
+                return true
+            end
+
+            def create(payload, params={})
+                response = client.post(uri, payload.to_json) do |request|
+                    request.params.update(params) if params
+                end
+
                 return response.body['data']
             end
 
-            def upsert(payload)
+            def upsert(payload, params={})
                 begin
                     if payload['id']
-                        return update(payload['id'], payload)
+                        return update(payload['id'], payload, params)
                     else
-                        return create(payload)
+                        return create(payload, params)
                     end
                 rescue Faraday::Error::ClientError => e
                     puts e.inspect

data/lib/client/product_option.rb

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

data/lib/client/product_option_value.rb

@@ -0,0 +1,72 @@
+module BigcommerceProductAgent
+    module Client
+        class ProductOptionValue < AbstractClient
+            @uri_base = 'catalog/products/:product_id/options/:option_id/values/:value_id'
+
+            def delete(product_id, option_id, value_id)
+                client.delete(uri(product_id: product_id, option_id: option_id, value_id: value_id))
+            end
+
+            def delete_all(option, option_values)
+                option_values.each do |option_value|
+                    delete(option['product_id'], option['id'], option_value['id'])
+                end
+            end
+
+            def upsert(option, option_value)
+                begin
+                    if option[:product_id] || option['product_id']
+                        option['product_id'] = option[:product_id] unless option[:product_id].nil?
+                    end
+
+                    if option[:id] || option['id']
+                        option['id'] = option[:id] unless option[:id].nil?
+                    end
+
+                    if option_value[:id] || option_value['id']
+                        option_value['id'] = option_value[:id] unless option_value[:id].nil?
+                        return update(option, option_value)
+                    else
+                        return create(option, option_value)
+                    end
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
+
+            def upsert_all(option, option_values)
+                results = []
+                option_values.each do |option_value|
+                    result = upsert(option, option_value)
+                    results.push(result)
+                end
+
+                return results
+            end
+
+            def update(option, option_value)
+                response = client.put(
+                    uri(
+                        product_id: option['product_id'],
+                        option_id: option['id'],
+                        value_id: option_value['id'],
+                    ),
+                    option_value.to_json,
+                )
+                return response.body['data']
+            end
+
+            def create(option, option_value)
+                response = client.post(
+                    uri(
+                        product_id: option['product_id'],
+                        option_id: option['id'],
+                    ),
+                    option_value.to_json,
+                )
+                return response.body['data']
+            end
+        end
+    end
+end

data/lib/client/product_variant.rb

@@ -0,0 +1,40 @@
+module BigcommerceProductAgent
+    module Client
+        class ProductVariant < AbstractClient
+            @uri_base = 'catalog/products/:product_id/variants/:variant_id'
+
+            def index(product_id, params = {})
+                response = client.get(uri(product_id: product_id), params)
+                return response.body['data']
+            end
+
+            def delete(product_id, variant_id)
+                client.delete(uri(product_id: product_id, variant_id: variant_id))
+            end
+
+            def upsert(product_id, variant)
+                begin
+                    if variant[:id] || variant['id']
+                        variant['id'] = variant[:id] unless variant[:id].nil?
+                        return update(product_id, variant)
+                    else
+                        return create(product_id, variant)
+                    end
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
+
+            def update(product_id, variant)
+                response = client.put(uri(product_id: product_id, variant_id: variant['id']), variant.to_json)
+                return response.body['data']
+            end
+
+            def create(product_id, variant)
+                response = client.post(uri(product_id: product_id), variant.to_json)
+                return response.body['data']
+            end
+        end
+    end
+end

data/lib/client/variant.rb

@@ -0,0 +1,41 @@
+module BigcommerceProductAgent
+    module Client
+        class Variant < AbstractClient
+            @uri_base = 'catalog/variants'
+
+            def update(payload)
+                raise "this endpoint only has upsert available"
+            end
+
+            def create(payload)
+                raise "this endpoint only has upsert available"
+            end
+
+            def upsert(payload)
+                begin
+                    response = client.put(uri, payload.to_json)
+                    return response.body['data']
+                rescue Faraday::Error::ClientError => e
+                    puts e.inspect
+                    raise e
+                end
+            end
+
+            def get_by_skus(skus, include = %w[custom_fields modifiers])
+                variants = index({
+                    'sku:in': skus.join(','),
+                    include: include.join(','),
+                })
+
+                map = {}
+
+                variants.each do |variant|
+                    map[variant['sku']] = variant
+                end
+
+                map
+            end
+
+        end
+    end
+end

data/lib/huginn_bigcommerce_product_agent/bigcommerce_product_agent.rb

@@ -4,7 +4,6 @@ require 'json'
 
 module Agents
     class BigcommerceProductAgent < Agent
-
         include WebRequestConcern
 
         can_dry_run!
@@ -14,6 +13,13 @@ module Agents
             Takes a generic product interface && upserts that product in BigCommerce.
         MD
 
+        def modes
+            %w[
+                variants
+                option_list
+            ]
+        end
+
         def default_options
             {
                 'store_hash' => '',
@@ -22,6 +28,7 @@ module Agents
                 'custom_fields_map' => {},
                 'meta_fields_map' => {},
                 'meta_fields_namespace' => '',
+                'mode' => modes[0]
             }
         end
 
@@ -39,15 +46,21 @@ module Agents
             end
 
             unless options['custom_fields_map'].is_a?(Hash)
-                errors.add(:base, "if provided, custom_fields_map must be a hash")
+                errors.add(:base, 'if provided, custom_fields_map must be a hash')
             end
 
             unless options['meta_fields_map'].is_a?(Hash)
-                errors.add(:base, "if provided, meta_fields_map must be a hash")
+                errors.add(:base, 'if provided, meta_fields_map must be a hash')
             end
 
             if options['meta_fields_map']
-                errors.add(:base, "if meta_fields_map is provided, meta_fields_namespace is required") if options['meta_fields_namespace'].blank?
+                if options['meta_fields_namespace'].blank?
+                    errors.add(:base, 'if meta_fields_map is provided, meta_fields_namespace is required')
+                end
+            end
+
+            unless options['mode'].present? && modes.include?(options['mode'])
+                errors.add(:base, "mode is a required field and must be one of: #{modes.join(', ')}")
             end
         end
 
@@ -56,22 +69,184 @@ module Agents
         end
 
         def check
-            initialize_clients()
+            initialize_clients
             handle interpolated['payload'].presence || {}
         end
 
         def receive(incoming_events)
-            initialize_clients()
+            initialize_clients
             incoming_events.each do |event|
                 handle(event)
             end
-       end
+        end
 
         def handle(event)
+            method_name = "handle_#{interpolated['mode']}"
+            if self.respond_to?(method_name, true)
+                self.public_send(method_name, event)
+            else
+                raise "'#{interpolated['mode']}' is not a supported mode"
+            end
+        end
+
+        # 1. upsert product
+        # 2. upsert option & option_values
+        # 3. delete old option_values
+        #     - NOTE: deleting an option_value also deletes the variant
+        #       associated with the option_value
+        # 4. upsert variants
+        #     - NOTE: because deleting option values deletes variants
+        #       we need to fetch the variants AFTER deletion has occurred.
+        #     - NOTE: by deleting variants in #3 if option_values on an
+        #       existing variant changes over time, we're effectively deleting
+        #       and then re-adding the variant. Could get weird.
+        def handle_variants(event)
+            product = event.payload
+
+            wrapper_skus = {
+                physical: get_mapper(:ProductMapper).get_wrapper_sku_physical(product),
+                digital: get_mapper(:ProductMapper).get_wrapper_sku_digital(product),
+            }
+            bc_products = @product.get_by_skus(
+                wrapper_skus.map {|k,v| v},
+                %w[custom_fields options]
+            )
+
+            split = get_mapper(:ProductMapper).split_digital_and_physical(product)
+            physical = split[:physical]
+            digital = split[:digital]
+
+            # upsert wrapper products
+            split.each do |type, product|
+                is_digital = type == :digital ? true : false
+
+                # modify digital
+                if is_digital
+                    product['name'] = "#{product['name']} (Digital)"
+                end
+
+                wrapper_sku = wrapper_skus[type]
+                bc_product = bc_products[wrapper_sku]
+                variant_option_name = get_mapper(:OptionMapper).variant_option_name
+                bc_option = !bc_product.nil? ? bc_product['options'].select {|opt| opt['display_name'] === variant_option_name}.first : nil
+
+                # ##############################
+                # 1. update wrapper product
+                # ##############################
+                upsert_result = upsert_product(wrapper_sku, product, bc_product, is_digital)
+                bc_product = upsert_result[:product]
+                bc_products[wrapper_sku] = bc_product
+                product_id = bc_products[wrapper_sku]['id']
+
+                # clean up custom/meta fields. there are not batch operations so we might as well do them here.
+                custom_fields_delete = upsert_result[:custom_fields_delete].select {|field| field['name'] != 'related_product_id'}
+                clean_up_custom_fields(custom_fields_delete)
+                update_meta_fields(
+                    upsert_result[:meta_fields_upsert],
+                    upsert_result[:meta_fields_delete],
+                )
+
+                # ##############################
+                # 2. upsert option & option_values
+                # ##############################
+                option_values_map = get_mapper(:ProductMapper).get_sku_option_label_map(product)
+                option_values = option_values_map.map {|k,v| v}
+                option_value_operations = get_mapper(:OptionMapper).option_value_operations(bc_option, option_values)
+                option = get_mapper(:OptionMapper).map(product_id, bc_option, option_value_operations[:create])
+                bc_option = @product_option.upsert(product_id, option)
+
+                # ##############################
+                # 3. delete old option_values
+                # ##############################
+                @product_option_value.delete_all(bc_option, option_value_operations[:delete])
+
+                # ##############################
+                # 4. upsert variants
+                # ##############################
+                variant_skus = get_mapper(:ProductMapper).get_product_skus(product)
+                bc_variants = @product_variant.index(product_id)
+                mapped_variants = product['model'].map do |variant|
+                    bc_variant = bc_variants.select {|v| v['sku'] === variant['sku']}.first
+                    opt = get_mapper(:ProductMapper).get_option(variant)
+                    bc_option_value = bc_option['option_values'].select {|ov| ov['label'] == opt}.first
+
+                    option_value = get_mapper(:VariantMapper).map_option_value(bc_option_value['id'], bc_option['id'])
+
+                    get_mapper(:VariantMapper).map(
+                        variant,
+                        [option_value],
+                        product_id,
+                        bc_variant.nil? ? nil : bc_variant['id'],
+                    )
+                end
+
+                bc_product['variants'] = @variant.upsert(mapped_variants)
+            end
+
+            bc_physical = bc_products[wrapper_skus[:physical]]
+            bc_digital = bc_products[wrapper_skus[:digital]]
+            is_delete_physical = split[:physical].nil? && bc_physical
+            is_delete_digital = split[:digital].nil? && bc_digital
+
+            # ##############################
+            # clean up products that no longer exist
+            # ##############################
+            if is_delete_physical
+                bc_product = bc_products[wrapper_skus[:physical]]
+                @product.delete(bc_product['id'])
+                bc_physical = false
+                bc_product.delete(wrapper_skus[:physical])
+            end
+
+            if is_delete_digital
+                bc_product = bc_products[wrapper_skus[:digital]]
+                @product.delete(bc_product['id'])
+                bc_digital = false
+                bc_product.delete(wrapper_skus[:digital])
+            end
+
+            # ##############################
+            # clean up custom field relationships
+            # ##############################
+            if bc_physical && !bc_digital
+                # clean up related_product_id on physical product
+                bc_product = bc_physical
+                related_custom_field = bc_product['custom_fields'].select {|field| field['name'] == 'related_product_id'}.first
+                @custom_field.delete(bc_product['id'], related_custom_field['id']) unless related_custom_field.nil?
+            elsif !bc_physical && bc_digital
+                # clean up related_product_id on digital product
+                bc_product = bc_digital
+                related_custom_field = bc_product['custom_fields'].select {|field| field['name'] == 'related_product_id'}.first
+                @custom_field.delete(bc_product['id'], related_custom_field['id']) unless related_custom_field.nil?
+            elsif bc_physical && bc_digital
+                # update/add related_product_id on both products
+                bc_physical_related = get_mapper(:CustomFieldMapper).map_one(bc_physical, 'related_product_id', bc_digital['id'])
+                bc_digital_related = get_mapper(:CustomFieldMapper).map_one(bc_digital, 'related_product_id', bc_physical['id'])
+                @custom_field.upsert(bc_physical['id'], bc_physical_related)
+                @custom_field.upsert(bc_digital['id'], bc_digital_related)
+            end
+
+            # ##############################
+            # emit events
+            # ##############################
+            if bc_physical
+                create_event payload: {
+                    product: bc_physical
+                }
+            end
+
+            if bc_digital
+                create_event payload: {
+                    product: bc_digital
+                }
+            end
+        end
+
+        def handle_option_list(event)
             product = event.payload
 
-            skus = ::BigcommerceProductAgent::Mapper::ProductMapper.get_product_skus(product)
-            wrapper_sku = ::BigcommerceProductAgent::Mapper::ProductMapper.get_wrapper_sku(product)
+            skus = get_mapper(:ProductMapper).get_product_skus(product)
+            wrapper_sku = get_mapper(:ProductMapper).get_wrapper_sku(product)
             all_skus = [].push(*skus).push(wrapper_sku)
             bc_products = @product.get_by_skus(all_skus)
 
@@ -83,7 +258,7 @@ module Agents
 
             skus.each do |sku|
                 bc_product = bc_products[sku]
-                result = upsert(sku, product, bc_product)
+                result = upsert_product(sku, product, bc_product)
                 custom_fields_delete += result[:custom_fields_delete]
                 meta_fields_upsert += result[:meta_fields_upsert]
                 meta_fields_delete += result[:meta_fields_delete]
@@ -92,16 +267,16 @@ module Agents
 
             # upsert wrapper
             bc_wrapper_product = bc_products[wrapper_sku]
-            result = upsert(wrapper_sku, product, bc_wrapper_product)
+            result = upsert_product(wrapper_sku, product, bc_wrapper_product)
             custom_fields_delete += result[:custom_fields_delete]
             meta_fields_upsert += result[:meta_fields_upsert]
             meta_fields_delete += result[:meta_fields_delete]
 
-            is_default_map = ::BigcommerceProductAgent::Mapper::ProductMapper.get_is_default(product)
+            is_default_map = get_mapper(:ProductMapper).get_is_default(product)
 
             # update modifier
-            sku_option_map = ::BigcommerceProductAgent::Mapper::ProductMapper.get_sku_option_label_map(product)
-            modifier_updates = ::BigcommerceProductAgent::Mapper::ModifierMapper.map(
+            sku_option_map = get_mapper(:ProductMapper).get_sku_option_label_map(product)
+            modifier_updates = get_mapper(:ModifierMapper).map(
                 bc_wrapper_product,
                 bc_children,
                 sku_option_map,
@@ -118,46 +293,39 @@ module Agents
             create_event payload: {
                 product: product,
                 parent: result[:product],
-                children: bc_children,
+                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']
-            )
-
-            @meta_field = ::BigcommerceProductAgent::Client::MetaField.new(
-                interpolated['store_hash'],
-                interpolated['client_id'],
-                interpolated['access_token']
-            )
+            @variant = initialize_client(:Variant)
+            @product_variant = initialize_client(:ProductVariant)
+            @product_option = initialize_client(:ProductOption)
+            @product_option_value = initialize_client(:ProductOptionValue)
+            @product = initialize_client(:Product)
+            @custom_field = initialize_client(:CustomField)
+            @meta_field = initialize_client(:MetaField)
+            @modifier = initialize_client(:Modifier)
+            @modifier_value = initialize_client(:ModifierValue)
+        end
 
-            @modifier = ::BigcommerceProductAgent::Client::Modifier.new(
+        def initialize_client(class_name)
+            klass = ::BigcommerceProductAgent::Client.const_get(class_name.to_sym)
+            return klass.new(
                 interpolated['store_hash'],
                 interpolated['client_id'],
                 interpolated['access_token']
             )
+        end
 
-            @modifier_value = ::BigcommerceProductAgent::Client::ModifierValue.new(
-                interpolated['store_hash'],
-                interpolated['client_id'],
-                interpolated['access_token']
-            )
+        def get_mapper(class_name)
+            return ::BigcommerceProductAgent::Mapper.const_get(class_name.to_sym)
         end
 
-        def upsert(sku, product, bc_product = nil)
-            custom_fields_updates = ::BigcommerceProductAgent::Mapper::CustomFieldMapper.map(
+        def upsert_product(sku, product, bc_product = nil, is_digital=false)
+            custom_fields_updates = get_mapper(:CustomFieldMapper).map(
                 interpolated['custom_fields_map'],
                 product,
                 bc_product
@@ -165,18 +333,21 @@ module Agents
 
             product_id = bc_product['id'] unless bc_product.nil?
 
-            payload = ::BigcommerceProductAgent::Mapper::ProductMapper.payload(
+            payload = get_mapper(:ProductMapper).payload(
                 sku,
                 product,
                 product_id,
-                { custom_fields: custom_fields_updates[:upsert] }
+                { custom_fields: custom_fields_updates[:upsert] },
+                is_digital,
             )
 
-            bc_product = @product.upsert(payload)
+            bc_product = @product.upsert(payload, {
+                include: %w[custom_fields variants options].join(',')
+            })
 
             # Metafields need to be managed separately. Intentionally get them _AFTER_
             # the upsert so that we have the necessary resource_id (bc_product.id)
-            meta_fields_updates = ::BigcommerceProductAgent::Mapper::MetaFieldMapper.map(
+            meta_fields_updates = get_mapper(:MetaFieldMapper).map(
                 interpolated['meta_fields_map'],
                 product,
                 bc_product,
@@ -184,11 +355,11 @@ module Agents
                 interpolated['meta_fields_namespace']
             )
 
-            return {
+            {
                 product: bc_product,
                 custom_fields_delete: custom_fields_updates[:delete],
                 meta_fields_upsert: meta_fields_updates[:upsert],
-                meta_fields_delete: meta_fields_updates[:delete],
+                meta_fields_delete: meta_fields_updates[:delete]
             }
         end
 
@@ -215,7 +386,7 @@ module Agents
                 @meta_field.delete(field[:resource_id], field[:id])
             end
 
-            return meta_fields
+            meta_fields
         end
     end
 end

data/lib/mapper/custom_field_mapper.rb

@@ -40,13 +40,28 @@ module BigcommerceProductAgent
                 return fields
             end
 
+            def self.map_one(bc_product, key, value)
+                field = bc_product['custom_fields'].select {|field| key == 'related_product_id'}.first
+
+                mapped = {
+                    name: key,
+                    value: value.to_s,
+                }
+
+                if field
+                    mapped[:id] = field['id']
+                end
+
+                return mapped
+            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]
+                        value: product[from_key].to_s
                     }
 
                     if existing_fields[to_key]
@@ -64,7 +79,7 @@ module BigcommerceProductAgent
                 if !item.nil?
                     field = {
                         name: to_key,
-                        value: item['value']
+                        value: item['value'].to_s
                     }
 
                     if existing_fields[to_key]

data/lib/mapper/option_mapper.rb

@@ -0,0 +1,65 @@
+module BigcommerceProductAgent
+    module Mapper
+        class OptionMapper
+
+            def self.variant_option_name
+                'Options'
+            end
+
+            def self.map(product_id, option, option_values)
+                mapped = {
+                    product_id: product_id,
+                    display_name: self.variant_option_name,
+                    type: 'radio_buttons',
+                    sort_order: 0,
+                    option_values: option_values,
+                }
+
+                if option && option['id']
+                    mapped[:id] = option['id']
+                end
+
+                return mapped
+            end
+
+            def self.option_value_operations(bc_option, option_values)
+                option_value_operations = {
+                    create: [],
+                    update: [],
+                    delete: [],
+                }
+
+                if bc_option && bc_option['option_values']
+                    bc_option['option_values'].each do |option_value|
+                        if option_values.include?(option_value['label'])
+                            option_value_operations[:update].push(option_value)
+                        else
+                            option_value_operations[:delete].push(option_value)
+                        end
+                    end
+
+                    option_values.each do |option_value_label|
+                        options_exists = bc_option['option_values'].any? {|option_value| option_value['label'] == option_value_label}
+                        if !options_exists
+                            option_value_operations[:create].push(
+                                OptionValueMapper.map(option_value_label)
+                            )
+                        end
+                    end
+                else
+                    option_values.each do |option_value_label|
+                        option_value_operations[:create].push(
+                            OptionValueMapper.map(option_value_label)
+                        )
+                    end
+                end
+
+                return option_value_operations
+            end
+
+            private
+
+
+        end
+    end
+end

data/lib/mapper/option_value_mapper.rb

@@ -0,0 +1,16 @@
+module BigcommerceProductAgent
+    module Mapper
+        class OptionValueMapper
+
+            def self.map(label)
+                {
+                    label: label,
+                    sort_order: 0,
+                }
+            end
+
+            private
+
+        end
+    end
+end

data/lib/mapper/product_mapper.rb

@@ -2,12 +2,12 @@ module BigcommerceProductAgent
     module Mapper
         class ProductMapper
 
-            def self.map(product, variant, additional_data = {})
+            def self.map(product, variant, additional_data = {}, is_digital = false, default_sku='')
                 product = {
                     name: variant.nil? ? product['name'] : "#{product['name']} (#{self.get_option(variant)})",
-                    sku: variant ? variant['sku'] : self.get_wrapper_sku(product),
+                    sku: variant ? variant['sku'] : default_sku,
                     is_default: variant && variant['isDefault'],
-                    type: variant && variant['isDigital'] == true ? 'digital' : 'physical',
+                    type: (variant && variant['isDigital'] == true) || is_digital ? 'digital' : 'physical',
                     description: product['description'],
                     price: variant && variant['offers'] && variant['offers'][0] ? variant['offers'][0]['price'] : '0',
                     categories: self.get_categories(product),
@@ -36,9 +36,17 @@ module BigcommerceProductAgent
                 "#{product['sku']}-W"
             end
 
-            def self.payload(sku, product, product_id = nil, additional_data = {})
+            def self.get_wrapper_sku_physical(product)
+                self.get_wrapper_sku(product)
+            end
+
+            def self.get_wrapper_sku_digital(product)
+                "#{self.get_wrapper_sku_physical(product)}-DIGITAL"
+            end
+
+            def self.payload(sku, product, product_id = nil, additional_data = {}, is_digital = false)
                 variant = self.get_variant_by_sku(sku, product)
-                payload = self.map(product, variant, additional_data)
+                payload = self.map(product, variant, additional_data, is_digital, sku)
                 payload['id'] = product_id unless product_id.nil?
 
                 return payload
@@ -68,6 +76,36 @@ module BigcommerceProductAgent
               return map
             end
 
+            def self.has_digital_variants?(product)
+                product['model'].any? {|m| m['isDigital'] == true}
+            end
+
+            def self.has_physical_variants?(product)
+                product['model'].any? {|m| m['isDigital'] != true}
+            end
+
+            def self.split_digital_and_physical(product)
+                result = {}
+
+                digitals = product['model'].select {|m| m['isDigital'] == true}
+
+                if digitals.length > 0
+                    clone = Marshal.load(Marshal.dump(product))
+                    clone['model'] = digitals
+                    result[:digital] = clone
+                end
+
+                physicals = product['model'].select {|m| m['isDigital'] != true}
+
+                if physicals.length > 0
+                    clone = Marshal.load(Marshal.dump(product))
+                    clone['model'] = physicals
+                    result[:physical] = clone
+                end
+
+                return result
+            end
+
             private
 
             def self.get_categories(product)

data/lib/mapper/variant_mapper.rb

@@ -0,0 +1,47 @@
+module BigcommerceProductAgent
+    module Mapper
+        class VariantMapper
+
+            def self.map(variant, option_values, product_id, variant_id=nil)
+                mapped = {
+                    product_id: product_id,
+                    sku: variant['sku'],
+                    price: variant['offers'] && variant['offers'][0] ? variant['offers'][0]['price'] : '0',
+                    cost_price: nil,
+                    sale_price: nil,
+                    retail_price: nil,
+                    weight: variant['weight'] ? variant['weight']['value'] : '0',
+                    width: variant['width'] ? variant['width']['value'] : '0',
+                    depth: variant['depth'] ? variant['depth']['value'] : '0',
+                    height: variant['height'] ? variant['height']['value'] : '0',
+                    is_free_shipping: false,
+                    fixed_cost_shipping_price: nil,
+                    purchasing_disabled: false,
+                    purchasing_disabled_message: '',
+                    upc: variant['gtin12'],
+                    inventory_level: nil,
+                    inventory_warning_level: nil,
+                    bin_picking_number: nil,
+                    option_values: option_values,
+                }
+
+                if variant_id
+                    mapped[:id] = variant_id
+                end
+
+                return mapped
+            end
+
+            def self.map_option_value(option_value_id, option_id)
+                return {
+                    id: option_value_id,
+                    option_id: option_id,
+                }
+            end
+
+            private
+
+
+        end
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: huginn_bigcommerce_product_agent
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jacob Spizziri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2020-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,12 +66,19 @@ files:
 - lib/client/modifier.rb
 - lib/client/modifier_value.rb
 - lib/client/product.rb
+- lib/client/product_option.rb
+- lib/client/product_option_value.rb
+- lib/client/product_variant.rb
+- lib/client/variant.rb
 - lib/huginn_bigcommerce_product_agent.rb
 - lib/huginn_bigcommerce_product_agent/bigcommerce_product_agent.rb
 - lib/mapper/custom_field_mapper.rb
 - lib/mapper/meta_field_mapper.rb
 - lib/mapper/modifier_mapper.rb
+- lib/mapper/option_mapper.rb
+- lib/mapper/option_value_mapper.rb
 - lib/mapper/product_mapper.rb
+- lib/mapper/variant_mapper.rb
 - spec/bigcommerce_product_agent_spec.rb
 homepage: https://github.com/5-stones/huginn_bigcommerce_product_agent
 licenses: []