discuss 0.0.1

data/app/controllers/discuss/application_controller.rb

@@ -0,0 +1,11 @@
+module Discuss
+  class ApplicationController < ::ApplicationController
+    before_action :discuss_current_user
+
+    private
+    def discuss_current_user
+      current_user
+    end
+    helper_method :discuss_current_user
+  end
+end

data/app/controllers/discuss/mailboxes_controller.rb

@@ -0,0 +1,30 @@
+require_dependency 'discuss/application_controller'
+
+module Discuss
+  class MailboxesController < ApplicationController
+    before_action :check_mailbox_params, only: :show
+
+    def show
+      @messages = Mailbox.new(discuss_current_user).send mailbox_name
+    end
+
+    def empty_trash
+      Mailbox.new(discuss_current_user).empty_trash!
+      redirect_to mailbox_path(:inbox), notice: 'Trash has been emptied'
+    end
+
+    private
+    def check_mailbox_params
+      redirect_to mailbox_path(:inbox) unless valid_mailbox?
+    end
+
+    def valid_mailbox?
+      %w{inbox outbox drafts trash}.include? params[:mailbox]
+    end
+
+    def mailbox_name
+      params[:mailbox]
+    end
+    helper_method :mailbox_name
+  end
+end

data/app/controllers/discuss/messages_controller.rb

@@ -0,0 +1,85 @@
+require_dependency 'discuss/application_controller'
+
+module Discuss
+  class MessagesController < ApplicationController
+    before_action :message, only: [:show, :update, :destroy]
+    before_action :can_view_message, only: [:show, :edit, :destroy]
+
+    def new
+      @message = discuss_current_user.messages.new
+    end
+
+    def show
+      redirect_to edit_message_path(message) unless message.received? || message.sent?
+    end
+
+    def create
+      @message = Message.new(message_params.merge(user: discuss_current_user))
+      if @message.save
+        send_message
+      else
+        render :new
+      end
+    end
+
+    # [e] avoiding validation exception. Should be done nicer
+    def reply
+      @message = Message.find(params[:message_id])
+      if params[:message][:body]
+        @message.reply! message_params.merge(user: discuss_current_user)
+        redirect_to mailbox_path(:inbox), notice: 'Reply sent'
+      else
+        redirect_to message, alert: "Don't you want to say something?"
+      end
+    end
+
+    def edit
+      redirect_to message unless message.unsent?
+    end
+
+    def update
+      message.update(message_params)
+      send_message
+    end
+
+    def trash
+      @message = Message.find(params[:message_id])
+      @message.trash!
+      redirect_to mailbox_path(:inbox), notice: 'Message moved to trash'
+    end
+
+    def destroy
+      message.delete!
+      redirect_to mailbox_path(:inbox), notice: 'Message deleted'
+    end
+
+    private
+    def message
+      @message ||= Message.find(params[:id])
+    end
+    helper_method :message
+
+    def message_params
+      params.require(:message).permit(:subject, :body, :draft, draft_recipient_ids: [])
+    end
+
+    def send_message
+      message.send!
+      notice = message.sent? ? 'Yay! Message sent' : 'Draft saved'
+      redirect_to mailbox_path(:inbox), notice: notice
+    end
+
+    def mailbox_name
+      params[:mailbox] || message.mailbox.to_s
+    end
+    helper_method :mailbox_name
+
+    def can_view_message
+      redirect_to mailbox_path(:inbox), notice: 'Unauthorised!' unless mine?
+    end
+
+    def mine?
+      message.user == discuss_current_user
+    end
+  end
+end

data/app/helpers/discuss/application_helper.rb

@@ -0,0 +1,7 @@
+module Discuss
+  module ApplicationHelper
+    def message_person(mailbox_name, message)
+      mailbox_name == 'inbox' ? message.sender : message.recipient_list.join(', ')
+    end
+  end
+end

data/app/models/discuss/conversation.rb

@@ -0,0 +1,29 @@
+# conversation should be in the context of a user,
+# so we grab only the messages the user owns
+# but we are defaulting to the message user just in case
+module Discuss
+  class Conversation
+    attr_accessor :message, :user
+
+    def initialize(message, user=nil)
+      @message = message
+      @user = user || message.user
+    end
+
+    def root
+      message.root
+    end
+
+    def for_user
+      all.by_user(user)
+    end
+
+    def all
+      root.subtree
+    end
+
+    def trash_conversation!
+      for_user.each { |message| message.trash! }
+    end
+  end
+end

