solidus_mailchimp_sync 1.0.0.beta01

data/app/serializers/solidus_mailchimp_sync/product_serializer.rb

@@ -0,0 +1,44 @@
+require 'json'
+
+module SolidusMailchimpSync
+  # Intentionally does not sync images, let variants do that.
+  #
+  class ProductSerializer
+    attr_reader :product
+
+    def initialize(product)
+      @product = product
+      unless product.persisted?
+        raise ArgumentError, "Can't serialize a non-saved product: #{product}"
+      end
+    end
+
+    # We don't include image or url, variants can have those anyway,
+    # and variants are actually editable, do it there.
+    def as_json
+      hash = {
+        id: product.id.to_s,
+        handle: product.slug,
+        title: product.name,
+        description: product.description,
+        variants: variants_json
+      }
+
+      if product.available_on
+        hash[:published_at_foreign] = product.available_on.iso8601
+      end
+
+      hash
+    end
+
+    def variants_json
+      product.variants_including_master.collect do |variant|
+        VariantSynchronizer.new(variant).serializer.as_json
+      end
+    end
+
+    def to_json
+      JSON.dump(as_json)
+    end
+  end
+end

data/app/serializers/solidus_mailchimp_sync/variant_serializer.rb

@@ -0,0 +1,59 @@
+require 'json'
+
+module SolidusMailchimpSync
+  class VariantSerializer
+    attr_reader :variant
+
+    def initialize(variant)
+      @variant = variant
+      unless variant.persisted?
+        raise ArgumentError, "Can't serialize a non-saved variant: #{variant}"
+      end
+    end
+
+    def as_json
+      hash = {
+        id: variant.id.to_s,
+        title: title,
+        sku: variant.sku,
+        price: variant.price.to_f,
+        # visibility is a string
+        visibility: (visibility || '').to_s
+      }
+
+      url = self.url
+      hash[:url] = url if url
+
+      image_url = self.image_url
+      hash[:image_url] = image_url if image_url
+
+      hash
+    end
+
+    def to_json
+      JSON.dump(as_json)
+    end
+
+    def title
+      [variant.product.name, variant.options_text].delete_if { |a| a.blank? }.join(' ')
+    end
+
+    # Override in custom serializer for custom front-end url
+    def url
+      if Rails.application.routes.default_url_options[:host] && Spree::Core::Engine.routes.url_helpers.respond_to?(:product_url)
+        Spree::Core::Engine.routes.url_helpers.product_url(variant.product, host: Rails.application.routes.default_url_options[:host])
+      end
+    end
+
+    # Override in custom serializer if you want to choose which image different than `first`
+    def image_url
+      (variant.images.first || variant.product.images.first).try(:url)
+    end
+
+    # Override for custom visibility. Mailchimp wants a string for some reason,
+    # not entirely sure what the string should be.
+    def visibility
+      variant.product.available?.to_s
+    end
+  end
+end

data/app/solidus_decorators/spree/image_decorator.rb

@@ -0,0 +1,16 @@
+Spree::Image.class_eval do
+  after_commit :mailchimp_sync
+
+  private
+  def mailchimp_sync
+    if self.viewable && self.viewable.is_a?(Spree::Variant)
+      if self.viewable.is_master?
+        # Need to sync all variants.
+        SolidusMailchimpSync::ProductSynchronizer.new(self.viewable.product).auto_sync(force: true)
+      else
+        # image just on this variant, just need to sync this one.
+        SolidusMailchimpSync::VariantSynchronizer.new(self.variant).auto_sync(force: true)
+      end
+    end
+  end
+end

data/app/solidus_decorators/spree/line_item_decorator.rb

@@ -0,0 +1,8 @@
+Spree::LineItem.class_eval do
+  after_commit :mailchimp_sync
+
+  def mailchimp_sync
+    # If a LineItem changes, tell the order to Sync for sure.
+    SolidusMailchimpSync::OrderSynchronizer.new(order).auto_sync(force: true)
+  end
+end

data/app/solidus_decorators/spree/order_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Order.class_eval do
+  after_commit :mailchimp_sync
+
+  private
+  def mailchimp_sync
+    SolidusMailchimpSync::OrderSynchronizer.new(self).auto_sync
+  end
+end

data/app/solidus_decorators/spree/price_decorator.rb

@@ -0,0 +1,10 @@
+Spree::Price.class_eval do
+  after_commit :mailchimp_sync
+
+  private
+  def mailchimp_sync
+    if self.variant
+      SolidusMailchimpSync::VariantSynchronizer.new(self.variant).auto_sync(force: true)
+    end
+  end
+end

