msg 0.1.0

data/app/controllers/msg/bounces_controller.rb

@@ -0,0 +1,67 @@
+require 'open-uri'
+
+module Msg
+  class BouncesController < Msg::EngineController
+    respond_to :json
+
+    # this is pinged from Amazon SNS with a JSON body something like this:
+    #
+    # {
+    #     "notificationType":"Bounce",
+    #     "bounce":{
+    #        "bounceType":"Permanent",
+    #        "reportingMTA":"dns; email.example.com",
+    #        "bouncedRecipients":[
+    #           {
+    #              "emailAddress":"username@example.com",
+    #              "status":"5.1.1",
+    #              "action":"failed",
+    #              "diagnosticCode":"smtp; 550 5.1.1 <username@example.com>... User"
+    #           }
+    #        ],
+    #        "bounceSubType":"General",
+    #        "timestamp":"2012-06-19T01:07:52.000Z",
+    #        "feedbackId":"00000138111222aa-33322211-cccc-cccc-cccc-ddddaaaa068a-000000"
+    #     },
+    #     "mail":{
+    #        "timestamp":"2012-06-19T01:05:45.000Z",
+    #        "source":"sender@example.com",
+    #        "messageId":"00000138111222aa-33322211-cccc-cccc-cccc-ddddaaaa0680-000000",
+    #        "destination":[
+    #           "username@example.com"
+    #        ]
+    #     }
+    #  }
+    #
+    #
+    # When the subscription is first set up they will also POST us a SubscriptionConfirmation,
+    # upon which we have to GET the given url to confirm that we can follow orders.
+    #
+    def create
+      if request.headers['x-amz-sns-message-type'] == 'SubscriptionConfirmation'
+        response = HTTParty.get(params['SubscribeURL'])
+        head :ok
+
+      else
+        mail = params['Message']['mail']
+        bounce = params['Message']['bounce']
+        if envelope = Msg::Envelope.find_by_email_id(mail['messageId'])
+          envelope.bounces.create({
+            :bounce_type => bounce['bounceType'],
+            :bounce_subtype => bounce['bounceSubType'],
+            :reporter => bounce['reportingMTA'],
+            :raw_message => JSON.dump(bounce)
+          })
+        end
+        head :ok
+      end
+    end
+
+  protected
+
+    def build_bounce
+      @bounce = Msg::Bounce.new(params[:bounce])
+    end
+
+  end
+end

data/app/controllers/msg/engine_controller.rb

@@ -0,0 +1,23 @@
+module Msg
+  class EngineController < ::ApplicationController
+    
+    before_filter :authenticate_user!
+    before_filter :require_admin!
+    layout :no_layout_if_pjax
+    
+  protected
+    
+    def require_admin!
+      raise Msg::PermissionDenied unless current_user.admin?
+    end
+    
+    def no_layout_if_pjax
+      if request.headers['X-PJAX']
+        false
+      else
+        Msg.layout
+      end
+    end
+    
+  end
+end

data/app/controllers/msg/envelopes_controller.rb

@@ -0,0 +1,22 @@
+module Msg
+  class EnvelopesController < Msg::EngineController
+    respond_to :png
+    skip_before_filter :authenticate_user!, :only => [:show]
+    skip_before_filter :require_admin!, :only => [:show]
+    before_filter :get_envelope, :only => [:show]
+
+    # envelopes#show is pinged when a message is opened.
+    #
+    def show
+      @envelope.open!
+      redirect_to view_context.image_path('msg/ping.png')
+    end
+  
+  protected
+  
+    def get_envelope
+      @envelope = Msg::Envelope.find(params[:id])
+    end
+  
+  end
+end

data/app/controllers/msg/messages_controller.rb

