postageapp 0.0.0 → 1.0.0

data/lib/postageapp/configuration.rb

@@ -0,0 +1,91 @@
+class PostageApp::Configuration
+  
+  # The API key for your postageapp.com project
+  attr_accessor :api_key
+  
+  # +true+ for https, +false+ for http connections (default: is +true+)
+  attr_accessor :secure
+  
+  # The protocol used to connect to the service (default: 'https' for secure 
+  # and 'http' for insecure connections)
+  attr_accessor :protocol
+  
+  # The host to connect to (default: 'api.postageapp.com')
+  attr_accessor :host
+  
+  # The port on which PostageApp service runs (default: 443 for secure, 80 for 
+  # insecure connections)
+  attr_accessor :port
+  
+  # The hostname of the proxy server (if using a proxy)
+  attr_accessor :proxy_host
+  
+  # The port of the proxy server (if using proxy)
+  attr_accessor :proxy_port
+  
+  # The username for the proxy server (if using proxy)
+  attr_accessor :proxy_user
+  
+  # The password for the proxy server (if using proxy)
+  attr_accessor :proxy_pass
+  
+  # The HTTP open timeout in seconds (defaults to 2).
+  attr_accessor :http_open_timeout
+  
+  # The HTTP read timeout in seconds (defaults to 5).
+  attr_accessor :http_read_timeout
+  
+  # The email address that all send_message method should address
+  # all messages while overriding original addresses
+  attr_accessor :recipient_override
+  
+  # A list of API method names payloads of which are captured and resent
+  # in case of service unavailability
+  attr_accessor :requests_to_resend
+  
+  # The file path of the project. This is where logs and failed requests
+  # can be stored
+  attr_accessor :project_root
+  
+  # The framework PostageApp gem runs in
+  attr_accessor :framework
+  
+  # Environment gem is running in
+  attr_accessor :environment
+  
+  # The logger used by this gem
+  attr_accessor :logger
+  
+  def initialize
+    @secure             = true
+    @host               = 'api.postageapp.com'
+    @http_open_timeout  = 5
+    @http_read_timeout  = 10
+    @requests_to_resend = %w( send_message )
+    @framework          = 'undefined framework'
+    @environment        = 'production'
+  end
+  
+  alias_method :secure?, :secure
+  
+  def protocol
+    @protocol || if secure?
+      'https'
+    else
+      'http'
+    end
+  end
+  
+  def port
+    @port || if secure?
+      443
+    else
+      80
+    end
+  end
+  
+  def url
+    "#{self.protocol}://#{self.host}:#{self.port}"
+  end
+  
+end

data/lib/postageapp/failed_request.rb

@@ -0,0 +1,64 @@
+module PostageApp::FailedRequest
+  
+  # Stores request object into a file for future re-send
+  # returns true if stored, false if not (due to undefined project path)
+  def self.store(request)
+    return false if !store_path || !PostageApp.configuration.requests_to_resend.member?(request.method.to_s)
+    
+    open(file_path(request.uid), 'w') do |f|
+      f.write(Marshal.dump(request))
+    end unless File.exists?(file_path(request.uid))
+    
+    PostageApp.logger.info "STORING FAILED REQUEST [#{request.uid}]"
+    
+    true
+  end
+  
+  # Attempting to resend failed requests
+  def self.resend_all
+    return false if !store_path
+    
+    Dir.foreach(store_path) do |filename|
+      next if !filename.match /^\w{40}$/
+      
+      request = initialize_request(filename)
+      
+      receipt_response = PostageApp::Request.new(:get_message_receipt, :uid => filename).send(true)
+      if receipt_response.ok?
+        PostageApp.logger.info "NOT RESENDING FAILED REQUEST [#{filename}]"
+        File.delete(file_path(filename))
+        
+      elsif receipt_response.not_found?
+        PostageApp.logger.info "RESENDING FAILED REQUEST [#{filename}]"
+        response = request.send(true)
+        
+        # Not a fail, so we can remove this file, if it was then
+        # there will be another attempt to resend
+        File.delete(file_path(filename)) if !response.fail?
+      end
+    end
+    
+    return
+  end
+  
+  # Initializing PostageApp::Request object from the file
+  def self.initialize_request(uid)
+    return false if !store_path
+    
+    Marshal.load(File.read(file_path(uid))) if File.exists?(file_path(uid))
+  end
+  
+protected
+  
+  def self.store_path
+    return if !PostageApp.configuration.project_root
+    dir = File.join(File.expand_path(PostageApp.configuration.project_root), 'tmp/postageapp_failed_requests')
+    FileUtils.mkdir_p(dir) unless File.exists?(dir)
+    return dir
+  end
+  
+  def self.file_path(uid)
+    File.join(store_path, uid)
+  end
+  
+end