data/app/models/discuss/mailbox.rb

@@ -0,0 +1,33 @@
+# @mailbox ||= Mailbox.new(current_user)
+
+module Discuss
+  class Mailbox
+    attr_accessor :user
+
+    def initialize(user)
+      @user = user
+    end
+
+    def inbox
+      Message.inbox(user)
+    end
+
+    def outbox
+      Message.outbox(user)
+    end
+
+    def drafts
+      Message.drafts(user)
+    end
+
+    def trash
+      Message.trash(user)
+    end
+
+    def empty_trash!
+      trash.each { |message| message.delete! }
+    end
+  end
+end
+
+

data/app/models/discuss/message.rb

@@ -0,0 +1,135 @@
+require 'thread'
+
+module Discuss
+  class Message < ActiveRecord::Base
+    has_ancestry
+
+    attr_accessor :draft
+    serialize :draft_recipient_ids, Array
+
+    belongs_to :user
+
+    validates :body, :user_id, presence: true
+    validate :lock_down_attributes, on: :update
+
+    scope :ordered,      -> { order('created_at asc') }
+    scope :active,       -> { not_trashed.not_deleted }
+
+    scope :draft,        -> { where('sent_at is NULL') }
+    scope :not_draft,    -> { where('sent_at is not NULL')  }
+
+    scope :sent,         -> { where('sent_at is not NULL') }
+    scope :unsent,       -> { where('sent_at is NULL')  }
+
+    scope :received,     -> { where('received_at is not NULL') }
+    scope :not_received, -> { where('received_at is NULL') }
+
+    scope :trashed,      -> { where('trashed_at is not NULL') }
+    scope :not_trashed,  -> { where('trashed_at is NULL') }
+
+    scope :deleted,      -> { where('deleted_at is not NULL') }
+    scope :not_deleted,  -> { where('deleted_at is NULL') }
+
+    scope :by_user, lambda { |user| where(user_id: user.id) }
+    scope :inbox,   lambda { |user| by_user(user).active.received }
+    scope :outbox,  lambda { |user| by_user(user).active.sent }
+    scope :drafts,  lambda { |user| by_user(user).active.draft.not_received }
+    scope :trash,   lambda { |user| by_user(user).trashed.not_deleted }
+
+    def active?
+      !trashed? && !deleted?
+    end
+
+    def sender
+      sent? ? user : parent.user
+    end
+
+    def recipients
+      sent? ? children.collect(&:user) : parent.recipients
+    end
+
+    def recipients= users
+      users.each { |u| draft_recipient_ids << u.id }
+    end
+
+    def recipient_list
+      draft_recipient_ids.reject(&:blank?).map {|id| User.find id}
+    end
+
+    def mailbox
+      case
+      when sent? then :outbox
+      when received? then :inbox
+      when !new_record? && unsent? then :drafts
+      when trashed? then :trash
+      else
+        :compose
+      end
+    end
+
+    def send!
+      lock.synchronize do
+        Discuss::MessageSender.new(self).run unless draft?
+      end
+    end
+
+    def reply! options={}
+      if parent
+        reply = children.create!(subject: options.fetch(:subject, subject),
+                                 body: options.fetch(:body, nil),
+                                 user: user,
+                                 recipients: [parent.user])
+        reply.send!
+      end
+    end
+
+    def receive!
+      update(received_at: Time.zone.now)
+    end
+
+    def read!
+      update(read_at: Time.zone.now)
+    end
+
+    def trash!
+      update(trashed_at: Time.zone.now)
+    end
+
+    def delete!
+      update(deleted_at: Time.zone.now)
+    end
+
+    %w[sent received trashed deleted read].each do |act|
+      define_method "#{act}?" do
+        self.send(:"#{act}_at").present?
+      end
+    end
+
+    def uneditable?
+      !editable?
+    end
+
+    def unsent?
+      !sent?
+    end
+
+    # passed in from the compose form
+    def draft?
+      self.draft == '1'
+    end
+
+    def sent_date
+      sent_at || received_at
+    end
+
+    private
+    def lock_down_attributes
+      return if editable?
+      errors.add(:base, 'Cannot edit') unless deleted_at_changed? || trashed_at_changed? || read_at_changed?
+    end
+
+    def lock
+      @lock ||= Mutex.new
+    end
+  end
+end

