gemgento 2.8.0

data/app/controllers/gemgento/magento/email/sales/credit_memos_controller.rb

@@ -0,0 +1,21 @@
+module Gemgento
+  module Magento
+    module Email
+      module Sales
+        class CreditMemosController < Gemgento::Magento::BaseController
+
+          def create
+            Gemgento::SalesMailer.credit_memo_email(
+                params[:data][:recipients],
+                params[:data][:sender],
+                params[:data][:order],
+                params[:data][:credit_memo]
+            ).deliver
+            render nothing: true
+          end
+
+        end
+      end
+    end
+  end
+end

data/app/controllers/gemgento/magento/email/sales/invoices_controller.rb

@@ -0,0 +1,21 @@
+module Gemgento
+  module Magento
+    module Email
+      module Sales
+        class InvoicesController < Gemgento::Magento::BaseController
+
+          def create
+            Gemgento::SalesMailer.invoice_email(
+                params[:data][:recipients],
+                params[:data][:sender],
+                params[:data][:order],
+                params[:data][:invoice]
+            ).deliver
+            render nothing: true
+          end
+
+        end
+      end
+    end
+  end
+end

data/app/controllers/gemgento/magento/email/sales/orders_controller.rb

@@ -0,0 +1,20 @@
+module Gemgento
+  module Magento
+    module Email
+      module Sales
+        class OrdersController < Gemgento::Magento::BaseController
+
+          def create
+            Gemgento::SalesMailer.order_email(
+                params[:data][:recipients],
+                params[:data][:sender],
+                params[:data][:order]
+            ).deliver
+            render nothing: true
+          end
+
+        end
+      end
+    end
+  end
+end

data/app/controllers/gemgento/magento/email/sales/shipments_controller.rb

@@ -0,0 +1,25 @@
+module Gemgento
+  module Magento
+    module Email
+      module Sales
+        class ShipmentsController < Gemgento::Magento::BaseController
+
+          def create
+            order = Gemgento::Magento::OrderAdapter.find(params[:data][:order][:increment_id]).import
+            shipment = Gemgento::Magento::ShipmentAdapter.find(params[:data][:shipment][:increment_id]).import
+
+            Gemgento::SalesMailer.shipment_email(
+                params[:data][:recipients],
+                params[:data][:sender],
+                order,
+                shipment
+            ).deliver
+
+            render nothing: true
+          end
+
+        end
+      end
+    end
+  end
+end

data/app/controllers/gemgento/magento/emails_controller.rb

@@ -0,0 +1,11 @@
+module Gemgento
+  module Magento
+    class EmailsController < Gemgento::Magento::BaseController
+
+      def create
+        render nothing: true
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/inventory_controller.rb

@@ -0,0 +1,30 @@
+module Gemgento
+  module Magento
+    class InventoryController < Gemgento::Magento::BaseController
+
+      def update
+        data = params[:data]
+
+        @product = Gemgento::Product.find_by!(magento_id: data[:product_id])
+
+        @product.stores.each do |store|
+            inventory = Gemgento::Inventory.find_or_initialize_by(store: store, product: @product)
+            inventory.product = @product
+            inventory.store = store
+            inventory.quantity = data[:qty]
+            inventory.is_in_stock = data[:is_in_stock]
+            inventory.backorders = data[:backorders].to_i
+            inventory.use_config_backorders = data[:use_config_backorders]
+            inventory.min_qty = data[:min_qty].to_i
+            inventory.use_config_min_qty = data[:use_config_min_qty]
+            inventory.manage_stock = data[:manage_stock]
+            inventory.sync_needed = false
+            inventory.save
+        end
+
+        render nothing: true
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/orders_controller.rb

@@ -0,0 +1,12 @@
+module Gemgento
+  module Magento
+    class OrdersController < Gemgento::Magento::BaseController
+
+      def update
+        @order = Gemgento::Magento::OrderAdapter.find(params[:data][:increment_id]).import
+        render nothing: true
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/price_rules_controller.rb

