spree_tradebyte 0.1.12.alpha

data/app/jobs/spree_tradebyte/export_stock_job.rb

@@ -0,0 +1,39 @@
+require 'nokogiri'
+
+class SpreeTradebyte::ExportStockJob < ApplicationJob
+  queue_as :tradebyte
+
+  def perform(*args)
+    stock_items = get_stock_items
+    stock_xml = parse_stock_items(stock_items)
+    transport_stock(stock_xml)
+  end
+
+  def get_stock_items
+    products = Spree::Product.active
+    Spree::Variant.includes(:stock_items).where(product: products).collect do |v|
+      {
+          sku: v.sku,
+          stock_item: v.stock_items.first
+      }
+    end
+  end
+
+  def parse_stock_items(stock_items)
+    Nokogiri::XML::Builder.new do |xml|
+      xml.TBSTOCK do
+        stock_items.each do |stock_item|
+          xml.ARTICLE do
+            xml.A_EAN stock_item[:sku]
+            xml.A_STOCK stock_item[:stock_item].count_on_hand
+          end
+        end
+      end
+    end.to_xml
+  end
+
+  def transport_stock(stock_xml)
+    ftp = SpreeTradebyte::TradebyteFTP.new(SpreeTradebyte.ftp_user, SpreeTradebyte.ftp_password, SpreeTradebyte.ftp_server, SpreeTradebyte.ftp_port)
+    ftp.put_stock_file(stock_xml)
+  end
+end

data/app/jobs/spree_tradebyte/import_orders_job.rb

@@ -0,0 +1,70 @@
+require 'nokogiri'
+require 'spree_tradebyte/order/processor'
+require 'spree_tradebyte/tb_logger'
+
+class SpreeTradebyte::ImportOrdersJob < ApplicationJob
+  include SpreeTradebyte::Order::Processor
+
+  queue_as :tradebyte
+
+  def perform(*args)
+    ftp = SpreeTradebyte::TradebyteFTP.new(SpreeTradebyte.ftp_user, SpreeTradebyte.ftp_password, SpreeTradebyte.ftp_server, SpreeTradebyte.ftp_port)
+    files = ftp.get_order_files
+
+    orders_hash = parse_order_files(files)
+    orders_hash.map do |order_hash|
+      process_order(order_hash)
+    end
+
+    ftp.archive_files(files.map {|f| f[:file_name]})
+  rescue StandardError => e
+    SpreeTradebyte::TBLogger.debug("Something went wrong while processing ALL TB ORDERS")
+    SpreeTradebyte::TBLogger.debug(e)
+    SpreeTradebyte::TBLogger.debug(e.backtrace.join("\n"))
+    ErrorNotificationMailer.exception_mail(e).deliver_now
+  end
+
+  def parse_order_files(files)
+    files.each_with_object([]) do |file, list|
+      xml = Nokogiri::XML(file[:file_contents])
+      xml.search('//ORDER_LIST/ORDER').each do |order_xml|
+        list << {
+            tb_id: order_xml.search('./ORDER_DATA/TB_ID').text,
+            channel_id: order_xml.search('./ORDER_DATA/CHANNEL_ID').text,
+            channel_sign: order_xml.search('./ORDER_DATA/CHANNEL_SIGN').text,
+            paid: order_xml.search('./ORDER_DATA/PAID').text.to_i == 1,
+            approved: order_xml.search('./ORDER_DATA/APPROVED').text.to_i == 1,
+            email: order_xml.search('./SELL_TO/EMAIL').text,
+            bill_address: parse_address(order_xml.search('./SELL_TO')),
+            ship_address: parse_address(order_xml.search('./SHIP_TO')),
+            line_items: parse_line_items(order_xml.search('./ITEMS/ITEM')),
+            completed_at: DateTime.parse(order_xml.search('./ORDER_DATA/DATE_CREATED').text)
+        }
+      end
+    end
+  end
+
+  def parse_address(address_xml)
+    {
+        firstname: address_xml.search('./FIRSTNAME').text,
+        lastname: address_xml.search('./LASTNAME').text,
+        address1: address_xml.search('./STREET_NO').text,
+        zipcode: address_xml.search('./ZIP').text,
+        city: address_xml.search('./CITY').text,
+        country: Spree::Country.find_by(iso: address_xml.search('./COUNTRY').text),
+    }
+  end
+
+  def parse_line_items(items_xml)
+    items_xml.map do |item_xml|
+      {
+          tb_id: item_xml.search('./TB_ID').text,
+          sku: item_xml.search('./EAN').text,
+          tradebyte_sku: item_xml.search('./SKU').text,
+          quantity: item_xml.search('./QUANTITY').text,
+          price: item_xml.search('./ITEM_PRICE').text,
+      }
+    end
+  end
+
+end