@@ -0,0 +1,85 @@
+module Msg
+  class MessagesController < Msg::EngineController
+    respond_to :html, :js
+
+    before_filter :get_message, :only => [:show, :edit, :update, :destroy, :preview]
+    before_filter :build_message, :only => [:new, :create]
+    before_filter :get_transactional_messages, :only => [:index, :transactional]
+    before_filter :get_saved_messages, :only => [:index, :saved]
+    before_filter :get_receiver, :only => [:show, :preview]
+    
+    def index
+      respond_with @saved_messages, @transactional_messages
+    end
+
+    def saved
+      respond_with @saved_messages
+    end
+
+    def transactional
+      respond_with @transactional_messages
+    end
+
+    def show
+      respond_with @message
+    end
+
+    def preview
+      respond_with @message, :layout => Msg.email_layout
+    end
+
+    def new
+      respond_with @message
+    end
+
+    def create
+      @message.update_attributes(params[:message])
+      respond_with @message
+    end
+
+    def edit
+      respond_with @message
+    end
+
+    def update
+      @message.update_attributes(params[:message])
+      respond_with @message
+    end
+
+    def destroy
+      @message.destroy
+      head :ok
+    end
+
+  protected
+
+    def build_message
+      @message = Msg::Message.new(params[:message])
+    end
+
+    def get_message
+      @message = Msg::Message.find(params[:id])
+    end
+
+    def get_transactional_messages
+      @transactional_messages = Msg::Message.transactional
+    end
+
+    def get_saved_messages
+      @show = params[:show] || 10
+      @page = params[:page] || 1
+      @saved_messages = Msg::Message.saved.page(@page).per(@show)
+    end
+    
+    def get_receiver
+      klass = params[:receiver_type] || Msg.receiving_classes.first
+      if id = params[:receiver_id]
+        @receiver = klass.classify.constantize.find(id)
+      else
+        @receiver = klass.classify.constantize.first
+      end
+      raise ActiveRecord::RecordNotFound, "Cannot find a valid receiver for whom to preview message." unless @receiver
+    end
+
+  end
+end

data/app/controllers/msg/sendings_controller.rb

@@ -0,0 +1,58 @@
+module Msg
+  class SendingsController < Msg::EngineController
+    respond_to :html, :js
+
+    before_filter :get_message, :only => [:new, :create]
+    before_filter :get_sending, :only => [:show, :review]
+    before_filter :build_sending, :only => [:new, :create]
+    before_filter :get_sendings, :only => [:index]
+
+    def index
+      respond_with @sendings do |format|
+        format.js { render :partial => "report"}
+      end
+    end
+
+    def show
+      respond_with @sending
+    end
+    
+    def review
+      respond_with @sending, :layout => Msg.email_layout
+    end
+
+    def new
+      respond_with @sending
+    end
+
+    def create
+      @sending.update_attributes(params[:sending])
+      respond_with @sending
+    end
+
+    def destroy
+      @sending.destroy
+      head :ok
+    end
+
+  protected
+
+    def get_message
+      @message = Msg::Message.find(params[:message_id])
+    end
+
+    def build_sending
+      @sending = @message.sendings.build
+    end
+
+    def get_sending
+      @sending = Msg::Sending.find(params[:id])
+    end
+
+    def get_sendings
+      @show = params[:show] || 10
+      @page = params[:page] || 1
+      @sendings = Msg::Sending.order("created_at DESC").page(@page).per(@show)
+    end
+  end
+end

data/app/helpers/msg/msg_helper.rb

@@ -0,0 +1,40 @@
+module Msg
+  module MsgHelper
+    def shorten(text, length=64)
+      length = length[:length] if length.is_a?(Hash)
+      truncate(strip_tags(text), {:length => length, :separator => " "})
+    end
+
+    def action_menulink(thing, html_options={})
+      classname = thing.class.to_s.downcase.underscore.split('/').last
+      html_options.reverse_merge!({
+        :class => "",
+        :data => {:menu => "#{classname}_#{thing.id}"}
+      })
+      html_options[:class] << " menu"
+      link_to t(:edit), "#", html_options if editable?(thing)
+    end
+    
+    def action_menu(thing, locals={})
+      if editable?(thing)
+        type = thing.class.to_s.downcase.underscore
+        classname = type.split('/').last
+        locals[classname.to_sym] = thing
+        render :partial => "#{type.pluralize}/action_menu", :locals => locals
+      end
+    end
+
+    def visible?(thing)
+      admin? || privileged? || current_user.can_see?(thing)
+    end
+    
+    def editable?(thing)
+      admin? || current_user == thing.created_by
+    end
+
+    def deletable?(thing)
+      admin? || current_user == thing.created_by
+    end
+
+  end
+end

data/app/mailers/msg/devise_mailer.rb

