spree_batch_capture 0.1.0 → 0.1.1

data/app/models/order_export.rb

@@ -0,0 +1,7 @@
+require 'carrierwave/orm/activerecord'
+
+class OrderExport < ActiveRecord::Base
+
+  mount_uploader :exported_orders, ExportUploader
+  
+end

data/app/uploaders/export_uploader.rb

@@ -0,0 +1,5 @@
+require 'carrierwave'
+
+class ExportUploader < CarrierWave::Uploader::Base
+  #storage :fog
+end

data/config/initializers/carrierwave.rb

@@ -0,0 +1,8 @@
+require 'carrierwave'
+# Set carrierwave to file storage for testing.
+if Rails.env.test? || Rails.env.cucumber?
+  CarrierWave.configure do |config|
+    config.storage = :file
+    config.enable_processing = false
+  end
+end

data/db/migrate/20111207214102_create_order_exports.rb

@@ -0,0 +1,18 @@
+class CreateOrderExports < ActiveRecord::Migration
+  def self.up
+    create_table :order_exports do |t|
+      t.integer :user_id
+      t.datetime :requested_at
+      t.datetime :completed_at
+      t.integer :count_of_orders
+      t.string :exported_orders
+      t.string :export_errors
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :order_exports
+  end
+end

data/lib/spree_batch_capture/formatter/simple_csv.rb

@@ -0,0 +1,127 @@
+module SpreeBatchCapture::Formatter
+
+  class SimpleCsv
+
+    # Takes an order and returns 1 or more csv rows
+    def self.transform(order)
+      return "" if order.nil? || order.id.nil?
+
+      line_items = LineItem.includes(:order => [:ship_address, :bill_address], :variant => :product).where(:order_id => order.id)
+
+      content = ""
+      if line_items && line_items.count > 0
+        content = CSV.generate do |csv|
+
+          line_items.each do |line_item|
+            csv << values(line_item)
+          end
+        end
+      end
+      return content
+    end
+
+    def self.header(line_item)
+      head = []
+      sections.each do |section|
+        head << extract_field_names(section, line_item)
+      end
+      Rails.logger.debug "Exporting Header: #{head.flatten}:: #{head.flatten.to_csv}"
+      return head.flatten.to_csv
+    end
+
+
+    private
+
+    def self.order_fields(line_item)
+      return [
+        { "OrderNumber"   => line_item.order.number },
+        { "OrderTotal"    => line_item.order.total },
+        { "OrderState"    => line_item.order.state },
+        { "ShipmentState" => line_item.order.shipment_state },
+        { "PaymentState"  => line_item.order.payment_state },
+        { "EmailAddress"  => line_item.order.email }
+      ] 
+    end
+
+    def self.shipping_address_fields(line_item)
+      return address_for("Shipping", line_item.order.ship_address)
+    end
+
+    def self.billing_address_fields(line_item) 
+      return address_for("Billing", line_item.order.bill_address)
+    end
+
+    def self.address_for(prefix, address)
+      # In case an address doesn't exist, return nil values
+      address = Address.default if address.nil?
+      return [
+        { "#{prefix}FirstName" => address.firstname },
+        { "#{prefix}LastName"  => address.lastname },
+        { "#{prefix}Address1"  => address.address1 },
+        { "#{prefix}Address2"  => address.address2 },
+        { "#{prefix}City"      => address.city },
+        { "#{prefix}State"     => address.state_text },
+        { "#{prefix}ZipCode"   => address.zipcode },
+        { "#{prefix}Country"   => address.country.name }
+      ]
+    end
+
+    def self.product_fields(line_item)
+      return [{ "ProductName" => line_item.variant.product.name }]
+    end
+
+    def self.variant_fields(line_item)
+      return [
+        { "SKU" => line_item.variant.sku },
+        { "VariantWeight" => line_item.variant.weight },
+        { "VariantHeight" => line_item.variant.height },
+        { "VariantWidth"  => line_item.variant.width },
+        { "VariantDepth"  => line_item.variant.depth }
+      ]
+    end
+
+    def self.line_item_fields(line_item)
+      return [
+        { "Quantity"      => line_item.quantity },
+        { "LineItemPrice" => line_item.price }
+      ]
+
+    end
+
+    def self.sections
+      return [
+        :order_fields,
+        :shipping_address_fields,
+        :billing_address_fields,
+        :product_fields,
+        :variant_fields,
+        :line_item_fields
+      ]
+    end
+
+    def self.values(line_item)
+      values = []
+      sections.each do |section|
+        values << extract_field_values(section, line_item)
+      end
+      return values.flatten
+    end
+
+    def self.extract_field_names(section, line_item)
+      self.send(section, line_item).map{ |h| h.keys.first }
+    end
+
+    def self.extract_field_values(section, line_item)
+      self.send(section, line_item).map{ |h| h.values.first }
+    end
+
+    def self.value(section, key, line_item)
+      section_arr = self.send(section, line_item)
+      hash = section_arr.find{|h| h[key] != nil}
+
+      return hash.nil? ? nil : hash[key]
+    end
+
+  end
+
+end

