gemgento 2.8.0

data/lib/gemgento/api/soap/directory/country.rb

@@ -0,0 +1,49 @@
+module Gemgento
+  module API
+    module SOAP
+      module Directory
+        class Country
+
+          # Fetch all Countries from Magento and sync them to Gemgento.
+          #
+          # @return [Void]
+          def self.fetch_all
+            response = list
+
+            if response.success?
+              response.body[:countries][:item].each do |country|
+                sync_magento_to_local(country)
+              end
+            end
+          end
+
+          # Get a list of Countries from Magento.
+          #
+          # @return [Gemgento::MagentoResponse]
+          def self.list
+            response = MagentoApi.create_call(:directory_country_list)
+
+            if response.success? && !response.body[:countries][:item].is_a?(Array)
+              response.body[:countries][:item] = [response.body[:countries][:item]]
+            end
+
+            return response
+          end
+
+          private
+
+          # Save Magento product attribute set to local
+          def self.sync_magento_to_local(source)
+            country = Gemgento::Country.where(magento_id: source[:country_id]).first_or_initialize
+            country.magento_id = source[:country_id]
+            country.iso2_code = source[:iso2_code]
+            country.iso3_code = source[:iso3_code]
+            country.name = source[:name]
+            country.save
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/directory/region.rb

@@ -0,0 +1,50 @@
+module Gemgento
+  module API
+    module SOAP
+      module Directory
+        class Region
+
+          def self.fetch_all
+            ::Gemgento::Country.all.each do |country|
+              response = list(country.iso2_code)
+
+              if response.success?
+                response.body[:countries][:item].each do |region|
+                  sync_magento_to_local(region, country)
+                end
+              end
+
+            end
+          end
+
+          def self.list(country)
+            response = MagentoApi.create_call(:directory_region_list, {country: country})
+
+            if response.success?
+              if response.body[:countries][:item].nil?
+                response.body[:countries][:item] = []
+              elsif !response.body[:countries][:item].is_a? Array
+                response.body[:countries][:item] = [response.body[:countries][:item]]
+              end
+            end
+
+            return response
+          end
+
+          private
+
+          # Save Magento product attribute set to local
+          def self.sync_magento_to_local(source, country)
+            region = Gemgento::Region.where(magento_id: source[:region_id]).first_or_initialize
+            region.magento_id = source[:region_id]
+            region.code = source[:code]
+            region.name = source[:name]
+            region.country = country
+            region.save
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/enterprise_gift_message/gift_message.rb

@@ -0,0 +1,26 @@
+module Gemgento
+  module API
+    module SOAP
+      module EnterpriseGiftMessage
+        class GiftMessage
+
+          def self.set_for_quote
+            # TODO: Create hold API call
+          end
+
+          def self.set_for_quote_item
+            # TODO: Create unhold API call
+          end
+
+          def self.set_for_quote_product
+            # TODO: Create cancel API call
+          end
+
+          def self.sync_magento_to_local(source)
+            # TODO: save gift messages locally
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Gemgento
+  module API
+    module SOAP
+      class GiftCard
+
+        def self.check(code)
+          MagentoApi.create_call(:giftcard_check, code: code)
+        end
+
+        def self.history(code)
+          MagentoApi.create_call(:giftcard_history, code: code)
+        end
+
+        def self.create(data)
+          MagentoApi.create_call(:giftcard_create, data: data)
+        end
+
+        def self.update(code, data)
+          MagentoApi.create_call(:giftcard_update, code: code, data: data)
+        end
+
+        def self.quote_add(quote_id, code, store_id)
+          message = { quote_id: quote_id, code: code, store_id: store_id }
+          MagentoApi.create_call(:giftcard_quote_add, message)
+        end
+
+        def self.quote_remove(quote_id, code, store_id)
+          message = { quote_id: quote_id, code: code }
+          MagentoApi.create_call(:giftcard_quote_remove, message)
+        end
+
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/globalcollect/saved_cc.rb

@@ -0,0 +1,58 @@
+module Gemgento
+  module API
+    module SOAP
+      module Globalcollect
+        class SavedCc
+
+          def self.fetch_all
+            User.all.each do |user|
+              fetch(user)
+            end
+          end
+
+          def self.fetch(user)
+            saved_cards = []
+
+            tokens(user.magento_id).each do |token|
+              saved_cards << sync_magento_to_local(token, user.id)
+            end
+
+            # destroy saved cards that were not returned
+            SavedCreditCard.where(user: user).where('id NOT IN (?)', saved_cards.collect(&:id)).delete_all
+          end
+
+          def self.tokens(customer_id)
+            response = MagentoApi.create_call(:globalcollect_tokens, {customer_id: customer_id})
+
+            if response.success?
+              if response.body[:result][:item].nil?
+                return []
+              else
+                response.body[:result][:item] = [response.body[:result][:item]] unless response.body[:result][:item].is_a? Array
+                return response.body[:result][:item]
+              end
+            else
+              return false
+            end
+          end
+
+          private
+
+          def self.sync_magento_to_local(token, user_id)
+            saved_cc = SavedCreditCard.find_or_initialize_by(magento_id: token[:token_id])
+            saved_cc.user_id = user_id
+            saved_cc.token = token[:token]
+            saved_cc.cc_number = token[:cc_number]
+            saved_cc.exp_month = token[:expire_date][0..1]
+            saved_cc.exp_year = token[:expire_date][2..3]
+            saved_cc.cc_type = token[:payment_product_id]
+            saved_cc.save
+
+            return saved_cc
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/miscellaneous/store.rb