data/app/solidus_decorators/spree/product_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Product.class_eval do
+  after_commit :mailchimp_sync
+
+  private
+  def mailchimp_sync
+    SolidusMailchimpSync::ProductSynchronizer.new(self).auto_sync
+  end
+end

data/app/solidus_decorators/spree/user_decorator.rb

@@ -0,0 +1,10 @@
+if Spree.user_class
+  Spree.user_class.class_eval do
+    after_commit :mailchimp_sync
+
+    private
+    def mailchimp_sync
+      SolidusMailchimpSync::UserSynchronizer.new(self).auto_sync
+    end
+  end
+end

data/app/solidus_decorators/spree/variant_decorator.rb

@@ -0,0 +1,8 @@
+Spree::Variant.class_eval do
+  after_commit :mailchimp_sync
+
+  private
+  def mailchimp_sync
+    SolidusMailchimpSync::VariantSynchronizer.new(self).auto_sync
+  end
+end

data/app/synchronizers/solidus_mailchimp_sync/base_synchronizer.rb

@@ -0,0 +1,74 @@
+module SolidusMailchimpSync
+  # Individual synchronizers will implement a #sync method, which will be run
+  # under an ActiveJob so won't have access to previous state.
+  #
+  # Individual synchornizers also set serializer_class_name, and synced_attributes,
+  # and override #path with Mailchimp API path.  May also override other methods.
+  class BaseSynchronizer
+    class_attribute :synced_attributes
+    class_attribute :serializer_class_name
+
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def path
+      raise TypeError, "Sub-class of BaseSynchronizer must implement #path with Solidus ecommerce API path"
+    end
+
+    # Designed to be called in an after commit hook, syncs in bg, if
+    # neccessary.
+    def auto_sync(force: false)
+      if SolidusMailchimpSync.auto_sync_enabled && (force || should_sync?)
+        SolidusMailchimpSync::SyncJob.perform_later(self.class.name, model)
+      end
+    end
+
+    # in an after-commit situation, we can tell new record from id changed
+    def was_newly_inserted?
+      pk_changed = model.previous_changes[model.class.primary_key]
+
+      pk_changed && pk_changed.first.nil? && pk_changed.second.present?
+    end
+
+    def should_sync?
+      was_newly_inserted? || synced_attributes_changed?
+    end
+
+    # This gets a lot harder when associations are involved, haven't completely solved it.
+    def synced_attributes_changed?
+      (model.previous_changes.keys & synced_attributes).present?
+    end
+
+    def put(arg_path = path)
+      Mailchimp.ecommerce_request(:put, arg_path, body: serializer.as_json)
+    end
+
+    def delete(arg_path = path, return_errors: false, ignore_404: false)
+      Mailchimp.ecommerce_request(:delete, arg_path, return_errors: return_errors)
+    rescue SolidusMailchimpSync::Error => e
+      if ignore_404 && e.status == 404
+        return nil
+      end
+      raise e
+    end
+
+    def post(arg_create_path = create_path)
+      Mailchimp.ecommerce_request(:post, arg_create_path, body: serializer.as_json)
+    end
+
+    def get(arg_path = path)
+      Mailchimp.ecommerce_request(:get, arg_path, body: serializer.as_json)
+    end
+
+    def patch(arg_path = path)
+      Mailchimp.ecommerce_request(:patch, arg_path, body: serializer.as_json)
+    end
+
+    def serializer
+      @serializer ||= serializer_class_name.constantize.new(model)
+    end
+  end
+end

data/app/synchronizers/solidus_mailchimp_sync/order_synchronizer.rb