@@ -0,0 +1,22 @@
+module Gemgento
+  module Magento
+    class PriceRulesController < Gemgento::Magento::BaseController
+
+      def update
+        if data = params[:data]
+          API::SOAP::CatalogRule::Rule.sync_magento_to_local(data, data[:website_ids], data[:customer_group_ids])
+        end
+        render nothing: true
+      end
+
+      def destroy
+        if price_rule = PriceRule.find_by(magento_id: params[:id])
+          price_rule.destroy
+        end
+
+        render nothing: true
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/product_attribute_sets_controller.rb

@@ -0,0 +1,37 @@
+module Gemgento
+  module Magento
+    class ProductAttributeSetsController < Gemgento::Magento::BaseController
+
+      def update
+        data = params[:data]
+
+        @product_attribute_set = ProductAttributeSet.find_or_initialize_by(magento_id: params[:id])
+        @product_attribute_set.magento_id = data[:set_id]
+        @product_attribute_set.name = data[:name]
+        @product_attribute_set.save
+
+        unless data[:attributes].nil?
+          data[:attributes].each do |magento_id|
+            attribute = ProductAttribute.find_by(magento_id: magento_id)
+
+            unless attribute.nil?
+              @product_attribute_set.product_attributes << attribute unless @product_attribute_set.product_attributes.include?(attribute)
+            end
+          end
+        end
+
+        API::SOAP::Catalog::ProductAttributeMedia.fetch_all_media_types
+
+        render nothing: true
+      end
+
+      def destroy
+        @product_attribute_set = ProductAttributeSet.find_by(magento_id: params[:id])
+        @product_attribute_set.mark_deleted! unless @product_attribute_set.nil?
+
+        render nothing: true
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/product_attributes_controller.rb

@@ -0,0 +1,70 @@
+module Gemgento
+  module Magento
+    class ProductAttributesController < Gemgento::Magento::BaseController
+
+      def update
+        data = params[:data]
+
+        unless ProductAttribute.ignored.include?(data[:attribute_code])
+          @product_attribute = ProductAttribute.find_or_initialize_by(magento_id: params[:id])
+          @product_attribute.magento_id = data[:attribute_id]
+          @product_attribute.code = data[:attribute_code]
+          @product_attribute.frontend_input = data[:frontend_input]
+          @product_attribute.default_value = data[:default_value]
+          @product_attribute.scope = data[:scope]
+          @product_attribute.is_unique = data[:is_unique].to_i == 1 ? true : false
+          @product_attribute.is_required = data[:is_required].to_i == 1 ? true : false
+          @product_attribute.is_configurable = data[:is_configurable].to_i == 1 ? true : false
+          @product_attribute.is_searchable = data[:is_searchable].to_i == 1 ? true : false
+          @product_attribute.is_visible_in_advanced_search = data[:is_visible_in_advanced_search].to_i == 1 ? true : false
+          @product_attribute.is_comparable = data[:is_comparable].to_i == 1 ? true : false
+          @product_attribute.is_used_for_promo_rules = data[:is_used_for_promo_rules].to_i == 1 ? true : false
+          @product_attribute.used_in_product_listing = data[:used_in_product_listing].to_i == 1 ? true : false
+          @product_attribute.save
+
+
+          set_options(@product_attribute, data[:options]) unless data[:options].nil?
+
+          if @product_attribute.frontend_input == 'media_image'
+            API::SOAP::Catalog::ProductAttributeMedia.fetch_all_media_types
+          end
+        end
+
+        render nothing: true
+      end
+
+      def destroy
+        @product_attribute = ProductAttribute.find_by(magento_id: params[:id])
+        @product_attribute.mark_deleted! unless @product_attribute.nil?
+
+        render nothing: true
+      end
+
+      private
+
+      def set_options(product_attribute, options)
+        option_ids = []
+        options.each do |store_options|
+          next if store_options[:options].nil?
+
+          store = Store.find_by(magento_id: store_options[:store_id])
+
+          if store
+            store_options[:options].each_with_index do |option, index|
+              product_attribute_option = ProductAttributeOption.find_or_initialize_by(product_attribute: product_attribute, store: store, value: option[:value])
+              product_attribute_option.label = option[:label]
+              product_attribute_option.order = index
+              product_attribute_option.sync_needed = false
+              product_attribute_option.save
+
+              option_ids << product_attribute_option.id
+            end
+          end
+        end
+
+        product_attribute.product_attribute_options.where.not(id: option_ids).destroy_all
+      end
+
+    end
+  end
+end

