postmark 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d99b2b07a9b385d8373eb4f0f020806d4ead30fc
-  data.tar.gz: 56f731c91f3d7a660e56c896d5666ee65c177ec1
+  metadata.gz: 17d7c0c5ea350fd8902efaa8e8334dff894fe215
+  data.tar.gz: 17f7871d1544d69b7cf16d75c4ba260048de182c
 SHA512:
-  metadata.gz: 1e0545eb81715e7a0d436557498f4cb0c3196fed8964ca8e0bc51699d2e944faacbb269cd8bfc1be537564983b2932a789738d2a9a0ba4271d2487371c3de61c
-  data.tar.gz: 6c5f27e71506ef94a7efb1f07bd14438f9f9403f9d1a209434dab722c3a96e57448e937d02f8da0f394596e4d3e800e2d5baf67cf2ec793e856ae7b364d8abf9
+  metadata.gz: 38df57ae61ce36c80870832444d017083e1bff043901823eb675384ae25df1366f420170abf41059a7601d7a6a2c7e26866a15abf8c5b98fa7fa30b7d8cbeeb8
+  data.tar.gz: 4dcacb79aec065cf65445da357f0b3e275911da17881291124dacd70b0bccacb1a3d69b4779f34f010692b7667710a0e0b6c8214a00af557b65d86746fc0a499

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = Changelog
 
+== 1.6.0
+
+* Add methods to access new templates API endpoints.
+
 == 1.5.0
 
 * Call API access strings tokens instead of keys. Keep backwards compatibility.

data/README.md