data/lib/spree_batch_capture/scope_serializer.rb

@@ -0,0 +1,36 @@
+module SpreeBatchCapture
+  class ScopeSerializer
+
+    def self.from_scope(relation)
+      raise "Invalid scope" unless relation.kind_of? ActiveRecord::Relation
+      {
+        :where => relation.where_values,
+        :joins => relation.joins_values,
+        :order => relation.order_values,
+        :group => relation.group_values,
+        :limit => relation.limit_value,
+        :from  => relation.from_value,
+        :select => relation.select_values,
+        :includes => relation.includes_values,
+        :having => relation.having_values,
+        :offset_value => relation.offset_value,
+      }
+    end
+
+    def self.to_scope(scope_hash)
+      scope_hash.symbolize_keys!
+      return Order
+        .where(scope_hash[:where])
+        .joins(scope_hash[:joins])
+        .order(scope_hash[:order])
+        .group(scope_hash[:group])
+        .limit(scope_hash[:limit])
+        .from(scope_hash[:from])
+        .select(scope_hash[:select])
+        .includes(scope_hash[:includes])
+        .having(scope_hash[:having])
+        .offset(scope_hash[:offset])
+    end
+
+  end
+end

data/lib/spree_batch_capture/worker/capture.rb

@@ -7,7 +7,7 @@ module SpreeBatchCapture
       return true unless order.payment_state == "balance_due"
 
       if order.payments.nil? || ( order.payments && order.payments.empty? )
-        raise UnexpectedWorkerError.new "Attempted to capture an order without any payments."
+        raise Error::UnexpectedWorkerError.new "Attempted to capture an order without any payments."
       else 
 
         order.payments.each do |payment|

data/lib/spree_batch_capture/worker/export.rb