data/lib/postageapp/logger.rb

@@ -0,0 +1,16 @@
+class PostageApp::Logger < ::Logger
+  
+  def format_message(severity, datetime, progname, msg)
+    timestamp = datetime.strftime('%m/%d/%Y %H:%M:%S %Z')
+    message = case msg
+      when PostageApp::Request
+        "REQUEST [#{msg.url}]\n #{msg.arguments_to_send.to_json}"
+      when PostageApp::Response
+        "RESPONSE [#{msg.status} #{msg.uid} #{msg.message}]\n #{msg.data.to_json}"
+      else
+        msg
+    end
+    "[#{timestamp}] #{message}\n"
+  end
+  
+end

data/lib/postageapp/mailer.rb

@@ -0,0 +1,48 @@
+require 'action_mailer'
+require 'action_mailer/version'
+
+# Loading PostageApp::Mailer class depending on what action_mailer is
+# currently installed on the system. Assuming we're dealing only with
+# ones that come with Rails 2 and 3
+if ActionMailer::VERSION::MAJOR >= 3
+  require File.expand_path('../mailer/mailer_3', __FILE__)
+else
+  require File.expand_path('../mailer/mailer_2', __FILE__)
+end
+
+# General helper methods for Request object to act more like TMail::Mail
+# of Mail for testing
+class PostageApp::Request
+  
+  # Getter and setter for headers. You can specify headers in the following
+  # formats:
+  #   headers['Custom-Header'] = 'Custom Value'
+  #   headers 'Custom-Header-1' => 'Custom Value 1',
+  #           'Custom-Header-2' => 'Custom Value 2'
+  def headers(value = nil)
+    self.arguments['headers'] ||= { }
+    if value && value.is_a?(Hash)
+      value.each do |k, v|
+        self.arguments['headers'][k.to_s] = v.to_s
+      end
+    end
+    self.arguments['headers']
+  end
+  
+  def to
+    self.arguments_to_send.dig('arguments', 'recipients')
+  end
+  
+  def from
+    self.arguments_to_send.dig('arguments', 'headers', 'from')
+  end
+  
+  def subject
+    self.arguments_to_send.dig('arguments', 'headers', 'subject')
+  end
+  
+  def body
+    self.arguments_to_send.dig('arguments', 'content')
+  end
+  
+end

data/lib/postageapp/mailer/mailer_2.rb