@@ -160,6 +160,22 @@ client.deliver(from: 'sheldon@bigbangtheory.com',
 # => {:to=>"Leonard Hofstadter <leonard@bigbangtheory.com>, Penny <penny@bigbangtheory.com>", :submitted_at=>"2013-05-09T05:04:16.3247488-04:00", :message_id=>"d647c5d6-xxxx-466d-9411-557dcd5c2297", :error_code=>0, :message=>"OK"}
 ```
 
+## Sending a templated email
+
+If you have a [template created](https://github.com/wildbit/postmark-gem/wiki/The-Templates-API-support) in Postmark you can send an email using that template. 
+
+``` ruby
+client.deliver_with_template(from: 'sheldon@bigbangtheory.com',
+                             to: 'Penny <penny@bigbangtheory.com>',
+                             template_id: 123,
+                             template_model: {
+                               name: 'Penny',
+                               message: 'Bazinga!'
+                             })
+
+# => {:to=>"Penny <penny@bigbangtheory.com>", :submitted_at=>"2013-05-09T03:00:55.4454938-04:00", :message_id=>"34aed4b3-3a95-xxxx-bd1d-88064909cc93", :error_code=>0, :message=>"OK"}
+```
+
 ## Sending in batches
 
 While Postmark is focused on transactional email, we understand that developers
@@ -544,6 +560,10 @@ Postmark allows you to automatically scale your sending infrastructure with the
 
 If you ever need to access your messages or their metadata (i.e. open tracking info), [the Messages API](https://github.com/wildbit/postmark-gem/wiki/The-Messages-API-support) is a great place to start.
 
+## The Templates API Support
+
+[The Templates API](https://github.com/wildbit/postmark-gem/wiki/The-Templates-API-support) can be used to fully manage your templates.
+
 ## ActiveModel-like Interface For Bounces
 
 To provide an interface similar to ActiveModel for bounces, the Postmark gem adds

data/VERSION

@@ -1 +1 @@
-1.5.0
+1.6.0

data/lib/postmark/api_client.rb

@@ -165,6 +165,62 @@ module Postmark
       format_response http_client.put("server", serialize(data))
     end
 
+    def get_templates(options = {})
+      load_batch('templates', 'Templates', options)
+    end
+
+    def templates(options = {})
+      find_each('templates', 'Templates', options)
+    end
+
+    def get_template(id)
+      format_response http_client.get("templates/#{id}")
+    end
+
+    def create_template(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.post('templates', data)
+    end
+
+    def update_template(id, attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+
+      format_response http_client.put("templates/#{id}", data)
+    end
+
+    def delete_template(id)
+      format_response http_client.delete("templates/#{id}")
+    end
+
+    def validate_template(attributes = {})
+      data = serialize(HashHelper.to_postmark(attributes))
+      response = format_response(http_client.post('templates/validate', data))
+
+      response.each do |k, v|
+        next unless v.is_a?(Hash) && k != :suggested_template_model
+
+        response[k] = HashHelper.to_ruby(v)
+
+        if response[k].has_key?(:validation_errors)
+          ruby_hashes = response[k][:validation_errors].map do |err|
+            HashHelper.to_ruby(err)
+          end
+          response[k][:validation_errors] = ruby_hashes
+        end
+      end
+
+      response
+    end
+
+    def deliver_with_template(attributes = {})
+      data = serialize(MessageHelper.to_postmark(attributes))
+
+      with_retries do
+        format_response http_client.post('email/withTemplate', data)
+      end
+    end
+
     protected
 
     def in_batches(messages)
@@ -195,4 +251,4 @@ module Postmark
     end
 
   end
-end
+end

data/lib/postmark/version.rb

@@ -1,3 +1,3 @@
 module Postmark
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
 end

data/spec/unit/postmark/api_client_spec.rb

@@ -572,4 +572,259 @@ describe Postmark::ApiClient do
     end
   end
 
-end
+  describe '#get_templates' do
+    let(:http_client) { subject.http_client }
+    let(:response) do
+      {
+        'TotalCount' => 31,
+        'Templates' => [
+          {
+            'Active' => true,
+            'TemplateId' => 123,
+            'Name' => 'ABC'
+          },
+          {
+            'Active' => true,
+            'TemplateId' => 456,
+            'Name' => 'DEF'
+          }
+        ]
+      }
+    end
+
+    it 'gets templates info and converts it to ruby format' do
+      http_client.should_receive(:get).with('templates', :offset => 0, :count => 2).and_return(response)
+
+      count, templates = subject.get_templates(:count => 2)
+
+      expect(count).to eq(31)
+      expect(templates.first[:template_id]).to eq(123)
+      expect(templates.first[:name]).to eq('ABC')
+    end
+  end
+
+  describe '#templates' do
+    it 'returns an Enumerator' do
+      expect(subject.templates).to be_kind_of(Enumerable)
+    end
+
+    it 'requests data at /templates' do
+      allow(subject.http_client).to receive(:get).
+          with('templates', an_instance_of(Hash)).
+          and_return('TotalCount' => 1, 'Templates' => [{}])
+      expect(subject.templates.first(5).count).to eq(1)
+    end
+  end
+
+  describe '#get_template' do
+    let(:http_client) { subject.http_client }
+    let(:response) do
+      {
+        'Name' => 'Template Name',
+        'TemplateId' => 123,
+        'Subject' => 'Subject',
+        'HtmlBody' => 'Html',
+        'TextBody' => 'Text',
+        'AssociatedServerId' => 456,
+        'Active' => true
+      }
+    end
+
+    it 'gets single template and converts it to ruby format' do
+      http_client.should_receive(:get).with('templates/123').and_return(response)
+
+      template = subject.get_template('123')
+
+      expect(template[:name]).to eq('Template Name')
+      expect(template[:template_id]).to eq(123)
+      expect(template[:html_body]).to eq('Html')
+    end
+  end
+
+  describe '#create_template' do
+    let(:http_client) { subject.http_client }
+    let(:response) do
+      {
+        'TemplateId' => 123,
+        'Name' => 'template name',
+        'Active' => true
+      }
+    end
+
+    it 'performs a POST request to /templates with the given attributes' do
+      expected_json = { 'Name' => 'template name' }.to_json
+
+      http_client.should_receive(:post).with('templates', expected_json).and_return(response)
+
+      template = subject.create_template(:name => 'template name')
+
+      expect(template[:name]).to eq('template name')
+      expect(template[:template_id]).to eq(123)
+    end
+  end
+
+  describe '#update_template' do
+    let(:http_client) { subject.http_client }
+    let(:response) do
+      {
+        'TemplateId' => 123,
+        'Name' => 'template name',
+        'Active' => true
+      }
+    end
+
+    it 'performs a PUT request to /templates with the given attributes' do
+      expected_json = { 'Name' => 'template name' }.to_json
+
+      http_client.should_receive(:put).with('templates/123', expected_json).and_return(response)
+
+      template = subject.update_template(123, :name => 'template name')
+
+      expect(template[:name]).to eq('template name')
+      expect(template[:template_id]).to eq(123)
+    end
+  end
+
+  describe '#delete_template' do
+    let(:http_client) { subject.http_client }
+    let(:response) do
+      {
+        'ErrorCode' => 0,
+        'Message' => 'Template 123 removed.'
+      }
+    end
+
+    it 'performs a DELETE request to /templates/:id' do
+      http_client.should_receive(:delete).with('templates/123').and_return(response)
+
+      resp = subject.delete_template(123)
+
+      expect(resp[:error_code]).to eq(0)
+    end
+  end
+
+  describe '#validate_template' do
+    let(:http_client) { subject.http_client }
+
+    context 'when template is valid' do
+      let(:response) do
+        {
+          'AllContentIsValid' => true,
+          'HtmlBody' => {
+            'ContentIsValid' => true,
+            'ValidationErrors' => [],
+            'RenderedContent' => '<html><head></head><body>MyName_Value</body></html>'
+          },
+          'TextBody' => {
+            'ContentIsValid' => true,
+            'ValidationErrors' => [],
+            'RenderedContent' => 'MyName_Value'
+          },
+          'Subject' => {
+            'ContentIsValid' => true,
+            'ValidationErrors' => [],
+            'RenderedContent' => 'MyName_Value'
+          },
+          'SuggestedTemplateModel' => {
+            'MyName' => 'MyName_Value'
+          }
+        }
+      end
+
+      it 'performs a POST request and returns unmodified suggested template model' do
+        expected_template_json = {
+          'HtmlBody' => '{{MyName}}',
+          'TextBody' => '{{MyName}}',
+          'Subject' => '{{MyName}}'
+        }.to_json
+
+        http_client.should_receive(:post).with('templates/validate', expected_template_json).and_return(response)
+
+        resp = subject.validate_template(:html_body => '{{MyName}}',
+                                         :text_body => '{{MyName}}',
+                                         :subject => '{{MyName}}')
+
+        expect(resp[:all_content_is_valid]).to be_true
+        expect(resp[:html_body][:content_is_valid]).to be_true
+        expect(resp[:html_body][:validation_errors]).to be_empty
+        expect(resp[:suggested_template_model]['MyName']).to eq('MyName_Value')
+      end
+    end
+
+    context 'when template is invalid' do
+      let(:response) do
+        {
+          'AllContentIsValid' => false,
+          'HtmlBody' => {
+            'ContentIsValid' => false,
+            'ValidationErrors' => [
+              {
+                'Message' => 'The \'each\' block being opened requires a model path to be specified in the form \'{#each <name>}\'.',
+                'Line' => 1,
+                'CharacterPosition' => 1
+              }
+            ],
+            'RenderedContent' => nil
+          },
+          'TextBody' => {
+            'ContentIsValid' => true,
+            'ValidationErrors' => [],
+            'RenderedContent' => 'MyName_Value'
+          },
+          'Subject' => {
+            'ContentIsValid' => true,
+            'ValidationErrors' => [],
+            'RenderedContent' => 'MyName_Value'
+          },
+          'SuggestedTemplateModel' => nil
+        }
+      end
+
+      it 'performs a POST request and returns validation errors' do
+        expected_template_json = {
+          'HtmlBody' => '{{#each}}',
+          'TextBody' => '{{MyName}}',
+          'Subject' => '{{MyName}}'
+        }.to_json
+
+        http_client.should_receive(:post).with('templates/validate', expected_template_json).and_return(response)
+
+        resp = subject.validate_template(:html_body => '{{#each}}',
+                                         :text_body => '{{MyName}}',
+                                         :subject => '{{MyName}}')
+
+        expect(resp[:all_content_is_valid]).to be_false
+        expect(resp[:text_body][:content_is_valid]).to be_true
+        expect(resp[:html_body][:content_is_valid]).to be_false
+        expect(resp[:html_body][:validation_errors].first[:character_position]).to eq(1)
+        expect(resp[:html_body][:validation_errors].first[:message]).to eq('The \'each\' block being opened requires a model path to be specified in the form \'{#each <name>}\'.')
+      end
+    end
+  end
+
+  describe "#deliver_with_template" do
+    let(:email) { Postmark::MessageHelper.to_postmark(message_hash) }
+    let(:email_json) { Postmark::Json.encode(email) }
+    let(:http_client) { subject.http_client }
+    let(:response) { {"MessageID" => 42} }
+
+    it 'converts message hash to Postmark format and posts it to /email/withTemplate' do
+      http_client.should_receive(:post).with('email/withTemplate', email_json) { response }
+      subject.deliver_with_template(message_hash)
+    end
+
+    it 'retries 3 times' do
+      2.times do
+        http_client.should_receive(:post).and_raise(Postmark::InternalServerError)
+      end
+      http_client.should_receive(:post) { response }
+      expect { subject.deliver_with_template(message_hash) }.not_to raise_error
+    end
+
+    it 'converts response to ruby format' do
+      http_client.should_receive(:post).with('email/withTemplate', email_json) { response }
+      r = subject.deliver_with_template(message_hash)
+      r.should have_key(:message_id)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postmark
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Petyo Ivanov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-05 00:00:00.000000000 Z
+date: 2015-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.7
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Official Postmark API wrapper.