postmark 1.8.1 → 1.21.3

data/lib/postmark/error.rb

@@ -0,0 +1,127 @@
+module Postmark
+  class Error < ::StandardError; end
+
+  class HttpClientError < Error
+    def retry?
+      true
+    end
+  end
+
+  class HttpServerError < Error
+    attr_accessor :status_code, :parsed_body, :body
+
+    alias_method :full_response, :parsed_body
+
+    def self.build(status_code, body)
+      parsed_body = Postmark::Json.decode(body) rescue {}
+
+      case status_code
+      when '401'
+        InvalidApiKeyError.new(401, body, parsed_body)
+      when '422'
+        ApiInputError.build(body, parsed_body)
+      when '500'
+        InternalServerError.new(500, body, parsed_body)
+      else
+        UnexpectedHttpResponseError.new(status_code, body, parsed_body)
+      end
+    end
+
+    def initialize(status_code = 500, body = '', parsed_body = {})
+      self.parsed_body = parsed_body
+      self.status_code = status_code.to_i
+      message = parsed_body.fetch(
+        'Message',
+        "The Postmark API responded with HTTP status #{status_code}.")
+
+      super(message)
+    end
+
+    def retry?
+      5 == status_code / 100
+    end
+  end
+
+  class ApiInputError < HttpServerError
+    INACTIVE_RECIPIENT = 406
+
+    attr_accessor :error_code
+
+    def self.build(body, parsed_body)
+      error_code = parsed_body['ErrorCode'].to_i
+
+      case error_code
+      when INACTIVE_RECIPIENT
+        InactiveRecipientError.new(INACTIVE_RECIPIENT, body, parsed_body)
+      else
+        new(error_code, body, parsed_body)
+      end
+    end
+
+    def initialize(error_code = nil, body = '', parsed_body = {})
+      self.error_code = error_code.to_i
+      super(422, body, parsed_body)
+    end
+
+    def retry?
+      false
+    end
+  end
+
+  class InactiveRecipientError < ApiInputError
+    attr_reader :recipients
+
+    PATTERNS = [/^Found inactive addresses: (.+?)\.$/.freeze,
+                /^Found inactive addresses: (.+?)\.$/.freeze,
+                /these inactive addresses: (.+?)\. Inactive/.freeze].freeze
+
+    def self.parse_recipients(message)
+      PATTERNS.each do |p|
+        _, recipients = p.match(message).to_a
+        next unless recipients
+        return recipients.split(', ')
+      end
+
+      []
+    end
+
+    def initialize(*args)
+      super
+      @recipients = parse_recipients || []
+    end
+
+    private
+
+    def parse_recipients
+      return unless parsed_body && !parsed_body.empty?
+
+      self.class.parse_recipients(parsed_body['Message'])
+    end
+  end
+
+  class InvalidTemplateError < Error
+    attr_reader :postmark_response
+
+    def initialize(response)
+      @postmark_response = response
+      super('Failed to render the template. Please check #postmark_response on this error for details.')
+    end
+  end
+
+  class TimeoutError < Error
+    def retry?
+      true
+    end
+  end
+
+  class MailAdapterError < Postmark::Error; end
+  class UnknownMessageType < Error; end
+  class InvalidApiKeyError < HttpServerError; end
+  class InternalServerError < HttpServerError; end
+  class UnexpectedHttpResponseError < HttpServerError; end
+
+  # Backwards compatible aliases
+  DeliveryError = Error
+  InvalidMessageError = ApiInputError
+  UnknownError = UnexpectedHttpResponseError
+end

data/lib/postmark/handlers/mail.rb

@@ -8,10 +8,11 @@ module Mail
     end
 
     def deliver!(mail)
-      settings = self.settings.dup
-      api_token = settings.delete(:api_token) || settings.delete(:api_key)
-      api_client = ::Postmark::ApiClient.new(api_token, settings)
-      response = api_client.deliver_message(mail)
+      response = if mail.templated?
+                   api_client.deliver_message_with_template(mail)
+                 else
+                   api_client.deliver_message(mail)
+                 end
 
       if settings[:return_response]
         response
@@ -20,5 +21,10 @@ module Mail
       end
     end
 
+    def api_client
+      settings = self.settings.dup
+      api_token = settings.delete(:api_token) || settings.delete(:api_key)
+      ::Postmark::ApiClient.new(api_token, settings)
+    end
   end
 end

data/lib/postmark/helpers/message_helper.rb