data/app/jobs/spree_tradebyte/order/processor.rb

@@ -0,0 +1,158 @@
+require 'spree_tradebyte/tb_logger'
+
+class TradebyteOrderInvalid < StandardError;
+end
+
+module SpreeTradebyte
+
+  module Order
+    module Processor
+
+      def process_order(order_hash)
+        order = Spree::Order.find_by_tradebyte_id(order_hash[:tb_id])
+        return order unless order_hash[:approved]
+        begin
+          if order.present?
+            update_order(order, order_hash)
+          else
+            order = create_order(order_hash)
+          end
+
+          if order.payments.none? && order.persisted?
+            order.update_with_updater!
+            payment_method = Spree::PaymentMethod.find_by_type!('Spree::PaymentMethod::Tradebyte')
+            payment = order.payments.create!(payment_method: payment_method, amount: order.total)
+            payment.capture!
+            order.state = 'complete'
+            order.completed_at = order_hash[:completed_at]
+            order.save!
+            order.reload
+            order.update_with_updater!
+            raise TradebyteOrderInvalid("Tradebyte order #{order.number} not completed. Tradebyte ID #{order.tradebyte_id}") unless order.complete?
+            order.tb_send_confirm_messages
+          end
+        rescue StandardError => e
+          SpreeTradebyte::TBLogger.debug("Something went wrong while processing tb order #{order_hash[:tb_id]}")
+          SpreeTradebyte::TBLogger.debug(e.message)
+          SpreeTradebyte::TBLogger.debug(e.backtrace.join("\n"))
+          ErrorNotificationMailer.exception_mail(e, order).deliver_now
+        end
+        order
+      end
+
+      def update_order(order, order_hash)
+        #Not implemented
+      end
+
+      def create_order(order_hash)
+        order_attibutes = {
+            tradebyte_id: order_hash[:tb_id],
+            tradebyte_channel_id: order_hash[:channel_id],
+            tradebyte_channel_sign: order_hash[:channel_sign],
+            is_tradebyte_order: true,
+        }.merge(build_order_attributes(order_hash))
+
+        order = Spree::Order.new(order_attibutes)
+        unavailable_line_items, order.line_items = order.line_items.partition do |line_item|
+          !line_item.variant.present? || !line_item.variant.available? || !line_item.variant.can_supply?(line_item.quantity)
+        end # split variants in array of unavailable and available line items
+
+        if unavailable_line_items.any?
+          order.tb_send_cancel_messages("Items are out of stock", unavailable_line_items) rescue nil
+        end
+
+        if order.line_items.any?
+          unless order.save
+            order.tb_send_cancel_messages(order.errors.full_messages) if order
+            SpreeTradebyte::TBLogger.debug("Cancelled order #{order.try(:tradebyte_id)} due to #{order.errors.full_messages}")
+            return order
+          end
+        elsif order.line_items.none?
+          return order
+        end
+
+        create_shipments(order_hash, order)
+
+        order.save!
+        order
+
+      rescue StandardError => e
+        SpreeTradebyte::TBLogger.debug("Something went wrong while creating tb order #{order_hash[:tb_id]}")
+        SpreeTradebyte::TBLogger.debug(e.message)
+        SpreeTradebyte::TBLogger.debug(e.backtrace.join("\n"))
+        ErrorNotificationMailer.exception_mail(e, order).deliver_now
+      end
+
+      def create_shipments(order_hash, order)
+        channel_shipping_method = Spree::ShippingMethod.where('code LIKE CONCAT(\'%\',?,\'%\')', order_hash[:channel_sign]).first
+
+        raise TradebyteOrderInvalid.new('Could not find a matching shipping method') unless channel_shipping_method.present?
+
+        inventory_units = Spree::Stock::InventoryUnitBuilder.new(order).units
+
+        shipment = order.shipments.build
+        shipment.stock_location = Spree::StockLocation.find_by(default: true)
+
+        order.line_items.each do |line_item|
+
+          inventory_unit = inventory_units.detect { |iu| iu.variant_id.to_i == line_item.variant_id }
+
+          if inventory_unit.present?
+            inventory_unit.shipment = shipment
+            inventory_unit.state = 'on_hand'
+            inventory_unit.save!
+
+            # Don't assign shipments to this inventory unit more than once
+            inventory_units.delete(inventory_unit)
+          end
+        end
+
+        shipment.state      = 'ready'
+        shipment.save!
+
+        rate = shipment.shipping_rates.create!(shipping_method: channel_shipping_method, cost: 0.0)
+        shipment.selected_shipping_rate_id = rate.id
+
+        shipment.save!
+        shipment.update_amounts
+
+      rescue StandardError => e
+        SpreeTradebyte::TBLogger.debug("Something went wrong while creating tb shipment for order #{order_hash[:tb_id]}")
+        SpreeTradebyte::TBLogger.debug(e.message)
+        SpreeTradebyte::TBLogger.debug(e.backtrace.join("\n"))
+        ErrorNotificationMailer.exception_mail(e, order).deliver_now
+      end
+
+      def build_order_attributes(order_hash)
+        {
+            email: order_hash[:email],
+            line_items_attributes: order_hash[:line_items].map(&method(:build_line_item_attributes)).compact,
+            bill_address_attributes: build_address_attributes(order_hash[:bill_address]),
+            ship_address_attributes: build_address_attributes(order_hash[:ship_address])
+        }
+      end
+
+      def build_line_item_attributes(line_item_hash)
+        {
+            variant: Spree::Variant.find_by_sku(line_item_hash[:sku]),
+            quantity: line_item_hash[:quantity],
+            price: line_item_hash[:price],
+            tradebyte_item_id: line_item_hash[:tb_id],
+            tradebyte_sku: line_item_hash[:tradebyte_sku]
+        }
+      end
+
+      def build_address_attributes(address_hash)
+        {
+            firstname: address_hash[:firstname],
+            lastname: address_hash[:lastname],
+            address1: address_hash[:address1],
+            zipcode: address_hash[:zipcode],
+            city: address_hash[:city],
+            country: address_hash[:country],
+        }
+      end
+
+    end
+  end
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,5 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end
+

