[cover image: Photo by Maksim Goncharenok from Pexels]

Goal

As explained in part one, we want to import all Postmark templates into our local system to be able to change them in bulk and export them to Postmark later.

In this section, we will look at importing e-mails from Postmark.

Data Structure

E-mails in Postmark are not only composed of HTML. They also have:

• A text body
• A layout id
• A name
• A subject
• An alias
• An associated server-id
• An active attribute
• A layout template

To both allow changing easily the HTML of the e-mails and the data associated with our e-mail, we decided to structure the data in two ways:

• an HTML file per template named with the following pattern: #{templatename}#{template_id}.
• a global metadata.yml file with the rest of the templates information. Each e-mail has one entry under its id and then an entry per attribute + the DateTime of the import for that template.

1234:
  :name: template_name
  :subject: Some Subject
  :associated_server_id: 1564321
  :active: true
  :text_body: The text body
  :alias: some-alias
  :layout_template: yago_layout_nl
  :imported_at: "2022-02-09T15:53"

Code

Code Structure

We decided to implement an ExternalTemplate model that represents the data on Postmark. We felt that it would have different responsibilities than the InternalTemplate model, which would focus on representing the mail on our DB.

To bulk import the e-mails, we also decided to implement a TemplateGetter service. The TemplateGetter service will make use of the ExternalTemplate.

ExternalTemplate

Its responsibilities are to get the data from Postmark and instantiate itself as an object (initialize), and save itself on the DB. For that, it will user write_html_body and write_metadata.

class ExternalTemplate
  def initialize(id, server_key)
    postmark = Postmark::ApiClient.new(server_key)
    postmark.get_template(id).each do |key, value|
      instance_variable_set("@#{key}", value)
      self.class.send(:attr_reader, key)
    end
  end

  def save
    print '.'
    write_html_body
    write_metadata
  end

  private

  def write_html_body
    File.open("imported_templates/#{name}_#{template_id}.html", 'w+') do |file|
      file << html_body
    end
  end

  def write_metadata
    require 'yaml'
    data = YAML.load_file('imported_templates/metadata.yml') || {}

    data[template_id] = yaml_attributes.merge(imported_at: Time.now.strftime('%Y-%m-%dT%H:%M'))
    File.open('imported_templates/metadata.yml', 'w+') do |file|
      YAML.dump(data, file)
    end
  end

  def yaml_attributes
    {
      name: name,
      subject: subject,
      associated_server_id: associated_server_id,
      active: active,
      text_body: text_body,
      alias: self.alias,
      layout_template: layout_template
    }
  end
end

TemplateGetter

Its responsibilities are:

• Iterate through the postmark servers (limited to 100 templates, so we currently have two servers)
• Get the ids of the server's templates
• Initialize an InternalTemplate for each id
• Tell the InternalTemplate to save

require 'rubygems'
require 'bundler/setup'
require 'yaml'
require 'postmark'
require_relative '../models/external_template'

class TemplateGetter
  def self.import_templates
    postmark_api_servers.each do |server_key|
      templates_ids(server_key).each { |id| download_template(id, server_key) }
    end
  end

  def self.postmark_api_servers
    secrets = YAML.load_file('secrets.yml')
    [secrets['postmark_api_server_1'], secrets['postmark_api_server_2']]
  end

  def self.templates_ids(server_key)
    postmark = Postmark::ApiClient.new(server_key)
    postmark.get_templates(count: 100)[1].map { |template| template[:template_id] }
  end

  def self.download_template(id, server_key)
    template = ExternalTemplate.new(id, server_key)
    template.save
  end
end

Conclusion

Building a tool to import templates from Postmark is relatively easy (thanks to their gem. If you find yourself having to make changes in bulk or even just wanting to have a copy of all your e-mail data on Postmark, this system is relatively easy to implement.

In our case, we added a CLI tool to be able to interact easily with the code:

require_relative 'services/template_getter'

puts 'welcome to the Postmark cli tool'
puts 'would you like to: ?'
puts '1. import all e-mails'

input = gets

case input.strip
when '1'
  TemplateGetter.new.get_all_templates
else
  puts 'invalid input'
end

In Part 3 we will discuss the strategies we implemented to test our changes.