@@ -18,6 +18,10 @@ module Postmark
         message[:attachments] = attachments_to_postmark(message[:attachments])
       end
 
+      if message[:track_links]
+        message[:track_links] = ::Postmark::Inflector.to_postmark(message[:track_links])
+      end
+
       HashHelper.to_postmark(message)
     end
 

data/lib/postmark/http_client.rb

@@ -6,7 +6,9 @@ module Postmark
     attr_accessor :api_token
     attr_reader :http, :secure, :proxy_host, :proxy_port, :proxy_user,
                 :proxy_pass, :host, :port, :path_prefix,
-                :http_open_timeout, :http_read_timeout, :auth_header_name
+                :http_open_timeout, :http_read_timeout, :http_ssl_version,
+                :auth_header_name
+
     alias_method :api_key, :api_token
     alias_method :api_key=, :api_token=
 
@@ -34,6 +36,10 @@ module Postmark
       do_request { |client| client.put(url_path(path), data, headers) }
     end
 
+    def patch(path, data = '')
+      do_request { |client| client.patch(url_path(path), data, headers) }
+    end
+
     def get(path, query = {})
       do_request { |client| client.get(url_path(path + to_query_string(query)), headers) }
     end
@@ -42,6 +48,10 @@ module Postmark
       do_request { |client| client.delete(url_path(path + to_query_string(query)), headers) }
     end
 
+    def protocol
+      self.secure ? 'https' : 'http'
+    end
+
     protected
 
     def apply_options(options = {})
@@ -49,7 +59,7 @@ module Postmark
       DEFAULTS.merge(options).each_pair do |name, value|
         instance_variable_set(:"@#{name}", value)
       end
-      @port = options[:port] || @secure ? 443 : 80
+      @port = options[:port] || (@secure ? 443 : 80)
     end
 
     def to_query_string(hash)
@@ -57,26 +67,15 @@ module Postmark
       "?" + hash.map { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
     end
 
-    def protocol
-      self.secure ? "https" : "http"
-    end
-
     def url
       URI.parse("#{protocol}://#{self.host}:#{self.port}/")
     end
 
     def handle_response(response)
-      case response.code.to_i
-      when 200
-        return Postmark::Json.decode(response.body)
-      when 401
-        raise error(InvalidApiKeyError, response.body)
-      when 422
-        raise error(InvalidMessageError, response.body)
-      when 500
-        raise error(InternalServerError, response.body)
+      if response.code.to_i == 200
+        Postmark::Json.decode(response.body)
       else
-        raise UnknownError, response
+        raise HttpServerError.build(response.code, response.body)
       end
     end
 
@@ -92,8 +91,10 @@ module Postmark
       @request_mutex.synchronize do
         handle_response(yield(http))
       end
-    rescue Timeout::Error
-      raise TimeoutError.new($!)
+    rescue Timeout::Error => e
+      raise TimeoutError.new(e)
+    rescue Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError => e
+      raise HttpClientError.new(e.message)
     end
 
     def build_http
@@ -105,21 +106,8 @@ module Postmark
       http.read_timeout = self.http_read_timeout
       http.open_timeout = self.http_open_timeout
       http.use_ssl = !!self.secure
-      http.ssl_version = :TLSv1 if http.respond_to?(:ssl_version=)
+      http.ssl_version = self.http_ssl_version if self.http_ssl_version && http.respond_to?(:ssl_version=)
       http
     end
-
-    def error_message(response_body)
-      Postmark::Json.decode(response_body)["Message"]
-    end
-
-    def error_message_and_code(response_body)
-      reply = Postmark::Json.decode(response_body)
-      [reply["Message"], reply["ErrorCode"], reply]
-    end
-
-    def error(clazz, response_body)
-      clazz.send(:new, *error_message_and_code(response_body))
-    end
   end
 end

data/lib/postmark/mail_message_converter.rb

@@ -7,10 +7,10 @@ module Postmark
     end
 
     def run
-      delete_blank_fields(convert)
+      delete_blank_fields(pick_fields(convert, @message.templated?))
     end
 
-    protected
+    private
 
     def convert
       headers_part.merge(content_part)
@@ -30,10 +30,25 @@ module Postmark
         'Subject' => @message.subject,
         'Headers' => @message.export_headers,
         'Tag' => @message.tag.to_s,
-        'TrackOpens' => cast_to_bool(@message.track_opens)
+        'TrackOpens' => (cast_to_bool(@message.track_opens) unless @message.track_opens.empty?),
+        'TrackLinks' => (::Postmark::Inflector.to_postmark(@message.track_links) unless @message.track_links.empty?),
+        'Metadata' => @message.metadata,
+        'TemplateAlias' => @message.template_alias,
+        'TemplateModel' => @message.template_model,
+        'MessageStream' => @message.message_stream
       }
     end
 
