spree_bronto 3.pre.0.pre.stable

data/config/bronto.yml

@@ -0,0 +1,39 @@
+# Be sure to restart your server when you modify this file.
+
+# three bronto accounts are configured here with identity of the store code.
+
+disable_cart_recovery: false
+# if this option is false, the tagkey must be present in your yaml file
+
+handle_asynchronously: true
+# if this option is true, delayed_job must be configured.
+
+default:
+   token: YOUR_BRONTO_TOKEN_TO_ACCESS_API
+   from_name: EMAIL_FROM NAME
+   tagkey: YOUR_BRONTO_CART_RECOVERY_KEY_IF_CART_RECOVERY_IS_ENABLED
+   order_shipped: EMAIL_API_ID_FOR_ORDER_SHIPPED_NOTIFICATION
+   order_received: EMAIL_API_ID_FOR_ORDER_CONFIRMATION
+   new_account: EMAIL_API_ID_FOR_ACCOUNT_CREATED
+   password_reset: EMAIL_API_ID_FOR_PASSWORD_RESET
+   order_canceled: EMAIL_API_ID_FOR_ORDER_CANCELED
+
+store_a_code:
+   token: YOUR_BRONTO_TOKEN_TO_ACCESS_API
+   from_name: EMAIL_FROM NAME
+   tagkey: YOUR_BRONTO_CART_RECOVERY_KEY_IF_CART_RECOVERY_IS_ENABLED
+   order_shipped: EMAIL_API_ID_FOR_ORDER_SHIPPED_NOTIFICATION
+   order_received: EMAIL_API_ID_FOR_ORDER_CONFIRMATION
+   new_account: EMAIL_API_ID_FOR_ACCOUNT_CREATED
+   password_reset: EMAIL_API_ID_FOR_PASSWORD_RESET
+   order_canceled: EMAIL_API_ID_FOR_ORDER_CANCELED
+
+store_b_code:
+   token: YOUR_BRONTO_TOKEN_TO_ACCESS_API
+   from_name: EMAIL_FROM NAME
+   tagkey: YOUR_BRONTO_CART_RECOVERY_KEY_IF_CART_RECOVERY_IS_ENABLED
+   order_shipped: EMAIL_API_ID_FOR_ORDER_SHIPPED_NOTIFICATION
+   order_received: EMAIL_API_ID_FOR_ORDER_CONFIRMATION
+   new_account: EMAIL_API_ID_FOR_ACCOUNT_CREATED
+   password_reset: EMAIL_API_ID_FOR_PASSWORD_RESET
+   order_canceled: EMAIL_API_ID_FOR_ORDER_CANCELED

data/config/locales/en.yml

@@ -0,0 +1,27 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See https://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+ spree:
+  subscription_sent: Signed up
+  subscription_notsent: Singup failed
+  bronto:
+    lists_admin: Bronto Lists
+    manage_settings: Manage Bronto mailing lists made available to Spree users
+    new_list: New List
+    lists: Bronto Lists
+    list_id: Bronto List ID
+    subscribe_all_new_users: Subscribe all new users
+    title: Display Name
+    editing: Editing Bronto List
+    retrieve_from_bronto: Retrieve from Bronto
+    slow_warning: This can be slow depending on the number of items defined.
+    only_list_can_subscribe_all: Only one list can be set to subscribe all new users at a time.
+    validate_unique: is already registered to another list
+    visible: Visible
+    my_newsletters: My Newsletters
+    update_subscriptions: Update Subscriptions
+    subscribed: Subscribed?
+    subscribe_question: Would you like to subscribe to any of our newsletters?
+    store_id: Web Store
+    no_such_list: This newsletter does not exist

data/config/routes.rb

@@ -0,0 +1,19 @@
+Spree::Core::Engine.routes.append do
+  namespace :admin do
+    resources :bronto_lists do
+      collection do
+         get 'get_lists'
+      end
+    end
+  end
+
+  resources :orders, :except => [:index, :new, :create, :destroy] do
+    patch :subscribe, :on => :member
+  end
+
+  post "/subscribenewsletter", :to => 'home#subscribenewsletter'
+  post "/subscribecampaign", :to => 'home#subscribecampaign'
+  post "/subscribecampaign_with_ops", :to => 'home#subscribecampaign_with_ops'
+
+end
+