@@ -0,0 +1,108 @@
+module SolidusMailchimpSync
+  # Syncs solidus orders to mailchimp Carts and Orders, adding/deleting
+  # as cart status changes.
+  class OrderSynchronizer < BaseSynchronizer
+    self.serializer_class_name = "::SolidusMailchimpSync::OrderSerializer"
+    # We update on all state changes, even though some might not really
+    # require a mailchimp sync, it just depends on what we're serializing.
+    # Also, when solidus sets completed_at, it seems not to trigger
+    # an after_commit, so we can't catch transition to complete that way.
+    #
+    # We used to update on changes to any totals thinking we could catch
+    # line item changes that way -- but removing a line item and adding
+    # another with the exact same price wouldn't trigger total changes, so
+    # we had to trap all line item changes instead on a LineItem decorator,
+    # so sync'ing on changes to order totals isn't neccesary just causes
+    # extra superfluous syncs.
+    self.synced_attributes = %w{state}
+
+    class_attribute :line_item_serializer_class_name
+    self.line_item_serializer_class_name = "::SolidusMailchimpSync::LineItemSerializer"
+
+    def path
+      if order_complete?
+        order_path
+      else
+        cart_path
+      end
+    end
+
+    def create_path
+      if order_complete?
+        create_order_path
+      else
+        create_cart_path
+      end
+    end
+
+    def sync
+      # If we don't have a user with an email address we can't sync -- mailchimp
+      # carts and orders require a customer, which requires an email address.
+      unless model.user.present? && model.user.send(UserSynchronizer.email_address_attribute).present?
+        return nil
+      end
+
+      # Can't sync an empty cart to mailchimp, delete the cart/order if
+      # we've previously synced, and bail out of this sync.
+      if model.line_items.empty?
+        return delete(path, ignore_404: true)
+      end
+
+      # if it's a completed order, delete any previous synced _cart_ version
+      # of this order, if one is present. There should be no Mailchimp 'cart',
+      # only a mailchimp 'order' now.
+      #byebug
+      if order_complete?
+        delete(cart_path, ignore_404: true)
+      end
+
+      post_or_patch(post_path: create_path, patch_path: path)
+    rescue SolidusMailchimpSync::Error => e
+      tries ||= 0 ; tries += 1
+      if tries <= 1 && user_not_synced_error?(e)
+        SolidusMailchimpSync::UserSynchronizer.new(model.user).sync
+        retry
+      else
+        raise e
+      end
+    end
+
+    def order_complete?
+      # Yes, somehow solidus can sometimes, temporarily, in our after commit hook
+      # have state==complete set, but not completed_at
+      model.completed? || model.state == "complete"
+    end
+
+    def post_or_patch(post_path:, patch_path:)
+      post(post_path)
+    rescue SolidusMailchimpSync::Error => e
+      if e.status == 400 && e.detail =~ /already exists/
+        patch(patch_path)
+      else
+        raise e
+      end
+    end
+
+    def user_not_synced_error?(e)
+      e.status == 400 &&
+        e.response_hash["errors"].present? &&
+        e.response_hash["errors"].any? { |h| %w{customer.email_address customer.opt_in_status}.include? h["field"] }
+    end
+
+    def cart_path
+      "/carts/#{model.id}"
+    end
+
+    def create_cart_path
+      "/carts"
+    end
+
+    def order_path
+      "/orders/#{model.id}"
+    end
+
+    def create_order_path
+      "/orders"
+    end
+  end
+end

data/app/synchronizers/solidus_mailchimp_sync/product_synchronizer.rb

@@ -0,0 +1,32 @@
+module SolidusMailchimpSync
+  class ProductSynchronizer < BaseSynchronizer
+    self.serializer_class_name = "::SolidusMailchimpSync::ProductSerializer"
+    self.synced_attributes = %w{name description slug available_on}
+
+    def sync
+      # We go ahead and try to create it. If it already existed, mailchimp
+      # doesn't let us do an update, but we can update all variants.
+      post
+    rescue SolidusMailchimpSync::Error => e
+      if e.status == 400 && e.detail =~ /already exists/
+        sync_all_variants
+      else
+        raise e
+      end
+    end
+
+    def path
+      "/products/#{product_id}"
+    end
+
+    def create_path
+      "/products"
+    end
+
+    def sync_all_variants
+      model.variants_including_master.collect do |variant|
+        VariantSynchronizer.new(variant).sync
+      end
+    end
+  end
+end

data/app/synchronizers/solidus_mailchimp_sync/user_synchronizer.rb

@@ -0,0 +1,44 @@
+require 'cgi'
+
+module SolidusMailchimpSync
+  class UserSynchronizer < BaseSynchronizer
+    self.serializer_class_name = "::SolidusMailchimpSync::CustomerSerializer"
+    self.synced_attributes = ['email']
+
+    class_attribute :email_address_attribute
+    self.email_address_attribute = :email
+
+    # synchronizers local user to Mailchimp customer. Whether Customer
+    # already existed on mailchimp end or not. Deletes if deleted.
+    def sync
+      if model.send(email_address_attribute).blank?
+        # can't sync a user without an email address, mailchimp doesn't allow it
+        return nil
+      end
+
+      if model.deleted?
+        delete
+      else
+        put
+      end
+    end
+
+    def path
+      "/customers/#{CGI.escape mailchimp_id}"
+    end
+
+    def mailchimp_id
+      self.class.customer_id(model)
+    end
+
+    # ID used to identify a user on mailchimp. Mailchimp does not
+    # allow ID's to change, even though we do, so care is needed.
+    # '@' sign in ID seems to maybe confuse mailchimp.
+    def self.customer_id(user)
+      email = user.send(email_address_attribute)
+      email = email && email.gsub("@", "-at-")
+      "#{user.id}-#{email}"
+    end
+
+  end
+end