@@ -0,0 +1,92 @@
+# Postage::Mailer allows you to use/re-use existing mailers set up using
+# ActionMailer. The only catch is to change inheritance from ActionMailer::Base
+# to PostageApp::Mailer. Also don't forget to require 'postageapp/mailer'
+#
+# Here's an example of a valid PostageApp::Mailer class
+#  
+#   require 'postageapp/mailer'
+#  
+#   class Notifier < PostageApp::Mailer
+#     def signup_notification(recipient)
+#       recipients  recipient.email_address
+#       from        'system@example.com'
+#       subject     'New Account Information'
+#     end
+#   end
+#
+# Postage::Mailer introduces a few mailer methods specific to Postage:
+#
+# * postage_template  - template name that is defined in your PostageApp project
+# * postage_variables - extra variables you want to send along with the message
+#
+# Sending email
+#
+#   Notifier.deliver_signup_notification(user) # attempts to deliver to PostageApp (depending on env)
+#   request = Notifier.create_signup_notification(user) # creates PostageApp::Request object
+#
+class PostageApp::Mailer < ActionMailer::Base
+  
+  # Using :test as a delivery method if set somewhere else
+  self.delivery_method = :postage unless (self.delivery_method == :test)
+  
+  adv_attr_accessor :postage_template
+  adv_attr_accessor :postage_variables
+  
+  def perform_delivery_postage(mail)
+    mail.send
+  end
+  
+  def deliver!(mail = @mail)
+    raise 'PostageApp::Request object not present, cannot deliver' unless mail
+    __send__("perform_delivery_#{delivery_method}", mail) if perform_deliveries
+  end
+  
+  # Creating a Postage::Request object unlike TMail one in ActionMailer::Base
+  def create_mail
+    params = { }
+    params['recipients'] = self.recipients unless self.recipients.blank?
+    
+    params['headers'] = { }
+    params['headers']['subject']  = self.subject  unless self.subject.blank?
+    params['headers']['from']     = self.from     unless self.from.blank?
+    params['headers'].merge!(self.headers)        unless self.headers.blank?
+    
+    params['content'] = { }
+    params['attachments'] = { }
+    
+    if @parts.empty?
+      params['content'][self.content_type] = self.body unless self.body.blank?
+    else
+      self.parts.each do |part|
+        case part.content_disposition
+        when 'inline'
+          part.content_type = 'text/plain' if part.content_type.blank? && String === part.body
+          params['content'][part.content_type] = part.body
+        when 'attachment'
+          params['attachments'][part.filename] = {
+            'content_type' => part.content_type,
+            'content'      => Base64.encode64(part.body)
+          }
+        end
+      end
+    end
+    
+    params['template'] = self.postage_template unless self.postage_template.blank?
+    params['variables'] = self.postage_variables unless self.postage_variables.blank?
+    
+    params.delete('headers')     if params['headers'].blank?
+    params.delete('content')     if params['content'].blank?
+    params.delete('attachments') if params['attachments'].blank?
+    
+    @mail = PostageApp::Request.new(:send_message, params)
+  end
+  
+  # Not insisting rendering a view if it's not there. PostageApp gem can send blank content
+  # provided that the template is defined.
+  def render(opts)
+    super(opts)
+  rescue ActionView::MissingTemplate
+    # do nothing
+  end
+  
+end

data/lib/postageapp/mailer/mailer_3.rb