data/db/migrate/20150427135748_spree_bronto_lists_users.rb

@@ -0,0 +1,12 @@
+class SpreeBrontoListsUsers < ActiveRecord::Migration
+  def self.up
+    create_table :spree_bronto_lists_users, :id => false do |t|
+      t.references :user
+      t.references :bronto_list
+      t.timestamps
+    end
+  end
+
+  def self.down
+  end
+end

data/db/migrate/20150427135923_create_spree_bronto_lists.rb

@@ -0,0 +1,16 @@
+class CreateSpreeBrontoLists < ActiveRecord::Migration
+  def self.up
+    create_table :spree_bronto_lists do |t|
+      t.string :list_id
+      t.string :title
+      t.boolean :subscribe_all_new_users, :default => false
+      t.boolean :visible, :default => true
+      t.integer :store_id
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :spree_bronto_lists
+  end
+end

data/lib/bronto_integration/bronto.rb

@@ -0,0 +1,255 @@
+require 'savon'
+
+class Bronto
+  attr_reader :client, :token
+
+  class ValidationError < StandardError; end
+
+  # NOTE Try building a response object?
+
+  def initialize(token)
+    @token = token
+    @client = Savon.client(
+        ssl_verify_mode: :none,
+        wsdl: 'https://api.bronto.com/v4?wsdl',
+        log_level: :debug,
+        log: true,
+        namespace_identifier: :v4,
+        env_namespace: :soapenv
+    )
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/add/addorupdateorders
+  def add_or_update_orders(data)
+    response = client.call(
+        :add_or_update_orders,
+        soap_header: soup_header,
+        message: { :orders => data }
+    )
+
+    result = get_results response.body[:add_or_update_orders_response]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/add/addorupdatecontacts
+  #
+  # Successful example:
+  #
+  #   {:id=>"ac41a110-bd21-4bf6-b061-625dfa428a27", :is_new=>true, :is_error=>false, :error_code=>"0"}
+  #
+  # Error example:
+  #   
+  #   {:is_error=>true, :error_code=>"319", :error_string=>"Invalid mobile number: 86 9999-6666"}
+  #
+  def add_or_update_contacts(data)
+    response = client.call(
+        :add_or_update_contacts,
+        soap_header: soup_header,
+        message: { :contacts => data }
+    )
+
+    result = get_results response.body[:add_or_update_contacts_response]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  def read_contacts(email)
+    response = client.call(
+        :read_contacts,
+        soap_header: soup_header,
+        message: {
+            :filter => [:email => { :operator => 'EqualTo', :value => email }],
+            :includeLists => false,
+            :fields => 'id',
+            :pageNumber => 1,
+            :includeSMSKeywords => false,
+            :includeGeoIPData => false,
+            :includeTechnologyData => false,
+            :includeRFMData => false
+        }
+    )
+
+    response.body[:read_contacts_response][:return]
+  end
+
+  def update_contacts(data)
+    response = client.call(
+        :update_contacts,
+        soap_header: soup_header,
+        message: { :contacts => data }
+    )
+
+    result = get_results response.body[:update_contacts_response]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  def read_fields(name)
+    response = client.call(
+        :read_fields,
+        soap_header: soup_header,
+        message: {
+            filter: {
+                name: { operator: 'EqualTo', value: name }
+            }
+        }
+    )
+
+    response.body[:read_fields_response][:return]
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/read/readmessages
+  def read_messages(message_name)
+    if !! message_name
+      filter= {
+          :name =>  [{ operator: 'EqualTo', :value => message_name }]
+      }
+    else
+      filter= {}
+    end
+
+    response = client.call(
+        :read_messages,
+        soap_header: soup_header,
+        message: {
+            :filter => filter,
+            includeContent: false,
+            pageNumber: 1
+        })
+
+    result = response.body[:read_messages_response][:return]
+
+    if result.blank? || result[:id].blank?
+      raise Bronto::ValidationError, "Couldn't find the message template for \"#{message_name}\""
+    end
+
+    result
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/add/adddeliveries
+  def add_deliveries(data)
+    response = client.call(
+        :add_deliveries,
+        soap_header: soup_header,
+        message: { deliveries: data }
+    )
+
+    result = get_results response.body[:add_deliveries_response]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/add/addtolist
+  def add_to_list(list_name, contact_email)
+    response = client.call(
+        :add_to_list,
+        soap_header: soup_header,
+        message: {
+            list: {
+                name: list_name
+            },
+            contacts: {
+                email: contact_email
+            }
+        }
+    )
+
+    result = response.body[:add_to_list_response][:return][:results]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/miscellaneous/removefromlist
+  def remove_from_list(list_name, contact_email)
+    response = client.call(
+        :remove_from_list,
+        soap_header: soup_header,
+        message: {
+            list: { name: list_name },
+            contacts: {
+                email: contact_email
+            }
+        }
+    )
+
+    result = response.body[:remove_from_list_response][:return][:results]
+
+    if result[:is_error]
+      raise ValidationError, "(Error Code: #{result[:error_code]}) #{result[:error_string]}"
+    else
+      result
+    end
+  end
+
+  # Ref: http://dev.bronto.com/api/v4/functions/read/readlists
+  def read_lists
+    response = client.call(
+        :read_lists,
+        soap_header: soup_header,
+        message: { :filter => {} }
+    )
+
+    lists = response.body[:read_lists_response][:return]
+
+    if lists.is_a? Hash
+      [lists]
+    else
+      lists
+    end
+  end
+
+  def read_list_by_name(list_name)
+
+    filter={name: [{ operator: 'EqualTo', :value =>list_name }]  }
+    response = client.call(
+        :read_lists,
+        soap_header: soup_header,
+        message: { :filter => filter, :pageNumber=>1 }
+    )
+
+    lists = response.body[:read_lists_response][:return]
+
+    if lists.is_a? Hash
+      [lists]
+    else
+      lists
+    end
+  end
+
+  private
+  def session_id
+    return @session_id if @session_id
+
+    login_response = @client.call(:login, message: { :api_token => token })
+    @session_id = login_response.body[:login_response][:return]
+  end
+
+  def soup_header
+    { 'v4:sessionHeader' => { :session_id => session_id } }
+  end
+
+  def get_results(body)
+    body[:return][:results]
+  end
+end

