gemgento 2.8.0

data/lib/gemgento/api/soap/checkout/product.rb

@@ -0,0 +1,138 @@
+module Gemgento
+  module API
+    module SOAP
+      module Checkout
+        class Product
+
+          # Add items to Magento quote.
+          #
+          # @param quote [Gemgento::Quote]
+          # @param line_items [Array(Gemgento::LineItem)]
+          # @return [Gemgento::MagentoResponse]
+          def self.add(quote, line_items)
+            message = {
+                quote_id: quote.magento_id,
+                products: { item: compose_products_data(line_items) },
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_product_add, message)
+          end
+
+          # Update items in Magento quote.
+          #
+          # @param quote [Gemgento::Quote]
+          # @param line_items [Array(Gemgento::LineItem)]
+          # @return [Gemgento::MagentoResponse]
+          def self.update(quote, line_items)
+            message = {
+                quote_id: quote.magento_id,
+                products: { item: compose_products_data(line_items) },
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_product_update, message)
+          end
+
+          # Remove items from Magento quote.
+          #
+          # @param quote [Gemgento::Quote]
+          # @param line_items [Array(Gemgento::LineItem)]
+          # @return [Gemgento::MagentoResponse]
+          def self.remove(quote, line_items)
+            message = {
+                quote_id: quote.magento_id,
+                products: { item: compose_products_data(line_items) },
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_product_remove, message)
+          end
+
+          # List all items in a quote
+          #
+          # @param quote [Gemgento::Quote]
+          # @return [Gemgento::MagentoResponse]
+          def self.list(quote)
+            message = {
+                quote_id: quote.magento_id,
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_product_list, message)
+          end
+
+          private
+
+          # An array with the list of shoppingCartProductEntity
+          #
+          # @param line_items [Array(Gemgento::LineItem)]
+          # @return [Array(Hash)]
+          def self.compose_products_data(line_items)
+            products_data = []
+
+            line_items.each do |line_item|
+              qty = line_item.qty_ordered
+              qty = qty.to_i if qty.to_i == qty # use an integer to avoid issue with decimals and 1 remaining item
+
+              products_data << {
+                  'product_id' => line_item.product.magento_id,
+                  sku: line_item.product.sku,
+                  qty: qty,
+                  options: { item: (compose_options_data(line_item.options) unless line_item.options.nil?) },
+                  'bundle_option' => line_item.bundle_options.any? ? { item: bundle_option(line_item) } : nil,
+                  'bundle_option_qty' => line_item.bundle_options.any? ? { item: bundle_option_qty(line_item) } : nil,
+                  links: nil
+              }
+            end
+
+            return products_data
+          end
+
+          def self.compose_options_data(options)
+            options_data = []
+
+            if options.any?
+              options.each do |key, value|
+                options_data << { key: key, value: value }
+              end
+            end
+
+            return options_data
+          end
+
+          # Create array of bundle item options.
+          #
+          # @param line_item [Gemgento::LineItem]
+          # @return [Hash]
+          def self.bundle_option(line_item)
+            bundle_options = []
+
+            line_item.bundle_options.each do |line_item_option|
+              bundle_options << {
+                  key: line_item_option.bundle_item.option.magento_id,
+                  value: line_item_option.bundle_item.magento_id
+              }
+            end
+
+            return bundle_options
+          end
+
+          # Create array of bundle items quantity .
+          #
+          # @param line_item [Gemgento::LineItem]
+          # @return [Array]
+          def self.bundle_option_qty(line_item)
+            bundle_option_qty = []
+
+            line_item.bundle_options.each do |line_item_option|
+              bundle_option_qty << {
+                  key: line_item_option.bundle_item.option.magento_id,
+                  value: line_item_option.quantity
+              }
+            end
+
+            return bundle_option_qty
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/checkout/shipping.rb

@@ -0,0 +1,37 @@
+module Gemgento
+  module API
+    module SOAP
+      module Checkout
+        class Shipping
+
+          # Retrieve a list of shipping methods for a Quote from Magento.
+          #
+          # @param quote [Gemgento::Quote]
+          # @return [Gemgento::MagentoResponse]
+          def self.list(quote)
+            message = {
+                quote_id: quote.magento_id,
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_shipping_list, message)
+          end
+
+          # Set the Quote shipping method in Magento.
+          #
+          # @param quote [Gemgento::Quote]
+          # @param shipping_method [String]
+          # @return [Gemgento::MagentoResponse]
+          def self.method(quote, shipping_method)
+            message = {
+                quote_id: quote.magento_id,
+                method: shipping_method,
+                store_id: quote.store.magento_id
+            }
+            MagentoApi.create_call(:shopping_cart_shipping_method, message)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/customer/address.rb

