message_train 0.1.0

data/app/controllers/message_train/messages_controller.rb

@@ -0,0 +1,74 @@
+module MessageTrain
+  class MessagesController < MessageTrain::ApplicationController
+    before_filter :load_message, only: [:show, :edit, :update]
+
+    # GET /box/in/messages/1
+    def show
+      respond_to do |format|
+        format.json { render :show }
+      end
+    end
+
+    # GET /box/in/messages/new
+    def new
+      @message = @box.new_message(conversation_id: params[:conversation_id])
+    end
+
+    # GET /box/in/messages/1/edit
+    def edit
+      unless @message.draft
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    # POST /box/in/messages
+    def create
+      @message = @box.send_message(message_params)
+      if @box.errors.all.empty?
+        if @message.draft
+          redirect_to message_train.box_path(:drafts), alert: :message_saved_as_draft.l
+        else
+          redirect_to message_train.box_path(:sent), notice: :message_sent.l
+        end
+      else
+        flash[:error] = @box.message
+        render :new
+      end
+    end
+
+    # PATCH/PUT /box/in/messages/1
+    def update
+      unless @message.draft
+        raise ActiveRecord::RecordNotFound
+      end
+      @box.update_message(@message, message_params)
+      if @box.errors.all.empty?
+        if @message.draft
+          redirect_to message_train.box_conversation_url(@box, @message.conversation), alert: :message_saved_as_draft.l
+        else
+          redirect_to message_train.box_path(:sent), notice: :message_sent.l
+        end
+      else
+        flash[:error] = @box.message
+        render :edit
+      end
+    end
+
+  private
+    def load_message
+      @message = @box.find_message(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def message_params
+      params.require(:message).permit(
+          :conversation_id,
+          :subject,
+          :body,
+          :draft,
+          attachments: [:attachment],
+          recipients_to_save: MessageTrain.configuration.recipient_tables
+      )
+    end
+  end
+end

data/app/controllers/message_train/participants_controller.rb

@@ -0,0 +1,36 @@
+module MessageTrain
+  class ParticipantsController < MessageTrain::ApplicationController
+    before_filter :load_participants
+    before_filter :load_participant, only: :show
+
+    # GET /box/in/participants
+    def index
+      respond_to do |format|
+        format.json { render :index }
+      end
+    end
+
+    # GET /box/in/participants/1
+    def show
+      respond_to do |format|
+        format.json { render :show }
+      end
+    end
+
+    private
+
+      def load_participants
+        current_participant = send(MessageTrain.configuration.current_user_method)
+        method = MessageTrain.configuration.address_book_method
+        if current_participant.respond_to? method
+          @participants = current_participant.send(method)
+        else
+          @participants = current_participant.class.all
+        end
+      end
+
+      def load_participant
+        @participant = @participants.find(params[:id])
+      end
+  end
+end

data/app/helpers/message_train/application_helper.rb

@@ -0,0 +1,4 @@
+module MessageTrain
+  module ApplicationHelper
+  end
+end

data/app/helpers/message_train/boxes_helper.rb

@@ -0,0 +1,30 @@
+module MessageTrain
+  module BoxesHelper
+    def box_nav_item(box)
+      text = box.title
+      link = message_train.box_path(box.division)
+      if box.unread_count > 0
+        text << ' '
+        text << badge(box.unread_count.to_s, 'info pull-right')
+      end
+      nav_item text, link
+    end
+    def box_list_item(box, html_options = {})
+      render partial: 'message_train/boxes/list_item', locals: { box: box, html_options: html_options }
+    end
+    def boxes_widget
+      boxes = send(MessageTrain.configuration.current_user_method).all_boxes
+      render partial: 'message_train/boxes/widget', locals: { boxes: boxes }
+    end
+    def boxes_dropdown_list
+      boxes = send(MessageTrain.configuration.current_user_method).all_boxes
+      render partial: 'message_train/boxes/dropdown_list', locals: { boxes: boxes }
+    end
+    def box_participant_name(participant)
+      participant.send(MessageTrain.configuration.name_columns[participant.class.table_name.to_sym])
+    end
+    def box_participant_slug(participant)
+      participant.send(MessageTrain.configuration.slug_columns[participant.class.table_name.to_sym])
+    end
+  end
+end

data/app/helpers/message_train/conversations_helper.rb

@@ -0,0 +1,73 @@
+module MessageTrain
+  module ConversationsHelper
+    def conversation_senders(conversation)
+      conversation.messages.collect { |x| box_participant_name(x.sender) }.uniq.to_sentence
+    end
+
+    def conversation_class(box, conversation)
+      css_classes = []
+
+      if conversation.includes_unread_for?(@box.parent)
+        css_classes << 'unread'
+      else
+        css_classes << 'read'
+      end
+
+      if conversation.includes_drafts_by?(@box.parent)
+        css_classes << 'draft'
+      end
+
+      unless conversation.includes_undeleted_for?(box.parent)
+        css_classes << 'hide'
+      end
+
+      if box.division == :trash
+        unless conversation.includes_trashed_for?(box.parent)
+          css_classes << 'hide'
+        end
+      else
+        unless conversation.includes_untrashed_for?(box.parent)
+          css_classes << 'hide'
+        end
+        if box.division == :ignored
+          unless conversation.is_ignored?(box.parent)
+            css_classes << 'hide'
+          end
+        else
+          if conversation.is_ignored?(box.parent)
+            css_classes << 'hide'
+          end
+        end
+      end
+      css_classes.uniq.join(' ')
+    end
+
+    def conversation_trashed_toggle(conversation)
+      render partial: 'message_train/conversations/trashed_toggle', locals: { conversation: conversation }
+    end
+
+    def conversation_read_toggle(conversation)
+      render partial: 'message_train/conversations/read_toggle', locals: { conversation: conversation }
+    end
+
+    def conversation_ignored_toggle(conversation)
+      render partial: 'message_train/conversations/ignored_toggle', locals: { conversation: conversation }
+    end
+
+    def conversation_deleted_toggle(conversation)
+      render partial: 'message_train/conversations/deleted_toggle', locals: { conversation: conversation }
+    end
+
+    def conversation_toggle(conversation, icon, mark_to_set, method, title, options = {})
+      options[:remote] = true
+      options[:method] = method
+      options[:title] = title
+      render partial: 'message_train/conversations/toggle', locals: {
+                                                            conversation: conversation,
+                                                            icon: icon,
+                                                            mark_to_set: mark_to_set,
+                                                            options: options
+                                                        }
+    end
+  end
+end

data/app/helpers/message_train/messages_helper.rb

@@ -0,0 +1,58 @@
+module MessageTrain
+  module MessagesHelper
+    def message_class(box, message)
+      css_classes = []
+
+      if message.is_unread_for?(@box.parent)
+        css_classes << 'unread panel-info'
+      else
+        css_classes << 'read'
+      end
+
+      if message.draft
+        css_classes << 'draft'
+      end
+
+      if box.division == :trash
+        unless message.is_trashed_for?(box.parent)
+          css_classes << 'hide'
+        end
+      else
+        unless message.is_untrashed_for?(box.parent)
+          css_classes << 'hide'
+        end
+      end
+      css_classes.join(' ')
+    end
+
+    def message_trashed_toggle(message)
+      render partial: 'message_train/messages/trashed_toggle', locals: { message: message }
+    end
+
+    def message_read_toggle(message)
+      render partial: 'message_train/messages/read_toggle', locals: { message: message }
+    end
+
+    def message_deleted_toggle(message)
+      render partial: 'message_train/messages/deleted_toggle', locals: { message: message }
+    end
+
+    def message_toggle(message, icon, mark_to_set, title, options = {})
+      options[:remote] = true
+      options[:id] = "mark_#{mark_to_set}_#{message.id}"
+      options[:class] = "mark-link"
+      options[:method] = :put
+      options[:title] = title
+      render partial: 'message_train/messages/toggle', locals: {
+                                                            message: message,
+                                                            icon: icon,
+                                                            mark_to_set: mark_to_set,
+                                                            options: options
+                                                        }
+    end
+
+    def message_recipients(message)
+      message.recipients.collect { |x| box_participant_name(x) }.to_sentence
+    end
+  end
+end

data/app/models/message_train/attachment.rb

@@ -0,0 +1,17 @@
+module MessageTrain
+  class Attachment < ActiveRecord::Base
+    belongs_to :message
+    has_attached_file :attachment
+    validates_attachment_presence :attachment
+    validates_attachment_content_type :attachment, content_type: [
+                                        "application/pdf",
+                                        "application/vnd.ms-excel",
+                                        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                                        "application/msword",
+                                        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                                        "application/rtf",
+                                        "text/plain",
+                                        /^image\/.*$/
+                                    ]
+  end
+end

data/app/models/message_train/box.rb

@@ -0,0 +1,268 @@
+module MessageTrain
+  class Box
+    include ActiveModel::Model
+    attr_accessor :parent, :division, :errors, :results
+    alias_method :id, :division
+
+    def initialize(parent, division)
+      @parent = parent
+      @division = division
+      @results = Results.new(self)
+      @errors = Errors.new(self)
+    end
+
+    def marks
+      { conversations: nil }
+    end
+
+    def to_param
+      division.to_s
+    end
+
+    def unread_count
+      conversations(unread: true).count
+    end
+
+    def conversations(options = {})
+      found = parent.conversations(division).with_undeleted_for(parent)
+      if options[:read] == false || options[:unread]
+        found = found.with_unread_for(parent)
+      end
+      if division == :trash
+        found = found.with_trashed_for(parent)
+      else
+        found = found.with_untrashed_for(parent)
+        if division == :drafts
+          found = found.with_drafts_by(parent)
+        else
+          found = found.with_ready_for(parent)
+        end
+        if division == :ignored
+          found = found.ignored(parent)
+        else
+          found = found.unignored(parent)
+        end
+      end
+      found
+    end
+
+    def find_conversation(id)
+      parent.all_conversations.find(id)
+    end
+
+    def find_message(id)
+      parent.all_messages.find(id)
+    end
+
+    def new_message(args = {})
+      if args[:conversation_id].nil?
+        message = MessageTrain::Message.new(args)
+      else
+        conversation = find_conversation(args[:conversation_id])
+        message = conversation.messages.build(args)
+        message.subject = "Re: #{conversation.subject}"
+        recipient_arrays = {}
+        conversation.default_recipients_for(parent).each do |recipient|
+          table_name = recipient.class.table_name
+          recipient_arrays[table_name] ||= []
+          recipient_arrays[table_name] << recipient.send(MessageTrain.configuration.slug_columns[table_name.to_sym])
+        end
+        recipient_arrays.each do |key, array|
+          message.recipients_to_save[key] = array.join(', ')
+        end
+      end
+      message
+    end
+
+    def send_message(attributes)
+      message_to_send = MessageTrain::Message.new attributes
+      message_to_send.sender = parent
+      unless message_to_send.save
+        errors.add(message_to_send, message_to_send.errors.full_messages.to_sentence)
+      end
+      message_to_send
+    end
+
+    def update_message(message_to_update, attributes)
+      attributes.delete(:sender)
+      if message_to_update.sender == parent
+        message_to_update.update(attributes)
+        unless message_to_update.errors.empty?
+          errors.add(message_to_update, message_to_update.errors.full_messages.to_sentence)
+        end
+      else
+        errors.add(message_to_update, :access_to_message_id_denied.l(id: message_to_update.id))
+      end
+      message_to_update.reload
+    end
+
+    def ignore(object)
+      case object.class.name
+        when 'Hash'
+          ignore object.values
+        when 'Array'
+          object.collect { |item| ignore(item) }.uniq == [true]
+        when 'String', 'Fixnum'
+          id = object.to_i
+          object = parent.all_conversations.find_by_id(id)
+          if object.nil?
+            errors.add(self, :class_id_not_found_in_box.l(class: 'Conversation', id: id.to_s))
+          else
+            ignore(object)
+          end
+        when 'MessageTrain::Conversation'
+          if authorize(object)
+            if object.set_ignored(parent)
+              results.add(object, :update_successful.l)
+            else
+              errors.add(object, object.errors.full_messages.to_sentence)
+            end
+          else
+            false
+          end
+        else
+        errors.add(self, :cannot_ignore_type.l(type: object.class.name))
+      end
+    end
+
+    def unignore(object)
+      case object.class.name
+        when 'Hash'
+          unignore object.values
+        when 'Array'
+          object.collect { |item| unignore(item) }.uniq == [true]
+        when 'String', 'Fixnum'
+          id = object.to_i
+          object = parent.all_conversations.find_by_id(id)
+          if object.nil?
+            errors.add(self, :class_id_not_found_in_box.l(class: 'Conversation', id: id.to_s))
+          else
+            unignore(object)
+          end
+        when 'MessageTrain::Conversation'
+          if authorize(object)
+            if object.set_unignored(parent)
+              results.add(object, :update_successful.l)
+            else
+              errors.add(object, object.errors.full_messages.to_sentence)
+            end
+          else
+            false
+          end
+        else
+        errors.add(self, :cannot_ignore_type.l(type: object.class.name))
+      end
+    end
+
+    def title
+      "box_title_#{division.to_s}".to_sym.l
+    end
+
+    def message
+      if !errors.all.empty?
+        errors.all.collect { |x| x[:message] }.uniq.to_sentence
+      elsif results.all.empty?
+        :nothing_to_do.l
+      else
+        results.all.collect { |x| x[:message] }.uniq.to_sentence
+      end
+    end
+
+    def mark(mark_to_set, objects)
+      objects.each do |key, object|
+        if object.present?
+          case object.class.name
+            when 'Hash'
+              mark(mark_to_set, { key => object.values } )
+            when 'Array'
+              object.collect { |item| mark(mark_to_set, key => item) }.uniq == [true]
+            when 'String', 'Fixnum'
+              id = object.to_i
+              object = parent.send("all_#{key}".to_sym).find_by_id(id)
+              if object.nil?
+                errors.add(self, :class_id_not_found_in_box.l(class: key.to_s.classify, id: id.to_s))
+              else
+                mark(mark_to_set, key => object)
+              end
+            when 'MessageTrain::Conversation', 'MessageTrain::Message'
+              if authorize(object)
+                if object.mark(mark_to_set, parent)
+                  results.add(object, :update_successful.l)
+                else
+                  errors.add(object, object.errors.full_messages.to_sentence)
+                end
+              else
+                false
+              end
+            else
+            errors.add(self, :cannot_mark_type.l(type: object.class.name))
+          end
+        end
+      end
+    end
+
+    def authorize(object)
+      case object.class.name
+        when 'MessageTrain::Conversation'
+          if object.includes_receipts_for? parent
+            true
+          else
+            errors.add(object, :access_to_conversation_id_denied.l(id: object.id))
+          end
+        when 'MessageTrain::Message'
+          if object.receipts.for(parent).any?
+            true
+          else
+            errors.add(object, :access_to_message_id_denied.l(id: object.id))
+          end
+        else
+          errors.add(object, :dont_know_how_to_mark_object.l(object: object.class.name))
+      end
+    end
+
+    class Results
+      attr_accessor :items, :box
+
+      def initialize(box)
+        @items = []
+        @box = box
+      end
+
+      def add(object, message)
+        item = {}
+        if object.is_a? MessageTrain::Box
+          item[:css_id] = 'box'
+          item[:path] = MessageTrain::Engine.routes.path_for({
+                                                             controller: 'message_train/boxes',
+                                                             action: :show,
+                                                             division: object.division
+                                                         })
+        elsif object.new_record?
+          item[:css_id] = "#{object.class.table_name.singularize}"
+          item[:path] = nil
+        else
+          item[:css_id] = "#{object.class.table_name.singularize}_#{object.id.to_s}"
+          item[:path] = MessageTrain::Engine.routes.path_for({
+                                                             controller: object.class.table_name.gsub('message_train_', 'message_train/'),
+                                                             action: :show,
+                                                             box_division: box.division,
+                                                             id: object.id
+                                                         })
+        end
+        item[:message] = message
+        items << item
+        true
+      end
+
+      def all
+        items
+      end
+    end
+    class Errors < Results
+      def add(object, message)
+        super object, message
+        false
+      end
+    end
+  end
+end

data/app/models/message_train/conversation.rb

@@ -0,0 +1,101 @@
+module MessageTrain
+  class Conversation < ActiveRecord::Base
+    has_many :messages
+    has_many :ignores
+    has_many :receipts, through: :messages
+
+    # Scopes
+    default_scope { order('updated_at DESC') }
+    scope :ignored, ->(participant) { where('id IN (?)', ignored_ids_for(participant))}
+    scope :unignored, ->(participant) { where('NOT(id IN (?))', ignored_ids_for(participant))}
+    scope :filter_by_receipt_method_ids, ->(receipt_method, participant) {
+      all.collect { |x| x.receipts.send(receipt_method, participant).conversation_ids }.flatten.uniq
+    }
+    scope :filter_by_receipt_method, ->(receipt_method, participant) {
+      where('id IN (?)', filter_by_receipt_method_ids(receipt_method, participant))
+    }
+    scope :with_drafts_by, ->(participant) {
+      ids_with_drafts = all.collect { |x| x.messages.drafts.by(participant).conversation_ids }.flatten.uniq
+      where('id IN (?)', ids_with_drafts)
+    }
+    scope :with_ready_for, ->(participant) {
+      ids_with_ready = all.collect { |x| x.messages.ready.with_receipts_for(participant).conversation_ids }.flatten.uniq
+      where('id IN (?)', ids_with_ready)
+    }
+
+    def default_recipients_for(sender)
+      recipients = messages.with_receipts_for(sender)
+                       .collect { |x| x.receipts.collect { |y| y.recipient } }
+                       .flatten
+                       .uniq
+      recipients.delete(sender)
+      recipients
+    end
+
+    def set_ignored(participant)
+      ignores.first_or_create!(participant: participant)
+    end
+
+    def set_unignored(participant)
+      ignores.where(participant: participant).destroy_all
+    end
+
+    def is_ignored?(participant)
+      if ignores.empty?
+        false
+      else
+        !ignores.find_all_by_participant(participant).empty?
+      end
+    end
+
+    def mark(mark, participant)
+      messages.mark(mark, participant)
+    end
+
+    def includes_drafts_by?(participant)
+      !messages.drafts_by(participant).empty?
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      # the first argument is a Symbol, so you need to_s it if you want to pattern match
+      if method_sym.to_s =~ /^includes_(.*_(by|to|for))\?$/
+        !receipts.send($1.to_sym, arguments.first).empty?
+      else
+        super
+      end
+    end
+
+    def self.method_missing(method_sym, *arguments, &block)
+      # the first argument is a Symbol, so you need to_s it if you want to pattern match
+      if method_sym.to_s =~ /^with_((.*)_(by|to|for))$/
+        self.filter_by_receipt_method($1.to_sym, arguments.first)
+      else
+        super
+      end
+    end
+
+    # It's important to know Object defines respond_to to take two parameters: the method to check, and whether to include private methods
+    # http://www.ruby-doc.org/core/classes/Object.html#M000333
+    def respond_to?(method_sym, include_private = false)
+      if method_sym.to_s =~ /^includes_((.*)_(by|to|for))\?$/
+        true
+      else
+        super
+      end
+    end
+
+    def self.respond_to?(method_sym, include_private = false)
+      if method_sym.to_s =~ /^(.*)_(by|to|for)$/
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+      def self.ignored_ids_for(participant)
+        MessageTrain::Ignore.find_all_by_participant(participant).conversation_ids
+      end
+  end
+end

data/app/models/message_train/ignore.rb

@@ -0,0 +1,18 @@
+module MessageTrain
+  class Ignore < ActiveRecord::Base
+    belongs_to :participant, polymorphic: true
+    belongs_to :conversation
+
+    validates_presence_of :conversation, :participant
+
+    scope :find_all_by_participant, ->(participant) { where('participant_type = ? AND participant_id = ?', participant.class.name, participant.id) }
+
+    def self.conversation_ids
+      all.collect { |y| y.conversation_id }
+    end
+
+    def self.conversations
+      MessageTrain::Conversation.where('id IN (?)', conversation_ids )
+    end
+  end
+end