@@ -0,0 +1,182 @@
+require 'digest/sha1'
+require 'zip/zip'
+
+module SpreeBatchCapture
+  class Worker::Export < Worker::Base
+
+    # expected options:
+    # :orders
+    # :user_id
+    # :requested_at
+    # :mark_as_shipped (optional, defaults to false)
+    #
+    # :orders is a hash that can be any of the following
+    # {:scope => {:joins => [], :where => [], ...}  ## There is a helper for this (see self.from_scope and self.to_scope)
+    # {:orders => []} ## Array of ids
+    # {:where => []} ## Conditional where clause
+    # {:sql => "select * from orders"} ## Any valid sql
+    # If more than one key is specified, only the first will be used in the order above.
+    def self.run(options)
+      Rails.logger.debug "Starting Export Worker..."
+
+      orders = get_orders(options[:orders])
+
+      default_attrs = {
+        :requested_at => options[:requested_at],
+        :user_id => options[:user_id]
+      }
+
+      if orders && orders.count > 0
+        export_file = export(orders, Formatter::SimpleCsv)
+        Rails.logger.debug "Exported orders to #{export_file}"
+        begin
+          oe = OrderExport.create(default_attrs.merge({
+            :count_of_orders => orders.count
+          }))
+
+          if export_file
+            oe.exported_orders = File.open(export_file)
+          else
+            oe.export_errors = I18n.t(:unable_to_export)
+            oe.count_of_orders = 0
+          end
+
+          oe.completed_at = Time.now
+          oe.save!
+
+          options[:successful_orders] = orders.map(&:id) if options[:mark_as_shipped]
+
+        rescue => e
+          if oe
+            oe.count_of_orders = 0
+            oe.export_errors = I18n.t(:unable_to_export)
+            oe.completed_at = Time.now
+            oe.save!
+          end
+        ensure
+          Rails.logger.debug "DELETING FILE: #{export_file}"
+          FileUtils.rm(export_file) if export_file && File.exist?(export_file)
+        end
+
+      else
+        OrderExport.create(default_attrs.merge({
+          :count_of_orders => 0,
+          :export_errors => I18n.t(:no_orders_for_export)
+        }))
+
+      end
+
+      return true
+    end
+
+
+    def self.after_run(success, options)
+      if success && options[:mark_as_shipped]
+        options[:successful_orders].each do |order_id|
+          Worker::Ship.enqueue({ :order_id => order_id })
+        end
+      end
+      return true
+    end
+
+    # Gets the orders based on a set of params.
+    # see run for more information
+    def self.get_orders(order_criteria)
+      orders = []
+      order_criteria.symbolize_keys!
+      if order_criteria[:scope]
+        orders = ScopeSerializer.to_scope(order_criteria[:scope])
+      elsif order_criteria[:orders]
+        orders = Order.where("id in (?)", order_criteria[:orders])
+      elsif order_criteria[:where]
+        orders = Order.where(order_criteria[:where])
+      elsif order_criteria[:sql]
+        orders = Order.find_by_sql(order_criteria[:sql])
+      else
+        return false
+      end
+
+      return orders
+      
+    end
+
+    def self.worker_klass_name
+      return "Export"
+    end
+
+    def self.default_queue_name
+      return "export"
+    end
+
+
+    # Allows overriding of the default
+    # filename prefix. All filenames are as follows:
+    # prefix_sha1.csv[.gz]
+    def self.filename_prefix
+      "export"
+    end
+
+    # Temporary directory used for creating the export files. 
+    # Can be overridden to provide a custom path
+    def self.temp_directory
+      File.join(Rails.root.to_s, 'tmp', 'export')
+    end
+
+    private 
+
+    # Exports the orders and returns a file on the local filesystem.
+    # Requires a formatter such as SpreeBatchCapture::Formatter::SimpleCsv
+    # Accepts a zip flag to zip the file.
+    def self.export(orders, formatter, zip=true)
+      begin
+
+        Rails.logger.debug "Exporting file..."
+      
+        export_file = open_file(zip) do |f|
+          f.print formatter.header(orders.first.line_items.first)
+          orders.each do |order|
+            Rails.logger.debug "Exporting order: #{order.number}"
+            f.print formatter.transform(order)
+          end
+        end
+
+        Rails.logger.debug "Export completed successfully."
+        return export_file
+
+      rescue => e
+        Rails.logger.debug ("Export failed: #{e.message}")
+        return false
+      end
+
+    end
+
+    def self.open_file(zip)
+      base_dir = temp_directory
+      FileUtils.mkdir_p(base_dir)
+      base_filename = generate_file_name
+      filename = File.join(base_dir, base_filename)
+
+      if zip
+        zip_filename = filename.gsub("csv", "zip")
+        Zip::ZipFile.open(zip_filename, Zip::ZipFile::CREATE) do |zipfile|
+          zipfile.get_output_stream(base_filename) { |f| yield(f) }
+        end
+      else
+        File.open(filename, "w") do |f|
+          yield(f)
+        end
+      end
+
+      return zip ? zip_filename : filename
+    end
+
+    # Generates a unique filename which includes 
+    # the full path.
+    def self.generate_file_name
+      sha1 = Digest::SHA1.hexdigest "#{filename_prefix}::#{Time.now.to_i}::#{rand(100)}"
+      return "#{filename_prefix}_#{sha1[1..10]}.csv"
+    end
+
+
+  end
+end