data/lib/bronto_integration/bronto_integration/communication.rb

@@ -0,0 +1,83 @@
+module BrontoIntegration
+  class Communication
+    attr_reader :token, :bronto_client
+
+    def initialize(token, client = nil)
+      @token = token
+      @bronto_client = client || Bronto.new(token)
+    end
+
+    def add_to_list(list_name,email)
+      Contact.new(token, bronto_client).find_or_create email
+
+      if list_name.is_a? Array
+        list_name.each do |list|
+          bronto_client.add_to_list list, email
+        end
+      else
+        bronto_client.add_to_list list_name, email
+      end
+    end
+
+    def remove_from_list(list_name,email)
+      if list_name.is_a? Array
+        list_name.each do |list|
+          bronto_client.remove_from_list list, email
+        end
+      else
+        bronto_client.remove_from_list list_name, email
+      end
+    end
+
+    def remove_from_all_lists(lists, email)
+      lists = bronto_client.read_lists
+      lists.map { |l| bronto_client.remove_from_list l[:name], email }
+    end
+
+    def trigger_delivery(message_name,recipient_email,delivery_type,mail_type,variables_payload, mail_options)
+      bronto_client.add_deliveries(mail_options.merge build(message_name,recipient_email,delivery_type,mail_type,variables_payload))
+    end
+
+    def trigger_delivery_by_id(message_id,recipient_email,delivery_type,mail_type,variables_payload, mail_options)
+      bronto_client.add_deliveries(mail_options.merge build_with_id(message_id,recipient_email,delivery_type,mail_type,variables_payload))
+    end
+
+    def message_id(message_name)
+      message = bronto_client.read_messages message_name
+      message[:id]
+    end
+
+    def contact_id(recipient_email)
+      contact = Contact.new(token, bronto_client)
+      contact.get_id_by_email recipient_email
+    end
+
+    def build(message_name,recipient_email,delivery_type,mail_type,variables_payload={})   # default to triggered
+      {
+          start: Time.new().iso8601(),
+          messageId: message_id(message_name),
+          type: delivery_type || 'triggered',
+          recipients: [
+          { id: contact_id(recipient_email), type: 'contact' }
+      ],
+          fields: variables_payload.map do |key, value|
+        { name: key.to_s, type: mail_type || 'html', content: value.to_s }
+      end
+      }
+    end
+
+    def build_with_id(message_api_id,recipient_email,delivery_type,mail_type,variables_payload={})   # default to triggered
+      {
+          start: Time.new().iso8601(),
+          messageId: message_api_id,
+          type: delivery_type || 'triggered',
+          recipients: [
+              { id: contact_id(recipient_email), type: 'contact' }
+          ],
+          fields: variables_payload.map do |key, value|
+            { name: key.to_s, type: mail_type || 'html', content: value.to_s }
+          end
+      }
+    end
+  end
+end

