huginn_bigcommerce_product_agent 1.10.1

data/lib/mapper/custom_field_mapper.rb

@@ -0,0 +1,96 @@
+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
+
+            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].to_s
+                    }
+
+                    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'].to_s
+                    }
+
+                    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/meta_field_mapper.rb

@@ -0,0 +1,100 @@
+module BigcommerceProductAgent
+    module Mapper
+        class MetaFieldMapper
+
+            def self.map(field_map, product, bc_product, meta_fields, namespace)
+                fields = {
+                    upsert: [],
+                    delete: [],
+                }
+
+                existing_fields = {}
+
+                if bc_product
+                    meta_fields.each do |mf|
+
+                        unless mf['namespace'] != namespace
+                          # Only delete meta fields managed by this sync
+                          existing_fields[mf['key'].to_s] = mf
+                        end
+                    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, namespace, bc_product)
+                        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, namespace, bc_product)
+                        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, namespace, bc_product)
+
+                if !product[from_key].nil?
+                    field = {
+                        namespace: namespace,
+                        permission_set: 'write',
+                        resource_type: 'product',
+                        key: to_key,
+                        value: product[from_key]
+                    }
+
+                    if bc_product
+                      field[:resource_id] = bc_product['id']
+                    end
+
+                    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, namespace, bc_product)
+
+                item = product['additionalProperty'].select {|p| p['propertyID'] == from_key}.first
+                if !item.nil?
+
+                    field = {
+                        namespace: namespace,
+                        permission_set: 'write',
+                        resource_type: 'product',
+                        key: to_key,
+                        value: item['value']
+                    }
+
+                    if bc_product
+                      field[:resource_id] = bc_product['id']
+                    end
+
+                    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, is_default_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: is_default_map[child['sku']],
+                        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/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

@@ -0,0 +1,226 @@
+module BigcommerceProductAgent
+    module Mapper
+        class ProductMapper
+
+            def self.map(product, variant, additional_data = {}, is_digital = false, default_sku='')
+                name = product['name']
+
+                if variant
+                    # variants inherit from and override parent product info
+                    name = "#{name} (#{self.get_option(variant)})"
+                    product = product.merge(variant)
+                else
+                    # wrapper product
+                    default_variant = self.get_variant_by_sku(product['sku'], product)
+                    if default_variant
+                        # pull up some properties from default variant (since bc doesn't display them otherwise)
+                        product = {
+                            "weight" => default_variant['weight'],
+                            "width" => default_variant['width'],
+                            "depth" => default_variant['depth'],
+                            "height" => default_variant['height'],
+                            "releaseDate" => default_variant['releaseDate'],
+                            "datePublished" => default_variant['datePublished'],
+                            "availability" => self.get_availability_offer(product, default_variant),
+                        }.merge(product)
+                    end
+                end
+
+                result = {
+                    name: name,
+                    sku: product ? product['sku'] : default_sku,
+                    is_default: product['isDefault'],
+                    type: product['isDigital'] == true || is_digital ? 'digital' : 'physical',
+                    description: product['description'] || '',
+                    price: product['offers'] && product['offers'][0] ? product['offers'][0]['price'] : '0',
+                    categories: self.get_categories(product),
+                    availability: self.get_availability(product),
+                    weight: product['weight'] ? product['weight']['value'] : '0',
+                    width: product['width'] ? product['width']['value'] : '0',
+                    depth: product['depth'] ? product['depth']['value'] : '0',
+                    height: product['height'] ? product['height']['value'] : '0',
+                    meta_keywords: self.meta_keywords(product),
+                    meta_description: self.meta_description(product) || '',
+                    search_keywords: self.get_search_keywords(additional_data.delete(:additional_search_terms), product),
+                    is_visible: variant ? false : true,
+                    preorder_release_date: product['releaseDate'] && product['releaseDate'].to_datetime ? product['releaseDate'].to_datetime.strftime("%FT%T%:z") : nil,
+                    preorder_message: self.get_availability(product) == 'preorder' ? product['availability'] : '',
+                    is_preorder_only: self.get_availability(product) == 'preorder' ? true : false,
+                    page_title: product['page_title'] || '',
+                }
+                result[:upc] = product['gtin12'] if product['gtin12']
+
+                result.merge(additional_data)
+            end
+
+            def self.get_wrapper_sku(product)
+                if product
+                    "#{product['sku']}-W"
+                end
+            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, is_digital, sku)
+                payload[:id] = product_id unless product_id.nil?
+                payload[:sku] = self.get_wrapper_sku(product)
+
+                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
+
+            def self.get_is_default(product)
+              map = {}
+
+              product['model'].each do |model|
+                  map[model['sku']] = model["isDefault"]
+              end
+
+              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, field_map)
+                result = {}
+
+                digitals = product['model'].select {|m| m['isDigital'] == true}
+
+                if digitals.length > 0
+                    clone = Marshal.load(Marshal.dump(product))
+                    clone['model'] = digitals
+                    clone['sku'] = clone['model'].select {|m| m['isDefault'] = true}.first['sku']
+                    self.merge_additional_properties(clone, field_map)
+                    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
+                    clone['sku'] = clone['model'].select {|m| m['isDefault'] = true}.first['sku']
+                    self.merge_additional_properties(clone, field_map)
+                    result[:physical] = clone
+                end
+
+                return result
+            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
+
+            def self.merge_additional_properties(clone, field_map)
+                defaultVariant = clone['model'].select { |v| v['isDefault'] }.first
+                if defaultVariant['isDefault'] && defaultVariant['additionalProperty']
+                    unless  field_map.nil? || field_map['additionalProperty'].nil?
+                        field_map['additionalProperty'].each do |field, key|
+                            prop = defaultVariant['additionalProperty'].select { |prop| prop['propertyID'] == field[key] }.first
+                            clone['additionalProperty'].push(prop) unless prop.nil?
+                        end
+                    end
+                end
+            end
+
+            # get a list of search keywords for the products
+            def self.get_search_keywords(additional_search_terms, product)
+                return (self.meta_keywords(product) + additional_search_terms.split(",")).join(",")
+            end
+
+            def self.get_availability(product)
+                if product['datePublished'] && product['datePublished'].to_datetime && product['datePublished'].to_datetime < DateTime.now
+                    return 'available'
+                else
+                    if product['releaseDate'] && product['releaseDate'].to_datetime
+                        if product['releaseDate'].to_datetime > DateTime.now
+                            return 'preorder'
+                        else
+                            return 'available'
+                        end
+                    else
+                        return 'disabled'
+                    end
+                end
+            end
+
+            def self.get_availability_offer(product, variant)
+                if product['offers'] && product['offers'][0]
+                    return product['offers'][0]['availability']
+                else
+                    if variant['offers'] && variant['offers'][0]
+                        return variant['offers'][0]['availability']
+                    end
+                end
+                return ''
+            end
+        end
+    end
+end