gemgento 2.8.0

data/lib/gemgento/api/soap/catalog/product_attribute.rb

@@ -0,0 +1,147 @@
+module Gemgento
+  module API
+    module SOAP
+      module Catalog
+        class ProductAttribute
+
+          def self.fetch_all
+            ::Gemgento::ProductAttributeSet.all.each do |product_attribute_set|
+              list(product_attribute_set).each do |product_attribute|
+                sync_magento_to_local(info(product_attribute[:attribute_id]), product_attribute_set)
+              end
+            end
+          end
+
+          def self.fetch(attribute_id, attribute_set)
+            attribute_info = info(attribute_id)
+            sync_magento_to_local(attribute_info, attribute_set)
+          end
+
+          def self.fetch_all_options(product_attribute)
+            option_ids = []
+
+            # add attribute options if there are any
+            Store.all.each do |store|
+              options(product_attribute.magento_id, store).each_with_index do |attribute_option, index|
+                label = MagentoApi.enforce_savon_string(attribute_option[:label])
+                value = MagentoApi.enforce_savon_string(attribute_option[:value])
+
+                product_attribute_option = ProductAttributeOption.find_or_initialize_by(product_attribute: product_attribute, value: value, store: store)
+                product_attribute_option.label = label
+                product_attribute_option.order = index
+                product_attribute_option.sync_needed = false
+                product_attribute_option.save
+
+                option_ids << product_attribute_option.id
+              end
+            end
+
+            product_attribute.product_attribute_options.where.not(id: option_ids).destroy_all
+          end
+
+          def self.list(product_attribute_set)
+            response = MagentoApi.create_call(:catalog_product_attribute_list, {set_id: product_attribute_set.magento_id})
+
+            if response.success?
+              unless response.body[:result][:item].is_a? Array
+                response.body[:result][:item] = [response.body[:result][:item]]
+              end
+
+              response.body[:result][:item]
+            end
+          end
+
+          def self.info(attribute_id)
+            response = MagentoApi.create_call(:catalog_product_attribute_info, {attribute: attribute_id})
+
+            if response.success?
+              response.body[:result]
+            end
+          end
+
+          def self.options(product_attribute_id, store)
+            message = {
+                attributeId: product_attribute_id,
+                storeView: store.magento_id
+            }
+            response = MagentoApi.create_call(:catalog_product_attribute_options, message)
+
+            if response.success?
+              if response.body[:result][:item].nil?
+                response.body[:result][:item] = []
+              end
+
+              unless response.body[:result][:item].is_a? Array
+                response.body[:result][:item] = [response.body[:result][:item]]
+              end
+
+              response.body[:result][:item]
+            end
+          end
+
+          def self.types
+            # TODO: Create types API call
+          end
+
+          def self.create(product_attribute)
+            # TODO: create a new product attribute set on Magento
+          end
+
+          def self.update(product_attribute)
+            # TODO: update a product attribute set on Magento
+          end
+
+          # Add an attribute option in Magento.
+          #
+          # @param product_attribute_option [Gemgento::ProductAttributeOption]
+          # @param product_attribute [Gemgento::ProductAttribute]
+          # @return [Gemgento::MagentoResponse]
+          def self.add_option(product_attribute_option, product_attribute)
+            message = {attribute: product_attribute.magento_id, data: {
+                label: {item: [{'store_id' => {item: Store.all.map { |s| s.magento_id.to_s } << 0}, value: product_attribute_option.label}]},
+                order: '0',
+                'is_default' => '0'
+            }}
+
+            response = MagentoApi.create_call(:catalog_product_attribute_add_option, message)
+            fetch_all_options(product_attribute) if response.success?
+
+            return response
+          end
+
+          def self.remove_option
+            # TODO: update a product attribute set on Magento
+          end
+
+          private
+
+          # Save Magento product attribute set to local
+          def self.sync_magento_to_local(source, product_attribute_set)
+            unless ::Gemgento::ProductAttribute.ignored.include?(source[:attribute_code])
+              product_attribute = ::Gemgento::ProductAttribute.find_or_initialize_by(magento_id: source[:attribute_id])
+              product_attribute.magento_id = source[:attribute_id]
+              product_attribute.product_attribute_sets << product_attribute_set unless product_attribute.product_attribute_sets.include? product_attribute_set
+              product_attribute.code = source[:attribute_code]
+              product_attribute.frontend_input = source[:frontend_input]
+              product_attribute.scope = source[:scope]
+              product_attribute.default_value = source[:default_value] == {:'@xsi:type' => 'xsd:string'} ? nil : source[:default_value]
+              product_attribute.is_unique = source[:is_unique]
+              product_attribute.is_required = source[:is_required]
+              product_attribute.is_configurable = source[:is_configurable]
+              product_attribute.is_searchable = source[:is_searchable]
+              product_attribute.is_visible_in_advanced_search = source[:is_visible_in_advanced_search]
+              product_attribute.is_comparable = source[:is_comparable]
+              product_attribute.is_used_for_promo_rules = source[:is_used_for_promo_rules]
+              product_attribute.is_visible_on_front = source[:is_visible_on_front]
+              product_attribute.used_in_product_listing = source[:used_in_product_listing]
+              product_attribute.sync_needed = false
+              product_attribute.save
+
+              fetch_all_options(product_attribute) if product_attribute.frontend_input == 'select'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/catalog/product_attribute_media.rb