@@ -0,0 +1,47 @@
+module Gemgento
+  module API
+    module SOAP
+      module Miscellaneous
+        class Store
+
+          def self.fetch_all
+            response = list
+
+            if response.success?
+              response.body[:stores][:item].each do |store|
+                sync_magento_to_local(store)
+              end
+            end
+
+          end
+
+          def self.list
+            response = MagentoApi.create_call(:store_list)
+
+            if response.success? && !response.body[:stores][:item].is_a?(Array)
+              response.body[:stores][:item] = [response.body[:stores][:item]]
+            end
+
+            return response
+          end
+
+          private
+
+          # Save Magento product attribute set to local
+          def self.sync_magento_to_local(source)
+            store = Gemgento::Store.where(magento_id: source[:store_id]).first_or_initialize
+            store.magento_id = source[:store_id]
+            store.code = source[:code]
+            store.website_id = source[:website_id]
+            store.group_id = source[:group_id]
+            store.name = source[:name]
+            store.sort_order = source[:sort_order]
+            store.is_active = source[:is_active]
+            store.save
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gemgento/api/soap/sales/order.rb

@@ -0,0 +1,249 @@
+module Gemgento
+  module API
+    module SOAP
+      module Sales
+        class Order
+
+          def self.fetch_all(last_updated = nil)
+            response = list(last_updated)
+
+            if response.success?
+              response.body_overflow[:result][:item].each do |order|
+                unless order.nil?
+                  fetch(order[:increment_id])
+                end
+              end
+            end
+
+          end
+
+          # Fetch a Magento Order.
+          #
+          # @param increment_id [String] Order increment id.
+          # @return [Gemgento::Order]
+          def self.fetch(increment_id)
+            response = info(increment_id)
+
+            if response.success?
+              sync_magento_to_local(response.body[:result])
+            else
+              return nil
+            end
+          end
+
+          # Get a list of orders from Magento.
+          #
+          # @param last_updated [String] db formatted datetime string.
+          # @return [Gemgento::MagentoResponse]
+          def self.list(last_updated = nil)
+            if last_updated.nil?
+              message = {}
+            else
+              message = {
+                  'filters' => {
+                      'complex_filter' => {item: [
+                          key: 'updated_at',
+                          value: {
+                              key: 'gt',
+                              value: last_updated
+                          }
+                      ]}
+                  }
+              }
+            end
+
+            response = ::Gemgento::MagentoApi.create_call(:sales_order_list, message)
+
+            if response.success? && !response.body_overflow[:result][:item].is_a?(Array)
+              response.body_overflow[:result][:item] = [response.body_overflow[:result][:item]]
+            end
+
+            return response
+          end
+
+          # Get Order info from Magento.
+          #
+          # @param increment_id [String]
+          # @return [Gemgento::MagentoResponse]
+          def self.info(increment_id)
+            ::Gemgento::MagentoApi.create_call(:sales_order_info, { order_increment_id: increment_id })
+          end
+
+          def self.hold
+            # TODO: Create hold API call
+          end
+
+          def self.unhold
+            # TODO: Create unhold API call
+          end
+
+          def self.cancel
+            # TODO: Create cancel API call
+          end
+
+          def self.add_comment(increment_id, status, comment = '', notify = nil)
+            message = {
+              order_increment_id: increment_id,
+              status: status,
+              comment: comment,
+              notify: notify
+            }
+            MagentoApi.create_call(:sales_order_add_comment, message)
+          end
+
+          private
+
+          # Save Magento order to local
+          #
+          # @return [::Gemgento::Order]
+          def self.sync_magento_to_local(source)
+            return nil if ::Gemgento::Store.find_by(magento_id: source[:store_id]).nil?
+
+            retry_count ||= 0
+
+            order = ::Gemgento::Order.find_or_initialize_by(increment_id: source[:increment_id])
+            order.magento_id = source[:order_id]
+            order.user = ::Gemgento::User.find_by(magento_id: source[:customer_id])
+            order.quote = ::Gemgento::Quote.find_by(magento_id: source[:quote_id])
+            order.user_group = ::Gemgento::UserGroup.where(magento_id: source[:customer_group_id]).first
+            order.store = ::Gemgento::Store.find_by(magento_id: source[:store_id])
+
+            source.each do |k, v|
+              next if [:store_id, :quote_id].include?(k) || !Gemgento::Order.column_names.include?(k.to_s)
+              order.assign_attributes k => v
+            end
+
+            order.save! validate: false
+
+            sync_magento_address_to_local(source[:shipping_address], order, order.shipping_address) unless source[:shipping_address][:address_id].nil?
+            sync_magento_address_to_local(source[:billing_address], order, order.billing_address) unless source[:billing_address][:address_id].nil?
+
+            sync_magento_payment_to_local(source[:payment], order)
+
+            unless source[:gift_message_id].nil?
+              gift_message = ::Gemgento::API::SOAP::EnterpriseGiftMessage::GiftMessage.sync_magento_to_local(source[:gift_message])
+              order.gift_message = gift_message
+              order.save! validate: false
+            end
+
+            # import line items
+            unless source[:items][:item].nil?
+              source[:items][:item] = [source[:items][:item]] unless source[:items][:item].is_a? Array
+              source[:items][:item].each do |item|
+                sync_magento_line_item_to_local(item, order)
+              end
+            end
+
+            # remove unused line items
+            known_ids = source[:items][:item].map { |i| i[:item_id] }
+            Gemgento::LineItem.where(itemizable: order).where.not(magento_id: known_ids).destroy_all
+
+            if !source[:status_history][:item].nil?
+              source[:status_history][:item] = [source[:status_history][:item]] unless source[:status_history][:item].is_a? Array
+
+              source[:status_history][:item].each do |status|
+                sync_magento_order_status_to_local(status, order)
+              end
+            end
+
+            order.reload
+            return order
+
+          # try one more time to create the record, duplicate record errors are common with threads
+          rescue ActiveRecord::RecordInvalid => e
+            (retry_count += 1) <= 1 ? retry : raise(e)
+
+          rescue ActiveRecord::RecordNotUnique => e
+            (retry_count += 1) <= 1 ? retry : raise(e)
+          end
+
+          def self.sync_magento_address_to_local(source, order, address = nil)
+            address = ::Gemgento::Address.new if address.nil?
+            address.addressable = order
+            address.increment_id = source[:increment_id]
+            address.city = source[:city]
+            address.company = source[:company]
+            address.country = ::Gemgento::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[:address_type] == 'billing')
+            address.is_shipping = (source[:address_type] == 'shipping')
+            address.sync_needed = false
+            address.save! validate: false
+
+            return address
+          end
+
+          def self.sync_magento_payment_to_local(source, order)
+            payment = ::Gemgento::Payment.where(magento_id: source[:payment_id].to_i).first_or_initialize
+            payment.payable = order
+            payment.magento_id = source[:payment_id]
+            payment.increment_id = source[:increment_id]
+            payment.is_active = source[:is_active]
+            payment.amount_ordered = source[:amount_ordered]
+            payment.shipping_amount = source[:shipping_amount]
+            payment.base_amount_ordered = source[:base_amount_ordered]
+            payment.base_shipping_amount = source[:base_shipping_amount]
+            payment.method = source[:method]
+            payment.po_number = source[:po_number]
+            payment.cc_type = source[:cc_type]
+            payment.cc_number_enc = source[:cc_number_enc]
+            payment.cc_last4 = source[:cc_last4]
+            payment.cc_owner = source[:cc_owner]
+            payment.cc_exp_month = source[:cc_exp_month]
+            payment.cc_exp_year = source[:cc_exp_year]
+            payment.cc_ss_start_month = source[:cc_ss_start_month]
+            payment.cc_ss_start_year = source[:cc_ss_start_year]
+            payment.save! validate: false
+
+            payment
+          end
+
+          def self.sync_magento_order_status_to_local(source, order)
+            order_status = ::Gemgento::OrderStatus.find_or_initialize_by(order_id: order.id, status: source[:status], comment: source[:comment])
+            order_status.order = order
+            order_status.status = source[:status]
+            order_status.is_active = source[:is_active]
+            order_status.is_customer_notified = source[:is_customer_notified].to_i
+            order_status.comment = source[:comment]
+            order_status.created_at = source[:created_at]
+            order_status.save
+
+            order_status
+          end
+
+          def self.sync_magento_line_item_to_local(source, order)
+            line_item = ::Gemgento::LineItem.find_or_initialize_by(itemizable_type: 'Gemgento::Order', magento_id: source[:item_id])
+            line_item.itemizable = order
+            line_item.product = ::Gemgento::Product.find_by(magento_id: source[:product_id])
+
+            source.each do |k, v|
+              next if [:product_id].include?(k) || !Gemgento::LineItem.column_names.include?(k.to_s)
+              line_item.assign_attributes k => v
+            end
+
+            unless source[:gift_message_id].nil?
+              gift_message = ::Gemgento::API::SOAP::EnterpriseGiftMessage::GiftMessage.sync_magento_to_local(source[:gift_message])
+              line_item.gift_message = gift_message
+              line_item.save
+            end
+
+            return line_item
+
+          rescue ActiveRecord::RecordNotUnique
+            return ::Gemgento::LineItem.find_by(itemizable_type: 'Gemgento::Order', magento_id: source[:item_id])
+          end
+        end
+      end
+    end
+  end
+end