sparkpost_rails_eu 1.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 389e52647f591e59d115e55cf157c1bcb65a44edaf351d027e69f6526d3d3c98
+  data.tar.gz: 8ca903cf8d6f5bc6b82c95d7b54844c497588e3ada33ffa512901a4b5abb7b37
+SHA512:
+  metadata.gz: 5e79ba82eb5d9cd19cd8bd4b37ef86d48128c8c6b6e99239def3e889a68c38e070107d4b6855076da07a519581fbcd099628b7ff47316ed0e4144b37f1f0e797
+  data.tar.gz: e875f7e1ca1c8b755cd28a00f6e54fbcd55aa32ae15b83d5144f23e3937d8c24f4593fc6c8043d3f4d4e9287bc5dbbd25ab904cd1ae810bd26b35d6a858d5b88

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kevin Kimball
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,230 @@
+[![Gem Version](https://badge.fury.io/rb/sparkpost_rails.svg)](https://badge.fury.io/rb/sparkpost_rails)
+[![Build Status](https://travis-ci.org/the-refinery/sparkpost_rails.svg?branch=master)](https://travis-ci.org/the-refinery/sparkpost_rails)
+
+SparkPost Rails
+===============
+
+This gem provides seamless integration of SparkPost with ActionMailer. It provides a `delivery_method` based upon the SparkPost API, and makes getting setup and sending email via SparkPost in a Rails app pretty painless.
+
+Getting Started
+---------------
+
+Add the gem to your Gemfile
+
+```ruby
+gem 'sparkpost_rails'
+```
+
+Then run the bundle command to install it.
+
+By default, the gem will look for your SparkPost API key in your environment, with the key `SPARKPOST_API_KEY`.  You can override this setting by identifying a different key in the initializer (`config/initializers/sparkpost_rails.rb`):
+
+```ruby
+SparkPostRails.configure do |c|
+  c.api_key = 'YOUR API KEY'
+end
+```
+Note that an initializer file is not required to use this gem. If an initializer is not provided, default values will be used. See ["Additional Configuration"](#additional-configuration) below for a list of all the default settings.
+
+In each environment configuration file from which you want to send emails via Sparkpost, (i.e. `config/environments/production.rb`) add
+
+```ruby
+config.action_mailer.delivery_method = :sparkpost
+```
+
+Additional Configuration
+------------------------
+You can establish values for a number of SparkPost settings in the initializer. These values will be used for every message sent from your application. You can override these settings on individual messages.
+
+```ruby
+SparkPostRails.configure do |c|
+  c.sandbox = true                                # default: false
+  c.track_opens = true                            # default: false
+  c.track_clicks = true                           # default: false
+  c.return_path = 'BOUNCE-EMAIL@YOUR-DOMAIN.COM'  # default: nil
+  c.campaign_id = 'YOUR-CAMPAIGN'                 # default: nil
+  c.transactional = true                          # default: false
+  c.ip_pool = "MY-POOL"                           # default: nil
+  c.inline_css = true                             # default: false
+  c.html_content_only = true                      # default: false
+  c.subaccount = "123"                            # default: nil
+end
+```
+
+Usage
+-----
+When calling the `deliver!` method on the mail object returned from your mailer, `SparkPostRails` provides the response data directly back from SparkPost as a hash.
+
+```ruby
+result = MyMailer.welcome_message(user).deliver!
+```
+
+Example:
+
+```ruby
+{
+  "total_rejected_recipients" => 0, 
+  "total_accepted_recipients" => 1, 
+  "id" => "00000000000000"
+}
+```
+
+If the SparkPost API reponds with an error condition, SparkPostRails will raise a `SparkPostRails::DeliveryException`, which will include all the message data returned by the API.
+
+SparkPostRails will support multiple recipients, multilple CC, multiple BCC, ReplyTo address, file attachments, inline images, multi-part (HTML and plaintext) messages - all utilizing the standard `ActionMailer` methodologies.
+
+Handling Errors
+---------------
+If you are using `ActiveJob` and wish to do something special when the SparkPost API responds with an error condition you can do so by rescuing these exceptions via `ActionMailer::DeliveryJob`. Simply add an initializer:
+
+`config/initializers/action_mailer.rb`
+
+```ruby
+ActionMailer::DeliveryJob.rescue_from(SparkPostRails::DeliveryException) do |exception|
+  # do something special with the error
+end
+```
+
+SparkPost-Specific Features
+---------------------------
+
+### Configuration Settings
+You can specifiy values for any or all of the configuration settings listed above on an individual message. Simply add a hash of these values to the mail message in a field named `sparkpost_data`:
+
+```ruby
+data = { 
+  track_opens: true,
+  track_clicks: false,
+  campaign_id: "My Campaign",
+  transactional: true,
+  ip_pool = "SPECIAL_POOL",
+  api_key = "MESSAGE_SPECIFIC_API_KEY"
+  subaccount = "123"
+}
+
+mail(to: to_email, subject: "Test", body: "test", sparkpost_data: data)
+```
+
+Additionally, `return_path` can be overriden on a specific email by setting that field on the mail message itself:
+
+```ruby
+mail(to: to_email, subject: "Test", body: "test", return_path: "bounces@example.com")
+```
+
+### Transmission Specific Settings
+
+For an individual transmisison you can specifiy that SparkPost should ignore customer supression rules - if your SparkPost account allows for this feature. Simply include the flag in the `sparkpost_data` field on the message:
+
+```ruby
+data = { skip_suppression: true }
+
+mail(to: to_email, subject: "Test", body: "test", sparkpost_data: data)
+```
+
+To schedule the generation of messages for a future date and time, specify a start time in the `date` parameter of the mail. The `date` must be in the future and less than 1 year from today. If `date` is in the past or too far in the future, no date will be passed, and no delivery schedule will be set.
+
+```ruby
+start_time = DateTime.now + 4.hours 
+
+mail(to: to_email, subject: "Test", body: "test", date: start_time)
+```
+
+You can set a `description` for a transmission via the `sparkpost_data` as well. The maximum length of the `decription` is 1024 characters - values longer than the maxium will be truncated.
+
+```ruby
+data = { description: "My Important Message" }
+
+mail(to: to_email, subject: "Test", body: "test", sparkpost_data: data)
+```
+
+By default, content from single-part messages is sent at plain-text. If you are only intending to send HTML email, with no plain-text part, you can specify this as shown below. You can also set this in the configuration to ensure that all single-part emails are sent as HTML.
+
+```ruby
+data = { html_content_only: true }
+
+mail(to: to_email, subject: "Test", body: "<h1>test</h1>", sparkpost_data: data)
+```
+
+### Subaccounts
+
+SparkPostRails supports sending messages via subaccounts in two ways. The default API key set in the configuration can be overriden on a message-by-message basis with a subaccount API key.
+
+```ruby
+data = { api_key: "SUBACCOUNT_API_KEY" }
+
+mail(subject: "Test", body: "test", sparkpost_data: data)
+```
+
+Subaccounts can also be leveraged using the subaccount ID with the master API key.
+
+```ruby
+data = { subaccount: "123" }
+
+mail(subject: "Test", body: "test", sparkpost_data: data)
+```
+
+### Recipient Lists
+SparkPostRails supports using SparkPost stored recipient lists. Simply add the `list_id` to the `sparkpost_data` hash on the mail message:
+
+```ruby
+data = { recipient_list_id: "MY-LIST"}
+
+mail(subject: "Test", body: "test", sparkpost_data: data)
+```
+
+**NOTE**: If you supply a recipient `list_id`, all `To:`, `CC:`, and `BCC:` data specified on the mail message will be ignored. The SparkPost API does not support utilizing both a recipient list and inline recipients.
+
+
+### Substitution Data
+You can leverage SparkPost's substitution engine through the gem as well. To supply substitution data, simply add your hash of substitution data to your `sparkpost_data` hash, with the key `substitution_data`.
+
+```ruby
+sub_data = {
+  first_name: "Sam",
+  last_name: "Test
+}
+
+data = { substitution_data: sub_data }
+
+mail(to: to_email, subject: "Test", body: "test", sparkpost_data: data)
+```
+
+### Recipient-Specific Data
+When sending to multiple recipients, you can pass an array of data to complement each recipient. Simply pass an array called `recipients` containing an array of the additional data (e.g. `substitution_data`).
+
+```ruby
+recipients = ['recipient1@email.com', 'recipient2@email.com']
+sparkpost_data = {
+  recipients: [
+    { substitution_data: { name: 'Recipient1' } },
+    { substitution_data: { name: 'Recipient2' } }
+  ]
+}
+mail(to: recipients, sparkpost_data: sparkpost_data)
+```
+
+
+### Using SparkPost Templates
+You can leverage SparkPost's powerful templates rather than building ActionMailer views using SparkPostRails. Add your `template_id` to the `sparkpost_data` hash. By default, `ActionMailer` finds a template to use within views. A workaround to prevent this default action is to explicitly pass a block with an empty `text` part:
+
+```ruby
+data = { template_id: "MY-TEMPLATE" }
+
+mail(to: to_email, sparkpost_data: data) do |format|
+  format.text { render text: "" }
+end
+```
+
+**NOTE**: All inline-content that may exist in your mail message will be ignored, as the SparkPost API does not accept that data when a template id is supplied. This includes `Subject`, `From`, `ReplyTo`, Attachments, and Inline Images.
+
+###Other Mail Headers
+If you need to identify custom mail headers for your messages, use the `ActionMailer` `header[]` method. The gem will pass all approprite headers through to the API. Note, per the SparkPost API documentation
+
+> Headers such as 'Content-Type' and 'Content-Transfer-Encoding' are not allowed here as they are auto-generated upon construction of the email.
+
+```ruby
+headers["Priority"] = "urgent"
+headers["Sensitivity"] = "private"
+
+mail(to: to_email, subject: "Test", body: "test")
+```

data/lib/sparkpost_rails.rb

@@ -0,0 +1,64 @@
+require "sparkpost_rails/data_options"
+require "sparkpost_rails/delivery_method"
+require "sparkpost_rails/exceptions"
+require "sparkpost_rails/railtie"
+
+module SparkPostRails
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :api_key
+    attr_accessor :sandbox
+
+    attr_accessor :track_opens
+    attr_accessor :track_clicks
+
+    attr_accessor :campaign_id
+    attr_accessor :return_path
+
+    attr_accessor :transactional
+    attr_accessor :ip_pool
+    attr_accessor :inline_css
+    attr_accessor :html_content_only
+
+    attr_accessor :subaccount
+
+    def initialize
+      set_defaults
+    end
+
+    def set_defaults
+      if ENV.has_key?("SPARKPOST_API_KEY")
+        @api_key = ENV["SPARKPOST_API_KEY"]
+      else
+        @api_key = ""
+      end
+
+      @sandbox = false
+
+      @track_opens = false
+      @track_clicks = false
+
+      @campaign_id = nil
+      @return_path = nil
+
+      @transactional = false
+      @ip_pool = nil
+      @inline_css = false
+      @html_content_only = false
+
+      @subaccount = nil
+    end
+  end
+end

data/lib/sparkpost_rails/data_options.rb

@@ -0,0 +1,25 @@
+module SparkPostRails
+    module DataOptions
+
+      def self.included(base)
+        base.class_eval do
+          prepend InstanceMethods
+        end
+      end
+
+      module InstanceMethods
+
+        def mail(headers={}, &block)
+          headers = headers.clone
+          sparkpost_data = headers.delete(:sparkpost_data)
+          sparkpost_data ||= {}
+          super(headers, &block).tap do |message|
+            message.singleton_class.class_eval { attr_accessor "sparkpost_data" }
+            message.sparkpost_data = sparkpost_data
+          end
+        end
+
+      end
+
+  end
+end

data/lib/sparkpost_rails/delivery_method.rb

@@ -0,0 +1,402 @@
+module SparkPostRails
+  class DeliveryMethod
+    require 'net/http'
+
+    attr_accessor :settings, :data, :response, :headers
+
+    def initialize(options = {})
+      @settings = options
+    end
+
+    def deliver!(mail)
+      @data = {content: {}}
+
+      sparkpost_data = find_sparkpost_data_from mail
+
+      prepare_recipients_from mail, sparkpost_data
+      prepare_recipients_data_from sparkpost_data
+
+      if sparkpost_data.has_key?(:template_id)
+        prepare_template_content_from sparkpost_data
+      else
+        prepare_from_address_from mail
+        prepare_reply_to_address_from mail
+
+        prepare_subject_from mail
+        prepare_cc_headers_from mail, sparkpost_data
+        prepare_inline_content_from mail, sparkpost_data
+        prepare_attachments_from mail
+      end
+
+      prepare_substitution_data_from sparkpost_data
+      prepare_metadata_from sparkpost_data
+      prepare_description_from sparkpost_data
+      prepare_options_from mail, sparkpost_data
+      prepare_additional_mail_headers_from mail
+
+      prepare_api_headers_from sparkpost_data
+
+      result = post_to_api
+
+      process_result result
+    end
+
+  private
+    def find_sparkpost_data_from mail
+      mail.sparkpost_data
+    end
+
+    def prepare_recipients_from mail, sparkpost_data
+      if sparkpost_data.has_key?(:recipient_list_id)
+        @data[:recipients] = {list_id: sparkpost_data[:recipient_list_id]}
+      else
+        @data[:recipients] = prepare_addresses(mail.to, mail[:to].display_names)
+
+        if !mail.cc.nil?
+          @data[:recipients] += prepare_copy_addresses(mail.cc, mail[:cc].display_names, mail.to.first).flatten
+        end
+
+        if !mail.bcc.nil?
+          @data[:recipients] += prepare_copy_addresses(mail.bcc, mail[:bcc].display_names, mail.to.first).flatten
+        end
+      end
+
+    end
+
+    def prepare_addresses emails, names
+      emails = [emails] unless emails.is_a?(Array)
+      header_to = emails.join(",")
+      emails.each_with_index.map {|email, index| prepare_address(email, index, names, header_to) }
+    end
+
+    def prepare_address email, index, names, header_to
+      if !names[index].nil?
+        { address:  { email: email, name: names[index], header_to: header_to } }
+      else
+        { address: { email: email, header_to: header_to } }
+      end
+    end
+
+    def prepare_copy_addresses emails, names, header_to
+      emails = [emails] unless emails.is_a?(Array)
+      emails.each_with_index.map {|email, index| prepare_copy_address(email, index, names, header_to) }
+    end
+
+    def prepare_copy_address email, index, names, header_to
+      if !names[index].nil? && !header_to.nil?
+        { address:  { email: email, name: names[index], header_to: header_to } }
+      elsif !names[index].nil?
+        { address:  { email: email, name: names[index] } }
+      elsif !header_to.nil?
+        { address: { email: email, header_to: header_to } }
+      else
+        { address: { email: email } }
+      end
+    end
+
+    # See https://developers.sparkpost.com/api/#/introduction/substitutions-reference/links-and-substitution-expressions-within-substitution-values
+    def prepare_recipients_data_from sparkpost_data
+      if (recipients_data = sparkpost_data[:recipients])
+        @data[:recipients].each_with_index do |recipient, index|
+          if (recipient_data = recipients_data[index])
+            recipient.merge!(recipient_data)
+          end
+        end
+      end
+    end
+
+    def prepare_template_content_from sparkpost_data
+      @data[:content][:template_id] = sparkpost_data[:template_id]
+
+    end
+
+    def prepare_substitution_data_from sparkpost_data
+      if sparkpost_data[:substitution_data]
+        @data[:substitution_data] = sparkpost_data[:substitution_data]
+      end
+    end
+
+    def prepare_metadata_from sparkpost_data
+      if sparkpost_data[:metadata]
+        @data[:metadata] = sparkpost_data[:metadata]
+      end
+    end
+
+    def prepare_from_address_from mail
+      if !mail[:from].display_names.first.nil?
+        from = { email: mail.from.first, name: mail[:from].display_names.first }
+      else
+        from = { email: mail.from.first }
+      end
+
+      @data[:content][:from] = from
+    end
+
+    def prepare_reply_to_address_from mail
+      unless mail.reply_to.nil?
+        @data[:content][:reply_to] = mail.reply_to.first
+      end
+    end
+
+    def prepare_subject_from mail
+      @data[:content][:subject] = mail.subject
+    end
+
+    def prepare_cc_headers_from mail, sparkpost_data
+      if !mail[:cc].nil? && !sparkpost_data.has_key?(:recipient_list_id)
+        copies = prepare_addresses(mail.cc, mail[:cc].display_names)
+        emails = []
+
+        copies.each do |copy|
+          emails << copy[:address][:email]
+        end
+
+        @data[:content][:headers] = { cc: emails.join(",") }
+      end
+    end
+
+    def prepare_inline_content_from mail, sparkpost_data
+      if mail.multipart?
+        if mail.html_part
+          @data[:content][:html] = cleanse_encoding(mail.html_part.body.to_s)
+        end
+
+        if mail.text_part
+          @data[:content][:text] = cleanse_encoding(mail.text_part.body.to_s)
+        end
+      else
+        if SparkPostRails.configuration.html_content_only || sparkpost_data[:html_content_only]
+          @data[:content][:html] = cleanse_encoding(mail.body.to_s)
+        else
+          @data[:content][:text] = cleanse_encoding(mail.body.to_s)
+        end
+      end
+    end
+
+    def cleanse_encoding content
+      ::JSON.parse({c: content}.to_json)["c"]
+    end
+
+    def prepare_attachments_from mail
+      attachments = Array.new
+      inline_images = Array.new
+
+      mail.attachments.each do |attachment|
+        #We decode and reencode here to ensure that attachments are
+        #Base64 encoded without line breaks as required by the API.
+        attachment_data = { name: attachment.inline? ? attachment.cid : attachment.filename,
+                            type: attachment.content_type,
+                            data: Base64.strict_encode64(attachment.body.decoded) }
+
+        if attachment.inline?
+          inline_images << attachment_data
+        else
+          attachments << attachment_data
+        end
+      end
+
+      if attachments.count > 0
+        @data[:content][:attachments] = attachments
+      end
+
+      if inline_images.count > 0
+        @data[:content][:inline_images] = inline_images
+      end
+    end
+
+    def prepare_options_from mail, sparkpost_data
+      @data[:options] = Hash.new
+
+      prepare_sandbox_mode_from sparkpost_data
+      prepare_open_tracking_from sparkpost_data
+      prepare_click_tracking_from sparkpost_data
+      prepare_campaign_id_from sparkpost_data
+      prepare_return_path_from mail
+      prepare_transactional_from sparkpost_data
+      prepare_skip_suppression_from sparkpost_data
+      prepare_ip_pool_from sparkpost_data
+      prepare_inline_css_from sparkpost_data
+      prepare_delivery_schedule_from mail
+    end
+
+    def prepare_sandbox_mode_from sparkpost_data
+      if SparkPostRails.configuration.sandbox
+        @data[:options][:sandbox] = true
+      end
+
+      if sparkpost_data.has_key?(:sandbox)
+        if sparkpost_data[:sandbox]
+          @data[:options][:sandbox] = sparkpost_data[:sandbox]
+        else
+          @data[:options].delete(:sandbox)
+        end
+      end
+    end
+
+    def prepare_open_tracking_from sparkpost_data
+      @data[:options][:open_tracking] = SparkPostRails.configuration.track_opens
+
+      if sparkpost_data.has_key?(:track_opens)
+        @data[:options][:open_tracking] = sparkpost_data[:track_opens]
+      end
+    end
+
+    def prepare_click_tracking_from sparkpost_data
+      @data[:options][:click_tracking] = SparkPostRails.configuration.track_clicks
+
+      if sparkpost_data.has_key?(:track_clicks)
+        @data[:options][:click_tracking] = sparkpost_data[:track_clicks]
+      end
+    end
+
+    def prepare_campaign_id_from sparkpost_data
+      campaign_id = SparkPostRails.configuration.campaign_id
+
+      if sparkpost_data.has_key?(:campaign_id)
+        campaign_id = sparkpost_data[:campaign_id]
+      end
+
+      if campaign_id
+        @data[:campaign_id] = campaign_id
+      end
+    end
+
+    def prepare_return_path_from mail
+      return_path = SparkPostRails.configuration.return_path
+
+      unless mail.return_path.nil?
+        return_path = mail.return_path
+      end
+
+      if return_path
+        @data[:return_path] = return_path
+      end
+    end
+
+    def prepare_transactional_from sparkpost_data
+      @data[:options][:transactional] = SparkPostRails.configuration.transactional
+
+      if sparkpost_data.has_key?(:transactional)
+        @data[:options][:transactional] = sparkpost_data[:transactional]
+      end
+    end
+
+
+    def prepare_skip_suppression_from sparkpost_data
+      if sparkpost_data[:skip_suppression]
+        @data[:options][:skip_suppression] = sparkpost_data[:skip_suppression]
+      end
+    end
+
+    def prepare_description_from sparkpost_data
+      if sparkpost_data[:description]
+        @data[:description] = sparkpost_data[:description].truncate(1024)
+      end
+    end
+
+    def prepare_ip_pool_from sparkpost_data
+      ip_pool = SparkPostRails.configuration.ip_pool
+
+      if sparkpost_data.has_key?(:ip_pool)
+        ip_pool = sparkpost_data[:ip_pool]
+      end
+
+      if ip_pool
+        @data[:options][:ip_pool] = ip_pool
+      end
+    end
+
+    def prepare_inline_css_from sparkpost_data
+      @data[:options][:inline_css] = SparkPostRails.configuration.inline_css
+
+      if sparkpost_data.has_key?(:inline_css)
+        @data[:options][:inline_css] = sparkpost_data[:inline_css]
+      end
+    end
+
+    def prepare_delivery_schedule_from mail
+      # Format YYYY-MM-DDTHH:MM:SS+-HH:MM or "now". Example: '2015-02-11T08:00:00-04:00'. -From SparkPost API Docs
+      if mail.date && (mail.date > DateTime.now) && (mail.date < (DateTime.now + 1.year))
+        @data[:options][:start_time] = mail.date.strftime("%Y-%m-%dT%H:%M:%S%:z")
+      end
+    end
+
+    def prepare_additional_mail_headers_from mail
+      valid_headers = Hash.new
+
+      invalid_names = ["sparkpost-data",
+                       "from",
+                       "to",
+                       "cc",
+                       "bcc",
+                       "subject",
+                       "reply-to",
+                       "return-path",
+                       "date",
+                       "mime-version",
+                       "content-type",
+                       "content-transfer-encoding",
+                       "text-part"]
+
+      mail.header.fields.each do |field|
+        unless invalid_names.include?(field.name.downcase)
+          valid_headers[field.name] = field.value
+        end
+      end
+
+      if valid_headers.count > 0
+        unless @data[:content].has_key?(:headers)
+          @data[:content][:headers] = Hash.new
+        end
+
+        @data[:content][:headers].merge!(valid_headers)
+      end
+    end
+
+    def prepare_api_headers_from sparkpost_data
+      if sparkpost_data.has_key?(:api_key)
+        api_key = sparkpost_data[:api_key]
+      else
+        api_key = SparkPostRails.configuration.api_key
+      end
+
+      @headers = {
+        "Authorization" => api_key,
+        "Content-Type"  => "application/json"
+      }
+
+      if sparkpost_data.has_key?(:subaccount)
+        subaccount = sparkpost_data[:subaccount]
+      else
+        subaccount = SparkPostRails.configuration.subaccount
+      end
+
+      if subaccount
+        @headers["X-MSYS-SUBACCOUNT"] = subaccount.to_s
+      end
+    end
+
+    def post_to_api
+      url = "https://api.eu.sparkpost.com/api/v1/transmissions"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = Net::HTTP::Post.new(uri.path, @headers)
+      request.body = JSON.generate(@data)
+      http.request(request)
+    end
+
+    def process_result result
+      result_data = JSON.parse(result.body)
+
+      if result_data["errors"]
+        @response = result_data["errors"]
+        raise SparkPostRails::DeliveryException, @response
+      else
+        @response = result_data["results"]
+      end
+    end
+  end
+end