data/lib/spree_batch_capture/worker/ship.rb

@@ -0,0 +1,52 @@
+class SpreeBatchCapture::Worker::Ship < SpreeBatchCapture::Worker::Base
+  
+  # expecting an order id like this:
+  # {:order => order_obj} 
+  # where order_obj is set in before_run from 
+  # {:order_id => 1}
+  def self.run(options)
+
+    order = options[:order]
+
+    result = false
+
+    if order && order.respond_to?(:fulfill)
+      result = order.fulfill
+    elsif order && order.shipments.count > 0
+      order.shipments.each do |shipment|
+        unless shipment.shipped?
+          result = shipment.ship!
+          if result
+            shipment.shipped_at = Time.now
+            shipment.save
+          end
+
+          break unless result # if something went wrong, don't try to continue
+        else
+          # already shipped so we'll just say we were successful.
+          result = true
+        end
+      end
+
+      order.update!
+
+    else
+      # Nothing to do so we'll just proceed as if everything was ok
+      result = true
+    end
+
+    return result
+  end
+
+  def self.before_run(options)
+    options[:order] = Order.find_by_id options[:order_id]
+  end
+
+  def self.worker_klass_name
+    return "Ship"
+  end
+
+  def self.default_queue_name
+    return "ship"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_batch_capture
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-05 00:00:00.000000000 Z
+date: 2011-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
-  requirement: &16020680 !ruby/object:Gem::Requirement
+  requirement: &6467000 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.60.4
   type: :runtime
   prerelease: false
-  version_requirements: *16020680
+  version_requirements: *6467000
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &16020220 !ruby/object:Gem::Requirement
+  requirement: &6466200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.19.0
   type: :runtime
   prerelease: false
-  version_requirements: *16020220
+  version_requirements: *6466200
 - !ruby/object:Gem::Dependency
   name: resque-lock
-  requirement: &16019760 !ruby/object:Gem::Requirement
+  requirement: &6464520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,25 +43,66 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *16019760
+  version_requirements: *6464520
+- !ruby/object:Gem::Dependency
+  name: carrierwave
+  requirement: &6462680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *6462680
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &6461280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *6461280
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: &6459040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *6459040
 description: Adds batch processing to Spree. Includes batch capture and batch export
   of orders.
-email: ''
+email: mike.farmer@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- app/uploaders/export_uploader.rb
+- app/models/order_export.rb
 - config/routes.rb
+- config/initializers/carrierwave.rb
 - lib/spree_batch_capture_hooks.rb
 - lib/tasks/install.rake
 - lib/tasks/spree_batch_capture.rake
 - lib/spree_batch_capture/worker/bogus.rb
+- lib/spree_batch_capture/worker/export.rb
 - lib/spree_batch_capture/worker/capture.rb
 - lib/spree_batch_capture/worker/base.rb
+- lib/spree_batch_capture/worker/ship.rb
+- lib/spree_batch_capture/formatter/simple_csv.rb
 - lib/spree_batch_capture/error.rb
+- lib/spree_batch_capture/scope_serializer.rb
 - lib/spree_batch_capture.rb
 - db/migrate/20111129223646_add_last_processing_error_to_payments.rb
-homepage: http://vitrue.com
+- db/migrate/20111207214102_create_order_exports.rb
+homepage: http://github.com/vitrue/spree_batch_capture
 licenses: []
 post_install_message: 
 rdoc_options: []