data/lib/bronto_integration/bronto_integration/contact.rb

@@ -0,0 +1,53 @@
+module BrontoIntegration
+  class Contact
+
+    attr_reader :token, :bronto_client
+
+    def initialize(token,  client = nil)
+      @token=token
+      @bronto_client = client || Bronto.new(token)
+    end
+
+    def get_id_by_email(email)
+      unless contact = bronto_client.read_contacts(email)
+        contact = bronto_client.add_or_update_contacts({ email: email })
+      end
+
+      contact[:id]
+    end
+
+    alias :find_or_create :get_id_by_email
+
+    def set_up(email,fields)
+      bronto_client.add_or_update_contacts build(email,fields)
+    end
+
+    def update_status(email,status)
+      bronto_client.update_contacts({:email => email, :status => status})
+    end
+
+    def build(email,fields)
+      {
+          :email => email,
+          :fields => fields(fields).reject{|f| f[:fieldId]==nil}          #delete the non-exist fields
+      }
+    end
+
+    def fields(fields)
+      fields = (fields || []).map do |key, value|
+        {
+            :fieldId => get_field_id(key.to_s),
+            :content => value.to_s
+        }
+      end
+    end
+
+    def get_field_id(name)
+      # use cache to reduce the field id query
+      Rails.cache.fetch("bronto_field_#{@token}_#{name}", :expires_in => 15.hours) {
+      result = bronto_client.read_fields name
+      result[:id] if result.is_a? Hash
+      }
+    end
+  end
+end

data/lib/bronto_integration/bronto_integration/order.rb

@@ -0,0 +1,44 @@
+module BrontoIntegration
+  class Order
+    attr_reader :token, :bronto_client
+    def initialize(token)         # let's use order object from spree 0.11 at this moment
+      @bronto_client = Bronto.new(token)
+      @token=token
+    end
+
+    def build(order)
+      {
+          :id => order.number,
+          :email => order.checkout.email,
+          :contactId => contact_id(order.checkout.email),
+          :products => line_items(order.line_items),
+          :orderDate => order.completed_at.iso8601()
+      }
+    end
+
+    def create_or_update(order)
+      bronto_client.add_or_update_orders build(order)
+    end
+
+    def line_items(line_items)
+      line_items.inject([]) do |items, item|
+        items << {
+            :id => item.variant_id,
+            :sku => item.variant.sku,
+            :name => ERB::Util.html_escape(item.product.name.gsub!(/[^0-9A-Za-z]/, ' ')),      # some product may have special characot in name
+            :quantity => item.quantity,
+            :price => item.price#,
+            #:url => 'http://www.' + item.product.store.name + '/products/' + item.product.permalink,
+            #:image => 'http://dt1l4oh2o5aei.cloudfront.net/attachments/' + item.product.images.first.id.to_s + '/product.jpg'
+        }
+
+        items
+      end
+    end
+
+    def contact_id(recipient_email)
+      contact = Contact.new(token, bronto_client)
+      contact.get_id_by_email recipient_email
+    end
+  end
+end

data/lib/bronto_integration/bronto_integration.rb

@@ -0,0 +1,6 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'bronto'
+require 'bronto_integration/order'
+require 'bronto_integration/contact'
+require 'bronto_integration/communication'

data/lib/delayed_send.rb