data/app/controllers/gemgento/magento/products_controller.rb

@@ -0,0 +1,240 @@
+module Gemgento
+  module Magento
+    class ProductsController < Gemgento::Magento::BaseController
+
+      def update
+        data = params[:data]
+
+        @product = Gemgento::Product.find_or_initialize_by(magento_id: data[:product_id])
+
+        @product.magento_id = data[:product_id]
+        @product.magento_type = data[:type]
+        @product.sku = data[:sku]
+        @product.sync_needed = false
+        @product.product_attribute_set = ProductAttributeSet.where(magento_id: data[:set]).first
+        @product.magento_type = data[:type]
+        @product.deleted_at = nil
+        @product.save
+
+        set_stores(data[:stores], @product) unless data[:stores].nil?
+
+        unless data[:additional_attributes].nil?
+          set_assets(data[:additional_attributes], @product)
+          set_attribute_values_from_magento(data[:additional_attributes], @product)
+        end
+
+        if data[:configurable_attribute_ids]
+          @product.configurable_attributes = Gemgento::ProductAttribute.where(magento_id: data[:configurable_attribute_ids])
+        end
+
+        set_associated_products(data[:simple_product_ids], data[:configurable_product_ids], @product)
+        set_bundle_options(data[:bundle_options], @product) if data[:bundle_options]
+        set_tier_prices(data[:tier_price], @product) if data[:tier_price]
+
+        render nothing: true
+      end
+
+      def destroy
+        data = params[:data]
+
+        if Product.not_deleted.where('id = ? OR magento_id = ?', params[:id], data[:product_id]).count > 0
+          @product = Product.find_by('id = ? OR magento_id = ?', params[:id], data[:product_id]).mark_deleted!
+        end
+
+        render nothing: true
+      end
+
+      private
+
+      def set_stores(magento_stores, product)
+        product.stores.clear
+
+        magento_stores.each do |magento_id|
+          product.stores << Store.find_by(magento_id: magento_id)
+        end
+
+        product.save
+      end
+
+      def set_attribute_values_from_magento(magento_attribute_values, product)
+        magento_attribute_values.each do |store_id, attribute_values|
+          next if attribute_values.nil?
+
+          store = Store.find_by(magento_id: store_id)
+
+          attribute_values.each do |code, value|
+
+            case code.to_s
+              when 'visibility'
+                product.visibility = value.to_i
+                product.save
+              when 'status'
+                product.status = value.to_i == 1 ? 1 : 0
+                product.save
+              when 'category_ids'
+                set_categories(value, product, store)
+              else
+                product.set_attribute_value(code, value, store)
+            end
+          end
+        end
+      end
+
+      def set_categories(magento_categories, product, store)
+        category_ids = []
+
+        # loop through each return category and add it to the product if needed
+        unless magento_categories.nil?
+          magento_categories.each do |magento_category|
+            category = Category.find_by(magento_id: magento_category)
+            next if category.nil? # deleted categories are still returned from Magento, just skip
+
+            product_category = ProductCategory.find_or_initialize_by(category: category, product: product, store: store)
+            product_category.sync_needed = false
+            product_category.save
+
+            category_ids << category.id
+          end
+        end
+
+        # remove Product Category relations that were not pushed
+        ProductCategory.where(store: store, product: product).where.not(category_id: category_ids).destroy_all
+
+        product.save
+      end
+
+      def set_assets(magento_source_assets, product)
+        assets_to_keep = []
+
+        magento_source_assets.each do |store_id, source_assets| # cycle through media galleries for each
+          next if source_assets.nil?
+
+          if !source_assets[:media_gallery].nil? && !source_assets[:media_gallery][:images].nil?
+            store = Store.find_by(magento_id: store_id)
+            media_gallery = source_assets[:media_gallery][:images]
+
+            media_gallery.each do |source| # cycle through the store specific assets
+              asset = Asset.find_or_initialize_by(product_id: product.id, file: source[:file], store: store)
+
+              if !source[:removed].nil? && source[:removed] == 1
+                asset.destroy
+              else
+                url, file = get_url_and_file(source)
+                next unless AssetFile.valid_url(url)
+
+                asset.url = url
+                asset.position = source[:position]
+                asset.label = source[:label]
+                asset.product = product
+                asset.sync_needed = false
+                asset.set_file Gemgento::AssetFile.from_url(url)
+                asset.file = file
+                asset.store = store
+                asset.save
+
+                asset.set_types_by_codes(source[:types]) unless source[:types].nil?
+                assets_to_keep << asset.id
+              end
+            end
+          end
+        end
+
+        # destroy any assets that were not in the media gallery for each store
+        # this is a failsafe for image deletions that were not registered
+        Asset.skip_callback(:destroy, :before, :delete_magento)
+        product.assets.where('gemgento_assets.id NOT IN (?)', assets_to_keep).destroy_all
+        Asset.set_callback(:destroy, :before, :delete_magento)
+      end
+
+      def set_associated_products(simple_magento_product_ids, configurable_magento_product_ids, product)
+        unless simple_magento_product_ids.nil?
+          product.set_simple_products_by_magento_ids(simple_magento_product_ids)
+        end
+
+        unless configurable_magento_product_ids.nil?
+          product.set_configurable_products_by_magento_ids(configurable_magento_product_ids)
+        end
+      end
+
+      def set_bundle_options(bundle_options_data, product)
+        bundle_option_ids = []
+
+        bundle_options_data.each do |bundle_option_data|
+          bundle_option = product.bundle_options.find_or_initialize_by(magento_id: bundle_option_data[:id])
+          bundle_option.is_required = bundle_option_data[:required].to_i == 1 ? true : false
+          bundle_option.position = bundle_option_data[:position]
+          bundle_option.name = bundle_option_data[:default_title]
+
+          bundle_option_data[:type] = 'selection' if bundle_option_data[:type] == 'select'
+          bundle_option.input_type = Gemgento::Bundle::Option.input_types[bundle_option_data[:type].to_sym]
+
+          bundle_option.save
+          bundle_option_ids << bundle_option.id
+
+          set_bundle_items(bundle_option, bundle_option_data[:selections])
+        end
+
+        product.bundle_options.where.not(id: bundle_option_ids).destroy_all
+      end
+
+      def set_bundle_items(bundle_option, selections)
+        bundle_item_ids = []
+
+        unless selections.nil?
+          selections.each do |selection|
+            bundle_item = bundle_option.items.find_or_initialize_by(magento_id: selection[:id])
+            bundle_item.product = Gemgento::Product.find_by(magento_id: selection[:product_id])
+            bundle_item.price_type = selection[:price_type].to_i
+            bundle_item.price_value = selection[:price_value].to_f
+            bundle_item.default_quantity = selection[:qty].to_f
+            bundle_item.is_user_defined_quantity = selection[:can_change_qty].to_i == 1
+            bundle_item.position = selection[:position]
+            bundle_item.is_default = selection[:is_default].to_i == 1
+            bundle_item.save
+            bundle_item_ids << bundle_item.id
+          end
+        end
+
+        bundle_option.items.where.not(id: bundle_item_ids).destroy_all
+      end
+
+      def get_url_and_file(source)
+        if source[:new_file].nil?
+          url = "#{Config[:magento][:url]}/media/catalog/product#{source[:file]}"
+          file = source[:file]
+        else
+          url = "#{Config[:magento][:url]}/media/catalog/product#{source[:new_file]}"
+          file = source[:new_file]
+        end
+
+        return url, file
+      end
+
+      def set_tier_prices(tier_prices, product)
+        prices = []
+
+
+        tier_prices.each do |source|
+          next if source[:delete].to_bool
+
+          user_group = Gemgento::UserGroup.find_by(magento_id: source[:cust_group])
+          store = Gemgento::Store.find_by(website_id: source[:website_id])
+          stores = store.code == 'admin' ? Gemgento::Store.all : [store]
+
+          stores.each do |store|
+            prices << product.price_tiers.find_or_create_by(
+                user_group: user_group,
+                store: store,
+                quantity: source[:price_qty],
+                price: source[:price]
+            )
+          end
+        end
+
+        # remove unused product price tiers for the store
+        product.price_tiers.where.not(id: prices.map(&:id)).destroy_all
+      end
+
+    end
+  end
+end