@@ -0,0 +1,202 @@
+module Gemgento
+  module API
+    module SOAP
+      module Catalog
+        class ProductAttributeMedia
+
+          def self.fetch_all
+            ::Gemgento::Store.all.each do |store|
+              ::Gemgento::Product.active.each do |product|
+                fetch(product, store)
+              end
+            end
+          end
+
+          def self.fetch(product, store = nil)
+            store = ::Gemgento::Store.current if store.nil?
+            response = list(product, store)
+
+            if response.success?
+              assets_to_keep = []
+
+              response.body[:result][:item].each do |product_attribute_media|
+                if asset = sync_magento_to_local(product_attribute_media, product, store)
+                  assets_to_keep << asset.id
+                end
+              end
+
+              # destroy any assets that were not in the media gallery for each store
+              ::Gemgento::Asset.skip_callback(:destroy, :before, :delete_magento)
+              product.assets.where(store: store).where.not(id: assets_to_keep).destroy_all
+              ::Gemgento::Asset.set_callback(:destroy, :before, :delete_magento)
+            end
+          end
+
+          def self.fetch_all_media_types
+            ::Gemgento::ProductAttributeSet.all.each do |product_attribute_set|
+              response = types(product_attribute_set)
+
+              if response.success?
+                response.body[:result][:item].each do |media_type|
+                  sync_magento_media_type_to_local(media_type, product_attribute_set)
+                end
+              end
+            end
+          end
+
+          def self.list(product, store)
+            message = {
+                product: product.magento_id,
+                identifier_type: 'id',
+                store_view: store.magento_id
+            }
+            response = ::Gemgento::MagentoApi.create_call(:catalog_product_attribute_media_list, message)
+
+            if response.success?
+              if response.body[:result][:item].nil?
+                response.body[:result][:item] = []
+              elsif !response.body[:result][:item].is_a? Array
+                response.body[:result][:item] = [response.body[:result][:item]]
+              end
+            end
+
+            return response
+          end
+
+          def self.info
+
+          end
+
+          # Create a Product Attribute Media in Magento.
+          #
+          # @param asset [Gemgento::Asset]
+          # @return [Gemgento::MagentoResponse]
+          def self.create(asset)
+            message = {
+                product: asset.product.magento_id,
+                data: compose_asset_entity_data(asset, true),
+                identifier_type: 'id',
+                store_view: asset.store.magento_id
+            }
+            ::Gemgento::MagentoApi.create_call(:catalog_product_attribute_media_create, message)
+          end
+
+          # Update a Product Attribute Media in Magento.
+          #
+          # @param asset [Gemgento::Asset]
+          # @return [Gemgento::MagentoResponse]
+          def self.update(asset)
+            message = {
+                product: asset.product.magento_id,
+                file: asset.file,
+                data: compose_asset_entity_data(asset, false),
+                identifier_type: 'id',
+                store_view: asset.store.magento_id
+            }
+            ::Gemgento::MagentoApi.create_call(:catalog_product_attribute_media_update, message)
+          end
+
+          # Remove Product Attribute Media in Magento.
+          #
+          # @param asset [Gemgento::Asset]
+          # @return [Gemgento::MagentoResponse]
+          def self.remove(asset)
+            message = { product: asset.product.magento_id, file: asset.file, identifier_type: 'id' }
+            ::Gemgento::MagentoApi.create_call(:catalog_product_attribute_media_remove, message)
+          end
+
+          # Get Product Attribute Media Types from Magento.
+          #
+          # @param product_attribute_set [Gemgento::ProductAttributeSet]
+          # @return [Gemgento::MagnetoRepsonse]
+          def self.types(product_attribute_set)
+            response = ::Gemgento::MagentoApi.create_call(:catalog_product_attribute_media_types, {set_id: product_attribute_set.magento_id})
+
+            if response.success? &&
+              if response.body[:result][:item].nil?
+                response.body[:result][:item] = []
+              elsif !response.body[:result][:item].is_a?(Array)
+                response.body[:result][:item] = [response.body[:result][:item]]
+              end
+            end
+
+            return response
+          end
+
+          private
+
+          # Save Magento product attribute set to local
+          # @return [Gemgento::Asset]
+          def self.sync_magento_to_local(source, product, store)
+            return false unless ::Gemgento::AssetFile.valid_url(source[:url])
+
+            asset = ::Gemgento::Asset.find_or_initialize_by(product_id: product.id, file: source[:file], store_id: store.id)
+            asset.url = source[:url]
+            asset.position = source[:position]
+            asset.label = ::Gemgento::MagentoApi.enforce_savon_string(source[:label])
+            asset.file = source[:file]
+            asset.product = product
+            asset.sync_needed = false
+            asset.store = store
+            asset.set_file ::Gemgento::AssetFile.from_url(source[:url])
+            asset.save
+
+            # assign AssetTypes
+            asset_type_codes = source[:types][:item]
+            asset_type_codes = [::Gemgento::MagentoApi.enforce_savon_string(asset_type_codes)] unless asset_type_codes.is_a? Array
+            asset.set_types_by_codes(asset_type_codes)
+
+            return asset
+          end
+
+          def self.sync_magento_media_type_to_local(source, product_attribute_set)
+            asset_type = ::Gemgento::AssetType.find_or_initialize_by(product_attribute_set: product_attribute_set, code: source[:code])
+            asset_type.scope = source[:scope]
+            asset_type.save
+          end
+
+          def self.compose_asset_entity_data(asset, include_file = true)
+            asset_entity = {
+                label: asset.label,
+                position: asset.position,
+                types: {item: compose_types(asset)},
+                exclude: '0'
+            }
+
+            if include_file
+              asset_entity[:file] = compose_file_entity(asset.asset_file)
+            end
+
+            asset_entity
+          end
+
+          def self.compose_file_entity(asset_file)
+            if asset_file.file.url(:original) =~ URI::regexp
+              content = open(asset_file.file.url(:original)).read
+            else
+              content = File.open(asset_file.file.path(:original)).read
+            end
+
+            file_entity = {
+                content: Base64.encode64(content),
+                mime: asset_file.file_content_type
+            }
+
+            file_entity
+          end
+
+          def self.compose_types(asset)
+            types = []
+
+            asset.asset_types.each do |asset_type|
+              types << asset_type.code
+            end
+
+            types
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/catalog/product_attribute_set.rb