@@ -0,0 +1,20 @@
+module Msg
+  class DeviseMailer < Devise::Mailer
+    default from: Msg.default_from_address, :bcc => Msg.email_bcc
+    layout Msg.email_layout
+
+    def confirmation_instructions(receiver, opts={})
+      @message = Msg::Message.find_by_function('confirmation_instructions')
+      @contents = @message.render_for(receiver)
+      super
+    end
+
+    def reset_password_instructions(receiver, opts={})
+      @message = Msg::Message.find_by_function('reset_password_instructions')
+      @contents = @message.render_for(receiver)
+      super
+    end
+
+
+  end
+end

data/app/mailers/msg/msg_mailer.rb

@@ -0,0 +1,23 @@
+module Msg
+  class MsgMailer < ActionMailer::Base
+    default from: Msg.default_from, :bcc => Msg.email_bcc
+    layout Msg.email_layout
+
+    # we send all messages through SES and use SNS to notify of bounces, so all the 
+    # return-path and VERP and other gubbins that we would normally need can be omitted
+    #
+    def message_in_envelope(envelope)
+      headers['Message-ID'] = envelope.email_id
+      @envelope = envelope
+      @message = envelope.message
+      @receiver = envelope.receiver
+      @contents = envelope.contents
+      mail({
+        :to => %{"#{@receiver.name}" <#{@receiver.email}>},
+        :from => envelope.from_address,
+        :subject => envelope.subject
+      })
+    end
+
+  end
+end

data/app/models/msg/bounce.rb

@@ -0,0 +1,19 @@
+module Msg
+  class Bounce < ActiveRecord::Base
+    attr_accessible :envelope, :bounce_type, :bounce_subtype, :raw_message, :reporter
+    belongs_to :envelope
+    validates :envelope, :presence => true
+    
+    scope :fatal, where(:bounce_type => "Permanent")
+    scope :transient, where(:bounce_type => "Transient")
+    
+    def fatal?
+      bounce_type == 'Permanent'
+    end
+
+    def transient?
+      bounce_type == 'Transient'
+    end
+    
+  end
+end

data/app/models/msg/envelope.rb

@@ -0,0 +1,56 @@
+module Msg
+  class Envelope < ActiveRecord::Base
+    attr_accessible :receiver, :sending
+    
+    belongs_to :sending
+    belongs_to :receiver, :polymorphic => true
+    has_many :bounces
+
+    validates :receiver, :presence => true
+    validates :sending, :presence => true
+    after_create :send_email
+
+    scope :opened, where("opened_at IS NOT NULL")
+
+    scope :bounced, select("msg_envelopes.*")
+                  .joins("INNER JOIN msg_bounces as mb ON mb.envelope_id = msg_envelopes.id")
+                  .having("count(mb.id) > 0")
+
+    def message
+      sending.message
+    end
+
+    def open!
+      update_column(:opened_at, Time.now)
+    end
+    
+    def status
+      if opened_at?
+        "read"
+      elsif bounces.any?
+        "bounced"
+      else
+        "unread"
+      end
+    end
+
+  protected
+
+    def send_email
+      # Record sending parameters for later reference. The message or receiver properties might change after this is sent.
+      self.email_id = "#{self.id}@#{Msg.sending_domain}"
+      self.subject = message.subject
+      self.from_address = message.from
+      self.to_address = receiver.email
+      # render the message for our receiver
+      self.contents = message.render_for(receiver)
+      # send it
+      Msg::MsgMailer.message_in_envelope(self).deliver
+      # note sending time
+      self.sent_at = Time.now
+      # and save our changes
+      self.save!
+    end
+
+  end
+end

data/app/models/msg/message.rb

@@ -0,0 +1,26 @@
+require 'mustache'
+
+module Msg
+  class Message < ActiveRecord::Base
+    attr_accessible :subject, :body, :function, :description, :transactional, :saved, :from_name, :from_address
+
+    has_many :sendings
+    belongs_to :created_by, :class_name => Msg.user_class
+
+    scope :transactional, where(:transactional => true)
+    scope :saved, where(:saved => true, :transactional => false)
+    scope :unsaved, where(:saved => false)
+
+    def from
+      name = from_name? ? from_name : Msg.default_from_name
+      address = from_address? ? from_address : Msg.default_from_address
+      "#{name} <#{address}>"
+    end
+    
+    def render_for(receiver)
+      values = receiver.for_email.reverse_merge(Msg.email_values)
+      Mustache.render(body, values)
+    end
+
+  end
+end