gemgento 2.8.0

data/lib/gemgento/admin/product_positions.rb

@@ -0,0 +1,49 @@
+ActiveAdmin.register_page 'Product Positions' do
+  menu parent: 'Gemgento', priority: 7
+
+  page_action :update, method: :post
+
+  action_item(:edit) do
+    link_to 'Save Positions', admin_product_positions_update_path, method: :post, id: 'submit-product-positions'
+  end
+
+  content do
+    render 'index'
+  end
+
+  controller do
+    def index
+      if params[:category_id]
+        @category = Gemgento::Category.find(params[:category_id])
+      elsif Gemgento::Category.top_level.navigation.any?
+        @category = Gemgento::Category.top_level.navigation.first
+      else
+        @category = Gemgento::Category.root
+      end
+
+      @store = params[:store_id].blank? ? nil : Gemgento::Store.find(params[:store_id])
+      @products = @category.products(@store).active.catalog_visible
+    end
+
+    def update
+      @category = Gemgento::Category.where(id: params[:category_id]).first
+      @stores = params[:store_id].blank? ? Gemgento::Store.all : Gemgento::Store.where(id: params[:store_id])
+
+      @stores.each do |store|
+        params[:products].split(',').each_with_index do |id, index|
+          product_category = Gemgento::ProductCategory.find_by(category_id: @category.id, product_id: id, store_id: store.id)
+          next if product_category.nil?
+
+          product_category.position = index
+          product_category.sync_needed = false
+          product_category.save!
+        end
+
+        Gemgento::API::SOAP::Catalog::Category.update_product_positions(@category, store)
+      end
+
+      flash[:notice] = 'Product positions successfully updated.'
+      redirect_to admin_product_positions_path(category_id: @category.id, store_id: params[:store_id])
+    end
+  end
+end

data/lib/gemgento/admin/stores.rb

@@ -0,0 +1,33 @@
+if defined?(ActiveAdmin)
+  module Gemgento
+    ActiveAdmin.register Store do
+      menu priority: 100, parent: 'Gemgento', label: 'Stores'
+
+      actions :all, :except => [:new, :destroy]
+
+      index do
+        column :name
+        column :currency_code
+        actions
+      end
+
+      form multipart: true do |f|
+        f.inputs do
+          f.input :currency_code
+        end
+
+        f.actions
+      end
+
+      controller do
+        def permitted_params
+          params.permit(
+              :gemgento_store => [
+                  :currency_code
+              ])
+        end
+      end
+
+    end
+  end
+end

data/lib/gemgento/admin/subscribers.rb

@@ -0,0 +1,31 @@
+if defined?(ActiveAdmin)
+  module Gemgento
+    ActiveAdmin.register Subscriber do
+      menu label: 'Subscribers', parent: 'Gemgento'
+
+      permit_params :first_name, :last_name, :email
+
+      index do
+        column :email
+        column :first_name
+        column :last_name
+        column :country
+        column :city
+        actions
+      end
+
+      form multipart: true do |f|
+        f.inputs do
+          f.input :email
+          f.input :first_name
+          f.input :last_name
+          f.input :country
+          f.input :city
+        end
+
+        f.actions
+      end
+
+    end
+  end
+end

data/lib/gemgento/admin/syncs.rb

@@ -0,0 +1,26 @@
+if defined?(ActiveAdmin)
+  module Gemgento
+    ActiveAdmin.register Sync do
+      menu priority: 100, parent: 'Gemgento', label: 'Sync'
+      permit_params :subject
+
+      actions :all, except: [:edit, :destroy]
+
+      form do |f|
+        f.inputs do
+          f.input :subject, as: :select, collection: %w[attributes categories customers everything  products  orders]
+        end
+        f.actions
+      end
+
+      controller do
+        def create
+          Gemgento::Sync.send(params[:sync][:subject])
+
+          redirect_to admin_gemgento_syncs_url
+        end
+      end
+
+    end
+  end
+end

data/lib/gemgento/api/soap/authnetcim/payment.rb