@@ -0,0 +1,143 @@
+module Gemgento
+  module API
+    module SOAP
+      module Customer
+        class Address
+
+          # Fetch Customer Addresses for all Gemgento Users from Magento.
+          #
+          # @return [Void]
+          def self.fetch_all
+            User.all.each do |user|
+              fetch(user)
+            end
+          end
+
+          # Fetch Customer Addresses for a User and sync them to Gemgento.
+          #
+          # @param user [Gemgento::User]
+          # @return [Void]
+          def self.fetch(user)
+            response = list(user.magento_id)
+
+            if response.success? && response.body[:result][:item]
+              response.body[:result][:item].each do |address|
+                sync_magento_to_local(address, user)
+              end
+            end
+          end
+
+          # Get a list of all Magento Addresses for a specific customer.
+          #
+          # @param customer_id [Integer] Magento Customer id.
+          # @return [Gemgento::MagentoResponse]
+          def self.list(customer_id)
+            response = MagentoApi.create_call(:customer_address_list, {customer_id: customer_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
+
+          # Get Magento Address data.
+          #
+          # @param address_id [Integer] Magento Address id.
+          # @return [Gemgento::MagentoReponse]
+          def self.info(address_id)
+            MagentoApi.create_call(:customer_address_list, { address_id: address_id })
+            # response.body[:result][:info]
+          end
+
+          # Create a Customer Address in Magento.
+          #
+          # @param address [Gemgento::Address]
+          # @return [Gemgento::MagentoResponse]
+          def self.create(address)
+            message = {
+                customer_id: address.addressable.magento_id,
+                address_data: compose_address_data(address)
+            }
+            MagentoApi.create_call(:customer_address_create, message)
+          end
+
+          # Update a Customer Address in Magento.
+          #
+          # @param address [Gemgento::Address]
+          # @return [Gemgento::MagentoResponse]
+          def self.update(address)
+            message = {
+                address_id: address.magento_id,
+                address_data: compose_address_data(address)
+            }
+            MagentoApi.create_call(:customer_address_update, message)
+          end
+
+          # Delete a Customer Address in Magento.
+          #
+          # @return [Gemgento::MagentoResponse]
+          def self.delete(address_id)
+            MagentoApi.create_call(:customer_address_update, {address_id: address_id})
+          end
+
+          private
+
+          # Save Magento users address to local
+          def self.sync_magento_to_local(source, user)
+            address = Gemgento::Address.find_or_initialize_by(magento_id: source[:customer_address_id], addressable: user)
+            address.increment_id = source[:increment_id]
+            address.city = source[:city]
+            address.company = source[:company]
+            address.country = Country.where(magento_id: source[:country_id]).first
+            address.fax = source[:fax]
+            address.first_name = source[:firstname]
+            address.middle_name = source[:middlename]
+            address.last_name = source[:lastname]
+            address.postcode = source[:postcode]
+            address.prefix = source[:prefix]
+            address.region_name = source[:region]
+            address.region = ::Gemgento::Region.where(magento_id: source[:region_id]).first
+            address.street = source[:street]
+            address.suffix = source[:suffix]
+            address.telephone = source[:telephone]
+            address.is_billing = source[:is_default_billing]
+            address.is_shipping = source[:is_default_shipping]
+            address.sync_needed = false
+            address.save
+
+            address
+          end
+
+          def self.compose_address_data(address)
+            address_data = {
+                city: address.city,
+                company: address.company,
+                'country_id' => address.country.magento_id,
+                fax: address.fax,
+                firstname: address.first_name,
+                lastname: address.last_name,
+                middlename: address.middle_name,
+                postcode: address.postcode,
+                prefix: address.prefix,
+                region: address.region_name,
+                'region_id' => address.region.nil? ? nil : address.region.magento_id,
+                street: {'arr:string' => [address.street]},
+                suffix: address.suffix,
+                telephone: address.telephone,
+                'is_default_billing' => address.is_billing,
+                'is_default_shipping' => address.is_shipping
+            }
+
+            address_data
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/customer/customer.rb

@@ -0,0 +1,200 @@
+module Gemgento
+  module API
+    module SOAP
+      module Customer
+        class Customer
+
+          def self.authnet_cim_cards(customer_id)
+            response = MagentoApi.create_call(:customer_customer_authnet_cim_cards, { customer_id: customer_id })
+
+            if response.success?
+              return response.body
+            else
+              return response.body[:faultstring]
+            end
+          end
+
+          def self.fetch_all(filters = {})
+            response = list(filters)
+
+            if response.success?
+              response.body_overflow[:store_view].each do |store_view|
+
+                unless store_view[:item].nil?
+                  # enforce array
+                  unless store_view[:item].is_a? Array
+                    store_view[:item] = [store_view[:item]]
+                  end
+
+                  store_view[:item].each do |customer|
+                    sync_magento_to_local(customer)
+                  end
+                end
+              end
+            end
+          end
+
+          # Grab customer from Magento and sync to Gemgento.
+          #
+          # @param [Integer] customer_id
+          # @return [User, String] The fetched user or an error message if there was a problem.
+          def self.fetch(customer_id)
+            response = info(customer_id)
+            if response.success?
+              sync_magento_to_local(response.body[:customer_info])
+            else
+              response.body[:faultstring]
+            end
+          end
+
+          def self.fetch_all_customer_groups
+            group.each do |customer_group|
+              sync_magento_customer_group_to_local(customer_group)
+            end
+          end
+
+          # Get a list of customers from Magento.
+          #
+          # @param filters [Hash]
+          # @return [Gemgento::MagentoResponse]
+          def self.list(filters = {})
+            if filters.empty?
+              message = {}
+            else
+              message = { filters: filters }
+            end
+
+            response = MagentoApi.create_call(:customer_customer_list, message)
+
+            if response.success? && !response.body_overflow[:store_view].is_a?(Array)
+              response.body_overflow[:store_view] = [response.body_overflow[:store_view]]
+            end
+
+            return response
+          end
+
+          # Get customer info from Magento
+          #
+          # @param [Integer] customer_id
+          # @return [MagentoResponse]
+          def self.info(customer_id)
+            MagentoApi.create_call(:customer_customer_info, { customer_id: customer_id })
+          end
+
+          # Create customer in Magento.
+          #
+          # @param [User] customer
+          # @param [Store] store
+          # @return [MagentoResponse]
+          def self.create(customer, store)
+            message = {
+                customer_data: compose_customer_data(customer, store)
+            }
+            MagentoApi.create_call(:customer_customer_create, message)
+          end
+
+          # Update customer in Magento.
+          #
+          # @param [User] customer
+          # @param [Store] store
+          # @return [MagentoResponse]
+          def self.update(customer, store)
+            message = {
+                customer_id: customer.magento_id,
+                customer_data: compose_customer_data(customer, store)
+            }
+            MagentoApi.create_call(:customer_customer_update, message)
+          end
+
+          # Delete customer in Magento.
+          #
+          # @param [User] customer
+          # @return [MagentoResponse]
+          def self.delete(customer)
+            message = {
+                customer_id: customer.magento_id
+            }
+            MagentoApi.create_call(:customer_customer_delete, message)
+          end
+
+          def self.group
+            response = MagentoApi.create_call(:customer_group_list)
+
+            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
+
+          private
+
+          # Save a Magento customer as local users
+          def self.sync_magento_to_local(source)
+            user = User.find_by(magento_id: source[:customer_id])
+
+            if user.nil?
+              user = User.where(email: source[:email]).first_or_initialize
+            end
+
+            user.magento_id = source[:customer_id]
+            user.increment_id = source[:increment_id]
+            user.stores << Store.find_by(magento_id: source[:store_id]) unless source[:store_id] == '0' || user.stores.include?(Store.find_by(magento_id: source[:store_id]))
+            user.created_in = source[:created_in]
+            user.email = source[:email]
+            user.first_name = source[:firstname]
+            user.middle_name = source[:middlename]
+            user.last_name = source[:lastname]
+            user.user_group = UserGroup.where(magento_id: source[:group_id]).first
+            user.prefix = source[:prefix]
+            user.suffix = source[:suffix]
+            user.dob = source[:dob]
+            user.taxvat = source[:taxvat]
+            user.confirmation = source[:confirmation]
+            user.magento_password = source[:password_hash]
+            user.gender = source[:gender]
+            user.sync_needed = false
+            user.save(validate: false)
+
+            API::SOAP::Customer::Address.fetch(user)
+
+            return user
+          end
+
+          def self.compose_customer_data(customer, store)
+            customer_data = {
+                email: customer.email,
+                firstname: customer.first_name,
+                middlename: customer.middle_name,
+                lastname: customer.last_name,
+                'store_id' => store.magento_id,
+                'group_id' => customer.user_group.magento_id,
+                'website_id' => store.website_id,
+                prefix: customer.prefix,
+                suffix: customer.suffix,
+                dob: customer.dob.nil? ? nil : "#{customer.dob.strftime('%Y-%m-%d')} 00:00:00",
+                taxvat: customer.taxvat,
+                gender: customer.gender.nil? ? nil : customer.gender
+            }
+
+            if !customer.password_confirmation.blank?
+              customer_data[:password] = customer.password_confirmation
+            end
+
+            customer_data
+          end
+
+          def self.sync_magento_customer_group_to_local(source)
+            customer_group = UserGroup.where(magento_id: source[:customer_group_id]).first_or_initialize
+            customer_group.magento_id = source[:customer_group_id]
+            customer_group.code = source[:customer_group_code]
+            customer_group.save
+          end
+
+        end
+      end
+    end
+  end
+end