postmark 1.8.1 → 1.21.3

data/RELEASE.md

@@ -0,0 +1,12 @@
+New versions of the gem are cut by the Postmark team, this is a quick guide to ensuring a smooth release.
+
+1. Verify all builds are passing on Travis for your branch.
+1. Merge in your branch to master.
+1. Update VERSION and lib/postmark/version.rb with the new version.
+1. Update CHANGELOG.rdoc with a brief description of the changes.
+1. Commit to git with a comment of "Bump version to x.y.z".
+1. run `rake release` - This will push to github(with the version tag) and rubygems with the version in lib/postmark/version.rb.
+  *Note that if you're on Bundler 1.17 there's a bug that hides the prompt for your OTP. If it hangs after adding the tag then it's asking for your OTP, enter your OTP and press Enter. Bundler 2.x and beyond resolved this issue. *
+1. Verify the new version is on [github](https://github.com/wildbit/postmark-gem) and [rubygems](https://rubygems.org/gems/postmark).
+1. Create a new release for the version on [Github releases](https://github.com/wildbit/postmark-gem/releases).
+1. Add or update any related content to the [wiki](https://github.com/wildbit/postmark-gem/wiki).

data/VERSION

@@ -1 +1 @@
-1.8.1
+1.21.3

data/gemfiles/Gemfile.legacy

@@ -6,11 +6,12 @@ gem 'rake', '< 11.0.0'
 gem 'json', '< 2.0.0'
 
 group :test do
-  gem 'rspec', '~> 2.14.0'
-  gem 'fakeweb'
+  gem 'rspec', '~> 3.7'
+  gem 'rspec-its', '~> 1.2'
+  gem 'fakeweb', :git => 'https://github.com/chrisk/fakeweb.git'
   gem 'fakeweb-matcher'
   gem 'mime-types', '~> 1.25.1'
   gem 'activesupport', '~> 3.2.0'
   gem 'i18n', '~> 0.6.0'
-  gem 'yajl-ruby', '~> 1.0', :platforms => [:mingw, :mswin, :ruby]
-end
+  gem 'yajl-ruby', '~> 1.0', '< 1.4.0', :platforms => [:mingw, :mswin, :ruby]
+end

data/lib/postmark.rb

@@ -10,6 +10,7 @@ require 'postmark/mail_message_converter'
 require 'postmark/bounce'
 require 'postmark/inbound'
 require 'postmark/json'
+require 'postmark/error'
 require 'postmark/http_client'
 require 'postmark/client'
 require 'postmark/api_client'
@@ -18,24 +19,6 @@ require 'postmark/message_extensions/mail'
 require 'postmark/handlers/mail'
 
 module Postmark
-
-  class DeliveryError < StandardError
-    attr_accessor :error_code, :full_response
-
-    def initialize(message = nil, error_code = nil, full_response = nil)
-      super(message)
-      self.error_code = error_code
-      self.full_response = full_response
-    end
-  end
-
-  class UnknownError        < DeliveryError; end
-  class InvalidApiKeyError  < DeliveryError; end
-  class InvalidMessageError < DeliveryError; end
-  class InternalServerError < DeliveryError; end
-  class UnknownMessageType  < DeliveryError; end
-  class TimeoutError        < DeliveryError; end
-
   module ResponseParsers
     autoload :Json,          'postmark/response_parsers/json'
     autoload :ActiveSupport, 'postmark/response_parsers/active_support'

data/lib/postmark/account_api_client.rb

@@ -61,6 +61,54 @@ module Postmark
     end
     alias_method :delete_signature, :delete_sender
 
+    def domains(options = {})
+      find_each('domains', 'Domains', options)
+    end
+
+    def get_domains(options = {})
+      load_batch('domains', 'Domains', options).last
+    end
+
+    def get_domains_count(options = {})
+      get_resource_count('domains', options)
+    end
+
+    def get_domain(id)
+      format_response http_client.get("domains/#{id.to_i}")
+    end
+
+    def create_domain(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.post('domains', data)
+    end
+
+    def update_domain(id, attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.put("domains/#{id.to_i}", data)
+    end
+
+    def verify_domain_dkim(id)
+      format_response http_client.put("domains/#{id.to_i}/verifydkim")
+    end
+
+    def verify_domain_return_path(id)
+      format_response http_client.put("domains/#{id.to_i}/verifyreturnpath")
+    end
+
+    def verified_domain_spf?(id)
+      !!http_client.post("domains/#{id.to_i}/verifyspf")['SPFVerified']
+    end
+
+    def rotate_domain_dkim(id)
+      format_response http_client.post("domains/#{id.to_i}/rotatedkim")
+    end
+
+    def delete_domain(id)
+      format_response http_client.delete("domains/#{id.to_i}")
+    end
+
     def servers(options = {})
       find_each('servers', 'Servers', options)
     end
@@ -91,6 +139,12 @@ module Postmark
       format_response http_client.delete("servers/#{id.to_i}")
     end
 
+    def push_templates(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+      _, batch = format_batch_response(http_client.put('templates/push', data), "Templates")
+      batch
+    end
+
   end
 
-end
+end

data/lib/postmark/api_client.rb

@@ -27,6 +27,11 @@ module Postmark
     end
 
     def deliver_message(message)
+      if message.templated?
+        raise ArgumentError,
+              "Please use #{self.class}#deliver_message_with_template to deliver messages with templates."
+      end
+
       data = serialize(message.to_postmark_hash)
 
       with_retries do
@@ -37,7 +42,26 @@ module Postmark
       end
     end
 
+    def deliver_message_with_template(message)
+      raise ArgumentError, 'Templated delivery requested, but the template is missing.' unless message.templated?
+
+      data = serialize(message.to_postmark_hash)
+
+      with_retries do
+        response, error = take_response_of { http_client.post("email/withTemplate", data) }
+        update_message(message, response)
+        raise error if error
+        format_response(response, true)
+      end
+    end
+
     def deliver_messages(messages)
+      if messages.any? { |m| m.templated? }
+        raise ArgumentError,
+              "Some of the provided messages have templates. Please use " \
+              "#{self.class}#deliver_messages_with_templates to deliver those."
+      end
+
       in_batches(messages) do |batch, offset|
         data = serialize(batch.map { |m| m.to_postmark_hash })
 
@@ -51,6 +75,24 @@ module Postmark
       end
     end
 
+    def deliver_messages_with_templates(messages)
+      unless messages.all? { |m| m.templated? }
+        raise ArgumentError, 'Templated delivery requested, but one or more messages lack templates.'
+      end
+
+      in_batches(messages) do |batch, offset|
+        data = serialize(batch.map { |m| m.to_postmark_hash })
+
+        with_retries do
+          http_client.post("email/batchWithTemplates", data).tap do |response|
+            response.each_with_index do |r, i|
+              update_message(messages[offset + i], r)
+            end
+          end
+        end
+      end
+    end
+
     def delivery_stats
       response = format_response(http_client.get("deliverystats"), true)
 
@@ -93,10 +135,6 @@ module Postmark
       batch
     end
 
-    def get_bounced_tags
-      http_client.get("bounces/tags")
-    end
-
     def get_bounce(id)
       format_response http_client.get("bounces/#{id}")
     end
@@ -113,23 +151,44 @@ module Postmark
       find_each('messages/outbound/opens', 'Opens', options)
     end
 
+    def clicks(options = {})
+      find_each('messages/outbound/clicks', 'Clicks', options)
+    end
+
     def get_opens(options = {})
       _, batch = load_batch('messages/outbound/opens', 'Opens', options)
       batch
     end
 
-    def get_opens_by_message_id(message_id, options ={})
+    def get_clicks(options = {})
+      _, batch = load_batch('messages/outbound/clicks', 'Clicks', options)
+      batch
+    end
+
+    def get_opens_by_message_id(message_id, options = {})
       _, batch = load_batch("messages/outbound/opens/#{message_id}",
                             'Opens',
                             options)
       batch
     end
 
+    def get_clicks_by_message_id(message_id, options = {})
+      _, batch = load_batch("messages/outbound/clicks/#{message_id}",
+                            'Clicks',
+                            options)
+      batch
+    end
+
     def opens_by_message_id(message_id, options = {})
       find_each("messages/outbound/opens/#{message_id}", 'Opens', options)
     end
 
+    def clicks_by_message_id(message_id, options = {})
+      find_each("messages/outbound/clicks/#{message_id}", 'Clicks', options)
+    end
+
     def create_trigger(type, options)
+      type = Postmark::Inflector.to_postmark(type).downcase
       data = serialize(HashHelper.to_postmark(options))
       format_response http_client.post("triggers/#{type}", data)
     end
@@ -138,22 +197,20 @@ module Postmark
       format_response http_client.get("triggers/#{type}/#{id}")
     end
 
-    def update_trigger(type, id, options)
-      data = serialize(HashHelper.to_postmark(options))
-      format_response http_client.put("triggers/#{type}/#{id}", data)
-    end
-
     def delete_trigger(type, id)
+      type = Postmark::Inflector.to_postmark(type).downcase
       format_response http_client.delete("triggers/#{type}/#{id}")
     end
 
     def get_triggers(type, options = {})
-      _, batch = load_batch("triggers/#{type}", 'Tags', options)
+      type = Postmark::Inflector.to_postmark(type)
+      _, batch = load_batch("triggers/#{type.downcase}", type, options)
       batch
     end
 
     def triggers(type, options = {})
-      find_each("triggers/#{type}", 'Tags', options)
+      type = Postmark::Inflector.to_postmark(type)
+      find_each("triggers/#{type.downcase}", type, options)
     end
 
     def server_info
@@ -221,22 +278,94 @@ module Postmark
       end
     end
 
+    def deliver_in_batches_with_templates(message_hashes)
+      in_batches(message_hashes) do |batch, offset|
+        mapped = batch.map { |h| MessageHelper.to_postmark(h) }
+        data = serialize(:Messages => mapped)
+
+        with_retries do
+          http_client.post('email/batchWithTemplates', data)
+        end
+      end
+    end
+
     def get_stats_totals(options = {})
       format_response(http_client.get('stats/outbound', options))
     end
 
     def get_stats_counts(stat, options = {})
       url = "stats/outbound/#{stat}"
-
       url << "/#{options[:type]}" if options.has_key?(:type)
 
       response = format_response(http_client.get(url, options))
-
       response[:days].map! { |d| HashHelper.to_ruby(d) }
-
       response
     end
 
+    def get_webhooks(options = {})
+      options = HashHelper.to_postmark(options)
+      _, batch = load_batch('webhooks', 'Webhooks', options)
+      batch
+    end
+
+    def get_webhook(id)
+      format_response http_client.get("webhooks/#{id}")
+    end
+
+    def create_webhook(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.post('webhooks', data)
+    end
+
+    def update_webhook(id, attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.put("webhooks/#{id}", data)
+    end
+
+    def delete_webhook(id)
+      format_response http_client.delete("webhooks/#{id}")
+    end
+
+    def get_message_streams(options = {})
+      _, batch = load_batch('message-streams', 'MessageStreams', options)
+      batch
+    end
+
+    def message_streams(options = {})
+      find_each('message-streams', 'MessageStreams', options)
+    end
+
+    def get_message_stream(id)
+      format_response(http_client.get("message-streams/#{id}"))
+    end
+
+    def create_message_stream(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+      format_response(http_client.post('message-streams', data))
+    end
+
+    def update_message_stream(id, attributes)
+      data = serialize(HashHelper.to_postmark(attributes))
+      format_response(http_client.patch("message-streams/#{id}", data))
+    end
+
+    def dump_suppressions(stream_id, options = {})
+      _, batch = load_batch("message-streams/#{stream_id}/suppressions/dump", 'Suppressions', options)
+      batch
+    end
+
+    def create_suppressions(stream_id, email_addresses)
+      data = serialize(:Suppressions => Array(email_addresses).map { |e| HashHelper.to_postmark(:email_address => e) })
+      format_response(http_client.post("message-streams/#{stream_id}/suppressions", data))
+    end
+
+    def delete_suppressions(stream_id, email_addresses)
+      data = serialize(:Suppressions => Array(email_addresses).map { |e| HashHelper.to_postmark(:email_address => e) })
+      format_response(http_client.post("message-streams/#{stream_id}/suppressions/delete", data))
+    end
+
     protected
 
     def in_batches(messages)
@@ -249,7 +378,7 @@ module Postmark
 
     def update_message(message, response)
       response ||= {}
-      message['Message-ID'] = response['MessageID']
+      message['X-PM-Message-Id'] = response['MessageID']
       message.delivered = response['ErrorCode'] && response['ErrorCode'].zero?
       message.postmark_response = response
     end
@@ -265,6 +394,5 @@ module Postmark
       path = options.delete(:inbound) ? 'messages/inbound' : 'messages/outbound'
       [path, messages_key, options]
     end
-
   end
 end

data/lib/postmark/bounce.rb

@@ -54,10 +54,6 @@ module Postmark
           Bounce.new(bounce_json)
         end
       end
-
-      def tags
-        Postmark.api_client.get_bounced_tags
-      end
     end
 
   end

data/lib/postmark/client.rb

@@ -37,12 +37,16 @@ module Postmark
 
     def with_retries
       yield
-    rescue DeliveryError
+    rescue HttpServerError, HttpClientError, TimeoutError, Errno::EINVAL,
+           Errno::ECONNRESET, Errno::ECONNREFUSED, EOFError,
+           Net::ProtocolError, SocketError => e
       retries = retries ? retries + 1 : 1
-      if retries < self.max_retries
+      retriable = !e.respond_to?(:retry?) || e.retry?
+
+      if retriable && retries < self.max_retries
         retry
       else
-        raise
+        raise e
       end
     end
 
@@ -52,7 +56,7 @@ module Postmark
 
     def take_response_of
       [yield, nil]
-    rescue DeliveryError => e
+    rescue HttpServerError => e
       [e.full_response || {}, e]
     end
 
@@ -76,6 +80,10 @@ module Postmark
       options[:offset] ||= 0
       options[:count] ||= 30
       response = http_client.get(path, options)
+      format_batch_response(response, name)
+    end
+
+    def format_batch_response(response, name)
       [response['TotalCount'], format_response(response[name])]
     end