@@ -0,0 +1,40 @@
+DelayedSend = Struct.new(:store_code, :email, :message_name, :order_id, :plain_view, :html_view) do
+  def perform
+    return if email.blank?
+    #store_code ||= 'default'
+    order = Spree::Order.find(order_id)
+    token= Spree::BrontoConfiguration.account[store_code]['token']
+    from_email= order.store.mail_from_address
+    from_name= Spree::BrontoConfiguration.account[store_code]['from_name']
+    reply_email= order.store.mail_from_address
+    email_options={:fromEmail =>from_email,:fromName => from_name, :replyEmail => reply_email}
+
+
+    view = ActionView::Base.new(Rails::Application::Configuration.new(Rails.root).paths["app/mailers/spree"])
+    view.view_paths<<File.join(File.dirname(__FILE__), '../app/mailers/spree')
+
+    attributes = {:First_Name => order.bill_address.firstname,
+                 :Last_name => order.bill_address.lastname}
+
+    attributes[:SENDTIME__CONTENT1] = view.render(plain_view, :order => order) unless plain_view.nil?
+    attributes[:SENDTIME__CONTENT2] = (view.render(html_view, :order => order)).gsub(/\n/,'').html_safe unless html_view.nil?
+
+    begin
+      communication = BrontoIntegration::Communication.new(token)
+      communication.trigger_delivery_by_id(message_name,email,'transactional','html',attributes,email_options)
+
+    rescue => exception
+      begin    #handle the transactional contact in case the message is not approved for transactional.
+        contact = BrontoIntegration::Contact.new(token)
+        contact.update_status(email,'active')
+        communication.trigger_delivery_by_id(message_name,email,'triggered','html',attributes,email_options)
+      rescue => exception
+        raise exception
+      end
+    end
+  end
+
+  if Spree::BrontoConfiguration.account['handle_asynchronously']
+     handle_asynchronously :perform, :priority => 20
+  end
+end

data/lib/delayed_simple_send.rb

@@ -0,0 +1,17 @@
+DelayedSimpleSend = Struct.new(:store_code, :email, :message_name, :attributes, :mail_type) do
+  def perform
+    return if email.blank?
+    begin
+      token= Spree::BrontoConfiguration.account[store_code]['token']
+      from_email= order.store.mail_from_address
+      from_name= Spree::BrontoConfiguration.account[store_code]['from_name']
+      reply_email= order.store.mail_from_address
+
+      email_options={:fromEmail =>from_email,:fromName => from_name, :replyEmail => reply_email}
+      communication = BrontoIntegration::Communication.new(token)
+      communication.trigger_delivery_by_id(message_name,email,'triggered',mail_type||'html',attributes||{},email_options)
+    rescue => exception
+      #raise exception   # as now only campaign use this and their templates may not be approved. let it go.
+    end
+  end
+end

data/lib/delayed_subscriber_add.rb

@@ -0,0 +1,38 @@
+DelayedSubscriberAdd = Struct.new(:store_code, :user, :list, :ops) do
+  def perform
+
+    if list.nil? || !user
+      subscriber_id = -1
+    else
+      begin
+        token= Spree::BrontoConfiguration.account[store_code]['token']
+        if user.is_a? String
+          email=user
+        else
+          email=user.email
+        end
+
+        contact = BrontoIntegration::Contact.new(token)
+        contacts=contact.set_up(email,ops||{})
+        subscriber_id= contacts[:id]
+
+        communication = BrontoIntegration::Communication.new(token)
+        communication.add_to_list(list.title,email)
+
+      rescue => exception
+          subscriber_id = -1
+          #raise exception
+      end
+    end
+
+    #unless user.is_a? String
+    #  begin
+    #  user.bronto_lists << list
+    #  user.save!
+    #  rescue
+    #  end
+    #end
+
+
+  end
+end

data/lib/delayed_subscriber_delete.rb

@@ -0,0 +1,35 @@
+DelayedSubscriberDelete = Struct.new(:store_code, :user, :list) do
+  def perform
+    if list.nil? || !user
+      subscriber_id = -1
+    else
+      begin
+        token= Spree::BrontoConfiguration.account[store_code]['token']
+        if user.is_a? String
+          email=user
+        else
+          email=user.email
+        end
+        unless email.empty?
+        communication = BrontoIntegration::Communication.new(token)
+        communication.remove_from_list(list.title,email)
+        end
+      rescue => exception
+        #raise exception
+      end
+    end
+
+    #unless user.is_a? String    # update  exact_target_lists
+    #  begin
+    #    list_del=user.bronto_lists.select{|l| l.id== list.id}
+    #    if list_del.length>0
+    #      user.bronto_lists.delete(list_del)
+    #    end
+    #    user.save!
+    #  rescue
+    #    #raise exception
+    #  end
+    #end
+
+  end
+end