@@ -0,0 +1,192 @@
+# Postage::Mailer allows you to use/re-use existing mailers set up using
+# ActionMailer. The only catch is to change inheritance from ActionMailer::Base
+# to PostageApp::Mailer. Also don't forget to require 'postageapp/mailer'
+#
+# Here's an example of a valid PostageApp::Mailer class
+#  
+#   require 'postageapp/mailer'
+#  
+#   class Notifier < PostageApp::Mailer
+#     def signup_notification(recipient)
+#       mail(
+#         :to       => recipient.email,
+#         :from     => 'sender@test.test',
+#         :subject  => 'Test Message'
+#       )
+#     end
+#   end
+#
+# Postage::Mailer introduces a few mailer methods specific to Postage:
+#
+# * postage_template  - template name that is defined in your PostageApp project
+# * postage_variables - extra variables you want to send along with the message
+#
+# Sending email
+#
+#   request = Notifier.signup_notification(user) # creates PostageApp::Request object
+#   response = request.deliver # attempts to deliver the message and creates a PostageApp::Response
+#
+class PostageApp::Mailer < ActionMailer::Base
+  
+  # Wrapper for creating attachments
+  # Attachments sent to PostageApp are in the following format:
+  #  'filename.ext' => {
+  #    'content_type' => 'content/type',
+  #    'content'      => 'base64_encoded_content'
+  #   }
+  class Attachments < Hash
+    
+    def initialize(message)
+      @_message = message
+      message.arguments['attachments'] ||= { }
+    end
+    
+    def []=(filename, attachment)
+      default_content_type = MIME::Types.type_for(filename).first.content_type rescue ''
+      if attachment.is_a?(Hash)
+        content_type  = attachment[:content_type] || default_content_type
+        content       = Base64.encode64(attachment[:body])
+      else
+        content_type  = default_content_type
+        content       = Base64.encode64(attachment)
+      end
+      @_message.arguments['attachments'][filename] = {
+        'content_type'  => content_type,
+        'content'       => content
+      }
+    end
+  end
+  
+  # In API call we can specify PostageApp template that will be used
+  # to generate content of the message
+  attr_accessor :postage_template
+  
+  # Hash of variables that will be used to inject into the content
+  attr_accessor :postage_variables
+  
+  # Instead of initializing Mail object, we prepare PostageApp::Request
+  def initialize(method_name = nil, *args)
+    @_message = PostageApp::Request.new(:send_message)
+    process(method_name, *args) if method_name
+  end
+  
+  def postage_template(value)
+    @_message.arguments['template'] = value
+  end
+  
+  def postage_variables(variables = {})
+    @_message.arguments['variables'] = variables
+  end
+  
+  def attachments
+    @_attachments ||= Attachments.new(@_message)
+  end
+  
+  # Overriding method that prepares Mail object. This time we'll be 
+  # contructing PostageApp::Request payload.
+  def mail(headers = {}, &block)
+    # Guard flag to prevent both the old and the new API from firing
+    # Should be removed when old API is removed
+    @mail_was_called = true
+    m = @_message
+    
+    # At the beginning, do not consider class default for parts order neither content_type
+    content_type = headers[:content_type]
+    parts_order  = headers[:parts_order]
+    
+    # Call all the procs (if any)
+    default_values = self.class.default.merge(self.class.default) do |k,v|
+      v.respond_to?(:call) ? v.bind(self).call : v
+    end
+    
+    # Handle defaults
+    headers = headers.reverse_merge(default_values)
+    headers[:subject] ||= default_i18n_subject
+    
+    # Set configure delivery behavior
+    wrap_delivery_behavior!(headers.delete(:delivery_method))
+    
+    # Assigning recipients
+    m.arguments['recipients'] = headers.delete(:to)
+    
+    # Assign all headers except parts_order, content_type and body
+    assignable = headers.except(:parts_order, :content_type, :body, :template_name, :template_path)
+    m.arguments['headers'] = assignable
+    
+    # Render the templates and blocks
+    responses, explicit_order = collect_responses_and_parts_order(headers, &block)
+    create_parts_from_responses(m, responses)
+    
+    m
+  end
+  
+  # Overriding method to create mesage from the old_api
+  def create_mail
+    m = @_message
+    
+    m.arguments['headers'] ||= { }
+    m.arguments['headers']['from'] = from
+    m.arguments['headers']['subject'] = subject
+    m.arguments['recipients'] = recipients
+    
+    m
+  end
+  
+  # Overriding part assignment from old_api
+  # For now only accepting a hash
+  def part(params)
+    @_message.arguments['content'] ||= { }
+    @_message.arguments['content'][params[:content_type]] = params[:body]
+  end
+  
+  # Overriding attachment assignment from old_api
+  # For now only accepting a hash
+  def attachment(params)
+    @_message.arguments['attachments'] ||= { }
+    @_message.arguments['attachments'][params[:filename]] = {
+      'content_type'  => params[:content_type],
+      'content'       => Base64.encode64(params[:body].to_s)
+    }
+  end
+  
+  # Overriding method in old_api
+  def create_inline_part(body, mime_type = nil)
+    @_message.arguments['content'] ||= { }
+    @_message.arguments['content'][mime_type && mime_type.to_s || 'text/plain'] = body
+  end
+  
+protected
+
+  def create_parts_from_responses(m, responses) #:nodoc:
+    content = m.arguments['content'] ||= {}
+    responses.each do |part|
+      content[part[:content_type]] = part[:body]
+    end
+  end
+  
+end
+
+# A set of methods that are useful when request needs to behave as Mail
+class PostageApp::Request
+  
+  attr_accessor :delivery_handler,
+                :perform_deliveries,
+                :raise_delivery_errors
+  
+  # Either doing an actual send, or passing it along to Mail::TestMailer
+  # Probably not the best way as we're skipping way too many intermediate methods
+  def deliver
+    if @delivery_method == Mail::TestMailer
+      mailer = @delivery_method.new(nil)
+      mailer.deliver!(self)
+    else
+      self.send
+    end
+  end
+  
+  # Not 100% on this, but I need to assign this so I can properly handle deliver method
+  def delivery_method(method = nil, settings = {})
+    @delivery_method = method
+  end
+  
+end