data/app/mailers/spree_tradebyte/error_notification_mailer.rb

@@ -0,0 +1,9 @@
+class SpreeTradebyte::ErrorNotificationMailer < ApplicationMailer
+
+  def exception_mail(exception, order = nil)
+    @exception = exception
+    @order = order
+    mail(to: SpreeTradebyte.admin_email, subject: 'SpreeTradebyte: Something went wrong')
+  end
+
+end

data/app/models/spree/order/mail_defuser.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Order::MailDefuser
+    def deliver_order_confirmation_email
+      unless is_tradebyte_order?
+        super
+      end
+    end
+
+    def send_cancel_email
+      unless is_tradebyte_order?
+        super
+      end
+    end
+  end
+end

data/app/models/spree/order/tradebyte_message_builder.rb

@@ -0,0 +1,133 @@
+module Spree
+  class Order < Spree::Base
+    module TradebyteMessageBuilder
+      extend ActiveSupport::Concern
+
+      def tb_send_confirm_messages
+        return unless is_tradebyte_order?
+        line_item_message = Nokogiri::XML::Builder.new do |xml|
+          xml.MESSAGES_LIST do
+            line_items.map {|li| tb_confirm_message(xml, li)}
+          end
+        end
+
+        ftp = tb_ftp
+        ftp.put_message_file(line_item_message.to_xml)
+        ftp.close
+      end
+
+      def tb_send_cancel_messages(comment = nil, line_items = self.line_items)
+        return unless is_tradebyte_order?
+        line_item_message = Nokogiri::XML::Builder.new do |xml|
+          xml.MESSAGES_LIST do
+            line_items.map {|li| tb_cancel_message(xml, li, comment)}
+          end
+        end
+
+        ftp = tb_ftp
+        ftp.put_message_file(line_item_message.to_xml)
+        ftp.close
+      end
+
+      def tb_send_no_stock_messages(line_items)
+        return unless is_tradebyte_order?
+        line_item_message = Nokogiri::XML::Builder.new do |xml|
+          xml.MESSAGES_LIST do
+            line_items.map {|li| tb_no_stock_message(xml, li)}
+          end
+        end
+
+        ftp = tb_ftp
+        ftp.put_message_file(line_item_message.to_xml)
+        ftp.close
+      end
+
+      def tb_send_shipped_messages(inventory_units)
+        return unless is_tradebyte_order?
+        inventory_unit_message = Nokogiri::XML::Builder.new do |xml|
+          xml.MESSAGES_LIST do
+            inventory_units.map {|iu| tb_shipped_message(xml, iu)}
+          end
+        end
+
+        ftp = tb_ftp
+        ftp.put_message_file(inventory_unit_message.to_xml)
+        ftp.close
+      end
+
+      def tb_send_return_messages(return_items)
+        return unless is_tradebyte_order?
+        return_item_message = Nokogiri::XML::Builder.new do |xml|
+          xml.MESSAGES_LIST do
+            return_items.map {|ri| tb_return_message(xml, ri)}
+          end
+        end
+
+        ftp = tb_ftp
+        ftp.put_message_file(return_item_message.to_xml)
+        ftp.close
+      end
+
+      private
+
+      def tb_ftp
+        SpreeTradebyte::TradebyteFTP.new(SpreeTradebyte.ftp_user, SpreeTradebyte.ftp_password, SpreeTradebyte.ftp_server, SpreeTradebyte.ftp_port)
+      end
+
+      def tb_confirm_message(xml, line_item)
+        xml.MESSAGE do
+          xml.MESSAGE_TYPE 'ORDER_ACKNOWLEDGE'
+          xml.TB_ORDER_ID line_item.order.tradebyte_id
+          xml.TB_ORDER_ITEM_ID line_item.tradebyte_item_id
+          xml.SKU line_item.tradebyte_sku
+          xml.QUANTITY line_item.quantity
+        end
+      end
+
+      def tb_cancel_message(xml, line_item, comment = 'Cancelled')
+        xml.MESSAGE do
+          xml.MESSAGE_TYPE 'CUST_CANCEL'
+          xml.TB_ORDER_ID line_item.order.tradebyte_id
+          xml.TB_ORDER_ITEM_ID line_item.tradebyte_item_id
+          xml.SKU line_item.tradebyte_sku
+          xml.QUANTITY line_item.quantity
+          xml.COMMENT comment
+        end
+      end
+
+      def tb_no_stock_message(xml, line_item)
+        xml.MESSAGE do
+          xml.MESSAGE_TYPE 'NO_INVENTORY'
+          xml.TB_ORDER_ID self.tradebyte_id
+          xml.TB_ORDER_ITEM_ID line_item.tradebyte_item_id
+          xml.SKU line_item.tradebyte_sku
+          xml.QUANTITY line_item.quantity
+        end
+      end
+
+      def tb_shipped_message(xml, inventory_unit)
+        xml.MESSAGE do
+          xml.MESSAGE_TYPE 'SHIP'
+          xml.TB_ORDER_ID self.tradebyte_id
+          xml.TB_ORDER_ITEM_ID inventory_unit.line_item.tradebyte_item_id
+          xml.SKU inventory_unit.line_item.tradebyte_sku
+          xml.QUANTITY inventory_unit.quantity
+          xml.CARRIER_PARCEL_TYPE inventory_unit.shipment.shipping_method.send(SpreeTradebyte.parcel_type_method)
+          xml.IDCODE inventory_unit.shipment.tracking
+        end
+      end
+
+      def tb_return_message(xml, return_item)
+        xml.MESSAGE do
+          xml.MESSAGE_TYPE 'RETURN'
+          xml.TB_ORDER_ID self.tradebyte_id
+          xml.TB_ORDER_ITEM_ID return_item.inventory_unit.line_item.tradebyte_item_id
+          xml.SKU return_item.inventory_unit.line_item.tradebyte_sku
+          xml.QUANTITY return_item.inventory_unit.quantity
+          xml.RETURN_CAUSE return_item.return_authorization.try(:return_authorization_reason).try(:name)
+        end
+      end
+
+    end
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,14 @@
+Spree::Order.class_eval do
+  include Spree::Order::TradebyteMessageBuilder
+
+  Spree::Order.state_machine.after_transition :to => :canceled, do: :cancel_tb_order
+
+  self.prepend(Spree::Order::MailDefuser)
+
+  private
+
+  def cancel_tb_order
+    tb_send_cancel_messages('The merchant cancelled the order')
+  end
+
+end