@@ -0,0 +1,80 @@
+module Gemgento
+  module API
+    module SOAP
+      module Catalog
+        class ProductAttributeSet
+
+          # Pull all Magento ProductAttributeSet data into Gemgento.
+          #
+          # @return [Void]
+          def self.fetch_all
+            response = list
+
+            if response.success?
+              response.body[:result][:item].each do |product_attribute_set|
+                sync_magento_to_local(product_attribute_set)
+              end
+            end
+          end
+
+          # Get a list of ProductAttributeSets from Magento.
+          #
+          # @return [Gemgento::MagentoResponse]
+          def self.list
+            response = MagentoApi.create_call(:catalog_product_attribute_set_list)
+
+            if response.success?
+              response.body[:result][:item] = [response.body[:result][:item]] unless response.body[:result][:item].is_a? Array
+            end
+
+            return response
+          end
+
+          # Create a new product attribute set in Magento
+          def self.create
+            # TODO: create a new product attribute set on Magento
+          end
+
+          # Update existing Magento product attribute set
+          def self.update
+            # TODO: update a product attribute set on Magento
+          end
+
+          def self.attribute_add
+            # TODO: add an attribute to a set on Magento
+          end
+
+          def self.attribute_remove
+            # TODO: remove an attribute from a set on Magento
+          end
+
+          def self.group_add
+            # TODO: add a new group for attributes in the set on Magento
+          end
+
+          def self.group_remove
+            # TODO: remove a group of attributes in the set on Magento
+          end
+
+          def self.group_rename
+            # TODO: rename a group in the set on Magento
+          end
+
+          private
+
+          # Save Magento product attribute set to local.
+          #
+          # @return [Void]
+          def self.sync_magento_to_local(source)
+            product_attribute_set = ::Gemgento::ProductAttributeSet.where(magento_id: source[:set_id]).first_or_initialize
+            product_attribute_set.magento_id = source[:set_id]
+            product_attribute_set.name = source[:name]
+            product_attribute_set.sync_needed = false
+            product_attribute_set.save
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/catalog/product_tag.rb