@@ -0,0 +1,127 @@
+module Gemgento
+  module API
+    module SOAP
+      module Authnetcim
+        class Payment
+
+          # Get a list of saved payment methods for customer.
+          #
+          # @param customer_id [Integer] Magento customer id.
+          # @return [Gemgento::MagentoResponse]
+          def self.list(customer_id)
+            response = MagentoApi.create_call(:authnetcim_payment_list, { customer_id: customer_id })
+
+            # filter and enforce the array of cards on success
+            if response.success?
+              if response.body[:response].nil?
+                response.body[:response] = {item: []}
+              elsif response.body[:response][:item].nil?
+                response.body[:response][:item] = []
+              elsif !response.body[:response][:item].is_a? Array
+                response.body[:response][:item] = [response.body[:response][:item]]
+              end
+            end
+
+            return response
+          end
+
+          # Create a new saved payment method for a customer
+          #
+          # @param saved_credit_card [Gemgento::SavedCreditCard]
+          # @return [Gemgento::MagentoResponse]
+          def self.create(saved_credit_card)
+            message = {
+                customer_id: saved_credit_card.user.magento_id,
+                payment: {
+                    firstname: saved_credit_card.address.first_name,
+                    lastname: saved_credit_card.address.last_name,
+                    address1: saved_credit_card.address.street,
+                    city: saved_credit_card.address.city,
+                    state: saved_credit_card.address.region.magento_id,
+                    zip: saved_credit_card.address.postcode,
+                    country: saved_credit_card.address.country.iso2_code,
+                    'cc_type' => saved_credit_card.cc_type,
+                    'cc_number' => saved_credit_card.cc_number,
+                    'cc_exp_month' => saved_credit_card.exp_month,
+                    'cc_exp_year' => saved_credit_card.exp_year
+                }
+            }
+
+            MagentoApi.create_call(:authnetcim_payment_create, message)
+          end
+
+          # Destroy a saved payment method for a customer.
+          #
+          # @param customer_id [Integer] Magento customer id.
+          # @param payment_profile_id [String]
+          # @return [Gemgento::MagentoResponse]
+          def self.destroy(customer_id, payment_profile_id)
+            message = {
+                customer_id: customer_id,
+                payment_profile_id: payment_profile_id
+            }
+            MagentoApi.create_call(:authnetcim_payment_destroy, message)
+          end
+
+          # Fetch and sync all user saved credit cards.
+          #
+          # @param user [Gemgento::User]
+          # @return [Void]
+          def self.fetch(user)
+            saved_cards = []
+            response = list(user.magento_id)
+
+            if response.success?
+              response.body[:response][:item].each do |saved_card|
+                saved_cards << sync_magento_to_local(user, saved_card)
+              end
+            end
+
+            SavedCreditCard.skip_callback(:destroy, :before, :magento_destroy)
+            user.saved_credit_cards.reload
+            user.saved_credit_cards.where.not(id: saved_cards.map(&:id)).destroy_all
+            SavedCreditCard.set_callback(:destroy, :before, :magento_destroy)
+          end
+
+          private
+
+          # Sync a Magento saved credit card with a local one.
+          #
+          # @param user [Gemgento::User]
+          # @param saved_card_params [Hash]
+          # @return [Gemgento::SavedCreditCard]
+          def self.sync_magento_to_local(user, saved_card_params)
+            SavedCreditCard.skip_callback(:create, :before, :magento_create)
+            saved_credit_card = SavedCreditCard.find_or_initialize_by(
+                user: user,
+                token: saved_card_params[:customer_payment_profile_id]
+            )
+            saved_credit_card.cc_number = saved_card_params[:payment][:credit_card][:card_number]
+            saved_credit_card
+            saved_credit_card.save
+            SavedCreditCard.set_callback(:create, :before, :magento_create)
+
+            # address / bill_to data
+            address = ::Gemgento::Address.find_or_initialize_by(addressable: saved_credit_card)
+            address.first_name = saved_card_params[:bill_to][:first_name]
+            address.last_name = saved_card_params[:bill_to][:last_name]
+            address.street = saved_card_params[:bill_to][:address]
+            address.city = saved_card_params[:bill_to][:city]
+            address.country = ::Gemgento::Country.find_by(iso2_code: saved_card_params[:bill_to][:country])
+            address.postcode = saved_card_params[:bill_to][:zip]
+
+            if address.country.regions.any?
+              address.region = address.country.regions.find_by(name: saved_card_params[:bill_to][:state])
+            end
+
+            address.save validate: false
+
+            return saved_credit_card
+          end
+
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+module Gemgento
+  module API
+    module SOAP
+      module Catalog
+        class Category
+
+          # Pull all Magento Category into Gemgento.
+          #
+          # @return [Void]
+          def self.fetch_all
+            Store.all.each do |store|
+              response = tree(store)
+              if response.success?
+                sync_magento_tree_to_local(response.body[:tree], store) unless response.body[:tree].nil?
+              end
+            end
+          end
+
+          # Get the Category tree from Magento.
+          #
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.tree(store)
+            message = {
+                store_view: store.magento_id
+            }
+            MagentoApi.create_call(:catalog_category_tree, message)
+          end
+
+          # Get Category info from Magento.
+          #
+          # @param magento_id [Integer] Magento category id.
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.info(magento_id, store)
+            message = {
+                category_id: magento_id,
+                store_view: store.magento_id
+            }
+            MagentoApi.create_call(:catalog_category_info, message)
+          end
+
+          # Create Category in Magento.
+          #
+          # @param category [Gemgento::Category]
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.create(category, store)
+            data = {
+                name: category.name,
+                'is_active' => category.is_active ? 1 : 0,
+                'include_in_menu' => category.include_in_menu ? 1 : 0,
+                'available_sort_by' => {'arr:string' => %w[name]},
+                'default_sort_by' => 'name',
+                'url_key' => category.url_key,
+                'position' => category.position,
+                'is_anchor' => 1
+            }
+            message = {
+                parentId: category.parent.magento_id,
+                category_data: data,
+                store_view: store.magento_id
+            }
+            MagentoApi.create_call(:catalog_category_create, message)
+          end
+
+          def self.update(category, store)
+            data = {
+                name: category.name,
+                'is_active' => category.is_active ? 1 : 0,
+                'include_in_menu' => category.include_in_menu ? 1 : 0,
+                'url_key' => category.url_key,
+                'position' => category.position
+            }
+            message = {
+                category_id: category.magento_id,
+                category_data: data,
+                store_view: store.magento_id
+            }
+            MagentoApi.create_call(:catalog_category_update, message)
+          end
+
+          # Update Category Product positions in Magento.
+          #
+          # @param category [Gemgento::Category]
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.update_product_positions(category, store)
+            # create an array of product positions
+            product_positions = []
+              category.product_categories.where(store: store).each do |product_category|
+              next if product_category.category.nil? or product_category.product.nil? or !product_category.product.deleted_at.nil?
+
+              product_positions << {
+                  product_id: product_category.product.magento_id,
+                  position: product_category.position
+              }
+            end
+
+            message = {
+                category_id: category.magento_id,
+                product_positions: {item: product_positions},
+                store_id: store.magento_id
+            }
+
+            MagentoApi.create_call(:catalog_category_update_product_positions, message)
+          end
+
+          # Get Products assigned to a Category in Magento.
+          #
+          # @param category [Gemgento::Category]
+          # @param store [Gemgento::Store]
+          # @return [Gemgento::MagentoResponse]
+          def self.assigned_products(category, store)
+            message = {
+                category_id: category.magento_id,
+                store_id: store.magento_id
+            }
+            response = MagentoApi.create_call(:catalog_category_assigned_products, 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
+
+          # Update all Category Products based on Magento data.
+          #
+          # @return [Void]
+          def self.set_product_categories
+            ::Gemgento::Category.all.each do |category|
+
+              category.stores.each do |store|
+                response = assigned_products(category, store)
+                next unless response.success?
+
+                items = response.body[:result][:item]
+
+                if items.nil? || items == false || items.empty?
+                  ProductCategory.unscoped.where(category: category, store: store).destroy_all
+                  next
+                end
+
+                product_category_ids = []
+                items.each do |item|
+                  product = ::Gemgento::Product.find_by(magento_id: item[:product_id])
+                  next if product.nil?
+
+                  pairing = ProductCategory.unscoped.find_or_initialize_by(category: category, product: product, store: store)
+                  pairing.position = item[:position].nil? ? 1 : item[:position][0]
+                  pairing.store = store
+                  pairing.save
+
+                  product_category_ids << pairing.id
+                end
+
+                ProductCategory.unscoped.
+                    where('store_id = ? AND category_id = ? AND id NOT IN (?)', store.id, category.id, product_category_ids).
+                    destroy_all
+              end
+            end
+          end
+
+          # Update ProductCategory info in Magento.
+          #
+          # @param product_category [Gemgento::ProductCategory]
+          # @return [Gemgento::MagentoResponse]
+          def self.update_product(product_category)
+            message = {
+                category_id: product_category.category.magento_id,
+                product: product_category.product.magento_id,
+                position: product_category.position,
+                product_identifier_type: 'id'
+            }
+            MagentoApi.create_call(:catalog_category_update_product, message)
+          end
+
+          private
+
+          # Traverse Magento category tree while synchronizing with local category tree
+          #
+          # @param category_tree [Hash] The returned item of Magento API call
+          # @param store [Gemgento::Store]
+          # @return [Void]
+          def self.sync_magento_tree_to_local(category_tree, store)
+            response = info(category_tree[:category_id], store)
+
+            if response.success?
+              sync_magento_to_local(response.body[:info], store)
+
+              if category_tree[:children][:item]
+                category_tree[:children][:item] = [category_tree[:children][:item]] unless category_tree[:children][:item].is_a? Array
+                category_tree[:children][:item].each do |child|
+                  sync_magento_tree_to_local(child, store)
+                end
+              end
+            end
+          end
+
+          # Synchronize the response of a catalogCategoryInfo API call to local database
+          #
+          # @param subject [Hash] The returned item of Magento API call
+          # @param store [Gemgento::Store]
+          # @return [Void]
+          def self.sync_magento_to_local(subject, store)
+            category = ::Gemgento::Category.find_or_initialize_by(magento_id: subject[:category_id])
+            category.name = subject[:name]
+            category.url_key = subject[:url_key]
+            category.parent = ::Gemgento::Category.find_by(magento_id: subject[:parent_id])
+            category.position = subject[:position]
+            category.is_active = subject[:is_active]
+            category.include_in_menu = subject[:include_in_menu].to_i == 1 ? true : false
+            category.all_children = subject[:all_children].nil? ? '' : subject[:all_children]
+
+            if subject.key? :image
+              begin
+                category.image = open("#{Config[:magento][:url]}/media/catalog/category/#{subject[:image]}")
+              rescue
+                category.image = nil
+              end
+            end
+
+            category.sync_needed = false
+            category.save
+
+            category.stores << store unless category.stores.include?(store)
+          end
+        end
+      end
+    end
+  end
+end