+    def pick_fields(message_hash, templated = false)
+      fields = if templated
+                 %w(Subject HtmlBody TextBody)
+               else
+                 %w(TemplateAlias TemplateModel)
+               end
+      fields.each { |key| message_hash.delete(key) }
+      message_hash
+    end
+
     def content_part
       {
         'Attachments' => @message.export_attachments,
@@ -42,8 +57,6 @@ module Postmark
       }
     end
 
-    protected
-
     def cast_to_bool(val)
       if val.is_a?(TrueClass) || val.is_a?(FalseClass)
         val

data/lib/postmark/message_extensions/mail.rb

@@ -15,12 +15,34 @@ module Mail
       header['TAG'] = val
     end
 
+    def track_links(val = nil)
+      self.track_links=(val) unless val.nil?
+      header['TRACK-LINKS'].to_s
+    end
+
+    def track_links=(val)
+      header['TRACK-LINKS'] = ::Postmark::Inflector.to_postmark(val)
+    end
+
     def track_opens(val = nil)
-      default 'TRACK-OPENS', !!val
+      self.track_opens=(val) unless val.nil?
+      header['TRACK-OPENS'].to_s
     end
 
     def track_opens=(val)
-      header['TRACK-OPENS'] = !!val
+      header['TRACK-OPENS'] = (!!val).to_s
+    end
+
+    def metadata(val = nil)
+      if val
+        @metadata = val
+      else
+        @metadata ||= {}
+      end
+    end
+
+    def metadata=(val)
+      @metadata = val
     end
 
     def postmark_attachments=(value)
@@ -39,6 +61,59 @@ module Mail
       ::Postmark::MessageHelper.attachments_to_postmark(@_attachments)
     end
 
+    def template_alias(val = nil)
+      return self[:postmark_template_alias] && self[:postmark_template_alias].to_s if val.nil?
+      self[:postmark_template_alias] = val
+    end
+
+    attr_writer :template_model
+    def template_model(model = nil)
+      return @template_model if model.nil?
+      @template_model = model
+    end
+
+    def message_stream(val = nil)
+      self.message_stream = val unless val.nil?
+      header['MESSAGE-STREAM'].to_s
+    end
+
+    def message_stream=(val)
+      header['MESSAGE-STREAM'] = val
+    end
+
+    def templated?
+      !!template_alias
+    end
+
+    def prerender
+      raise ::Postmark::Error, 'Cannot prerender a message without an associated template alias' unless templated?
+
+      unless delivery_method.is_a?(::Mail::Postmark)
+        raise ::Postmark::MailAdapterError, "Cannot render templates via #{delivery_method.class} adapter."
+      end
+
+      client = delivery_method.api_client
+      template = client.get_template(template_alias)
+      response = client.validate_template(template.merge(:test_render_model => template_model || {}))
+
+      raise ::Postmark::InvalidTemplateError, response unless response[:all_content_is_valid]
+
+      self.body = nil
+
+      subject response[:subject][:rendered_content]
+
+      text_part do
+        body response[:text_body][:rendered_content]
+      end
+
+      html_part do
+        content_type 'text/html; charset=UTF-8'
+        body response[:html_body][:rendered_content]
+      end
+
+      self
+    end
+
     def text?
       if defined?(super)
         super
@@ -77,10 +152,8 @@ module Mail
       [].tap do |headers|
         self.header.fields.each do |field|
           key, value = field.name, field.value
-          next if bogus_headers.include? key.downcase
-          name = key.split(/-/).map { |i| i.capitalize }.join('-')
-
-          headers << { "Name" => name, "Value" => value }
+          next if reserved_headers.include? key.downcase
+          headers << { "Name" => key, "Value" => value }
         end
       end
     end
@@ -107,7 +180,7 @@ module Mail
       end
     end
 
-    def bogus_headers
+    def reserved_headers
       %q[
         return-path  x-pm-rcpt
         from         reply-to
@@ -116,7 +189,9 @@ module Mail
         cc           bcc
         subject      tag
         attachment   to
-        track-opens
+        track-opens  track-links
+        postmark-template-alias
+        message-stream
       ]
     end