data/app/services/discuss/message_sender.rb

@@ -0,0 +1,33 @@
+class Discuss::MessageSender
+  attr_reader :message, :recipients
+
+  delegate :body, to: :message
+  delegate :subject, to: :message
+
+  def initialize message
+    @message = message
+    @recipients = message.recipient_list
+  end
+
+  def run
+    deliver!
+  end
+
+  private
+  def set_as_sent
+    message.update_column(:sent_at, Time.zone.now)
+    message.update_column(:editable, false)
+  end
+
+  def deliver!
+    if recipients.any? && message.unsent?
+      set_as_sent
+      recipients.each { |user| deliver_to user }
+    end
+  end
+
+  def deliver_to user
+    attrs = {subject: subject, body: body, user: user, received_at: Time.zone.now, editable: false }
+    message.children.create(attrs)
+  end
+end

data/app/views/discuss/mailboxes/show.html.haml

@@ -0,0 +1,24 @@
+%section#discuss(class="mailboxes #{mailbox_name}")
+  %h2= mailbox_name.humanize
+
+  .summary= pluralize(@messages.size, 'message')
+
+  = render 'discuss/shared/nav'
+
+  %section.messages
+    - if @messages.any?
+      %table
+        %tbody
+          - @messages.each do |message|
+            %tr[message]
+              %td.user
+                = link_to message_person(mailbox_name, message), mailbox_message_path(message.mailbox, message)
+              %td.preview
+                = link_to message.try(:subject), mailbox_message_path(message.mailbox, message)
+                = link_to truncate(message.body, length: 50), mailbox_message_path(message.mailbox, message)
+              %td.sent_at
+                = message.created_at.to_date
+
+      - if mailbox_name == 'trash'
+        = form_tag empty_trash_path do
+          = submit_tag 'Empty trash'

data/app/views/discuss/messages/_form.html.haml

@@ -0,0 +1,18 @@
+%section#discuss(class = "#{mailbox_name}")
+  %h2= mailbox_name.humanize
+  = render 'discuss/shared/nav'
+
+  .compose.message
+    = simple_form_for @message do |f|
+      - if @message.errors.any?
+        %p.errors This message has #{pluralize(@message.errors.count, 'error')}
+
+      - # TODO review User.all query
+      - # TODO if no first_name and last_name, display user's email
+      = f.input :draft_recipient_ids, collection: User.all.reject{|u| u == discuss_current_user }, input_html: {class: 'chosen', multiple: true}, label: 'Recipients'
+      = f.input :subject
+      = f.input :body, required: false, label: 'Your message'
+      = f.input :draft, as: :boolean
+
+      = f.submit 'Send message'
+

data/app/views/discuss/messages/edit.html.haml

@@ -0,0 +1 @@
+= render 'form'

data/app/views/discuss/messages/new.html.haml

@@ -0,0 +1 @@
+= render 'form'

data/app/views/discuss/messages/show.html.haml

@@ -0,0 +1,28 @@
+%section#discuss(class = "#{mailbox_name}")
+  %h2= mailbox_name.humanize
+
+  = render 'discuss/shared/nav'
+
+  .message
+    %ul.headers
+      %li.subject Subject: #{message.try(:subject)}
+      %li.sender Sender: #{message.sender}
+      %li.sent_at Date: #{message.sent_date.to_date}
+      - # Do we want recipient names to be links? or have any data attributes like the user.id?
+      %li.recipients Recipients: #{message.recipients.join(', ')}
+
+    .body= message.body
+
+    - unless message.trashed?
+      .move_to_trash
+        = simple_form_for @message, url: message_trash_path(@message), method: :post do |f|
+          = f.submit 'Move to trash'
+
+    - if message.received?
+      .compose.reply
+        %h3 Reply
+        = simple_form_for @message, url: message_reply_path(@message), method: :post do |f|
+          = f.input :subject, input_html: { value: "Re: #{@message.subject}" }
+          = f.input :body, required: false, label: 'Your message', input_html: { value: '' }
+          = f.input :draft, as: :boolean
+          = f.submit 'Reply'