@@ -0,0 +1,146 @@
+module Gemgento
+  module API
+    module SOAP
+      module Catalog
+        class ProductTag
+
+          # Fetch all product tags from Magento.
+          #
+          # @return [Void]
+          def self.fetch_all
+            Product.not_deleted.where(magento_id: [391]).each do |product|
+              product.stores.each do |store|
+                list_response = list product, store
+
+                if list_response.success?
+
+                  list_response.body[:result][:item].each do |tag|
+                    info_response = info tag[:tag_id], store
+
+                    if info_response.success?
+                      sync_magento_to_local tag[:tag_id], info_response.body[:result], store
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Retrieve a list of tags related to a product and store.
+          #
+          # @param product [Product]
+          # @param store [Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.list(product, store)
+            message = {
+                product_id: product.magento_id,
+                store: store.magento_id
+            }
+            response = MagentoApi.create_call(:catalog_product_tag_list, message)
+
+            if response.success?
+              response.body[:result][:item] = [response.body[:result][:item]] unless response.body[:result][:item].is_a? Array
+            end
+
+            return response
+          end
+
+          # Retrieve info on a specific tag.
+          #
+          # @param magento_tag_id [Gemgento::Integer]
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.info(magento_tag_id, store)
+            message = {
+                tag_id: magento_tag_id,
+                store: store.magento_id
+            }
+            MagentoApi.create_call(:catalog_product_tag_info, message)
+          end
+
+          # Sync a Magento tag to Gemgento.
+          #
+          # @param magento_tag_id [Integer]
+          # @param source [Hash]
+          # @param store [Store]
+          def self.sync_magento_to_local(magento_tag_id, source, store)
+            tag = Tag.find_or_initialize_by(magento_id: magento_tag_id)
+            tag.name = source[:name]
+            tag.sync_needed = false
+            tag.save
+
+            store_tag = StoreTag.find_or_initialize_by(store: store, tag: tag)
+            store_tag.base_popularity = source[:base_popularity]
+            store_tag.save
+
+            associate_products(tag, source[:products][:item]) if source[:products][:item]
+          end
+
+          # Associate a tag using a set of magento product ids.
+          #
+          # @param tag [Tag]
+          # @param source_product_ids [Hash, Array(Hash)]
+          # @return [Void]
+          def self.associate_products(tag, source_product_ids)
+            product_ids = []
+            source_product_ids = [source_product_ids] unless source_product_ids.is_a? Array
+
+            source_product_ids.each do |product_key|
+              Product.unscoped do
+                if product = Product.not_deleted.find_by(magento_id: product_key[:key])
+                  tag.products << product unless tag.products.include? product
+                  product_ids << product.id
+                end
+              end
+            end
+
+            tag.products.where('gemgento_products.id NOT IN (?)', product_ids).destroy_all
+          end
+
+          # Add tags to a product.
+          #
+          # @param tags [Array(Tag)]
+          # @param products [Product]
+          # @param store [Store]
+          # @param user [User]
+          # @return [Gemgento::MagentoResponse]
+          def self.add(tags, product, store, user = nil)
+            message = {
+                tag: "'#{tags.map(&:name).join("', '")}'",
+                product_id: product.magento_id,
+                store: store.magento_id
+            }
+            message[:customer_id] = user.magento_id unless user.nil?
+
+            response = MagentoApi.create_call(:catalog_product_tag_info, message)
+
+            if response.success?
+              response.body[:result][:item] = [response.body[:result][:item]] unless response.body[:result][:item].is_a?(Array)
+            end
+
+            return response
+          end
+
+          # Manage a tag, this will create/update a tag with absolute values.
+          #
+          # @param tag [Tag]
+          # @param store [Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.manage(tag, store)
+            message = {
+                name: tag.name,
+                status: tag.status,
+                base_popularity: tag.base_popularity(store),
+                product_ids: {item: tag.products.map(&:magento_id)},
+                store: store.magento_id
+            }
+            message[:tag_id] = tag.magento_id unless tag.magento_id.nil?
+
+            MagentoApi.create_call(:catalog_product_tag_manage, message)
+          end
+
+        end
+      end
+    end
+  end
+end