message_train 0.1.7 → 0.2.0

data/app/views/message_train/messages/_message.html.haml

@@ -10,11 +10,10 @@
         = link_to "#message_#{message.id}_collapse", aria: { controls: "message_#{message.id}_collapse", expanded: 'true' }, data: { parent: '#accordion', toggle: 'collapse' }, role: "button" do
           %span.caret
           = :message_draft.l
-          %small= message.created_at
+          %small= message.updated_at
     .panel-collapse.collapse.in{aria: { labelledby: "message_#{message.id}_heading" }, role: "tabpanel", id: "message_#{message.id}_collapse"}
       .panel-body
         = render partial: 'message_train/messages/form', locals: { message: message }
-
 - else
   .panel.panel-default{ class: message_class(@box, message), id: "message_train_message_#{message.id}", data: { mark_path: message_train.box_conversation_path(@box.division, id: message.conversation_id, objects: { 'messages' => {message.id.to_s => message.id.to_s} }) } }
     .panel-heading{role: "tab", id: "message_#{message.id}_heading"}
@@ -27,9 +26,20 @@
         = link_to "#message_#{message.id}_collapse", aria: { controls: "message_#{message.id}_collapse", expanded: 'true' }, data: { parent: '#accordion', toggle: 'collapse' }, role: "button" do
           %span.caret
           = :from_sender.l(sender: message.sender.display_name)
-          %small= message.created_at
+          %small= message.updated_at
     .panel-collapse.collapse.in{aria: { labelledby: "message_#{message.id}_heading" }, role: "tabpanel", id: "message_#{message.id}_collapse"}
       .panel-body
         %p= :to_recipient.l(recipient: message_recipients(message))
         %p.lead= message.subject
-        = message.body
+        = sanitize message.body
+        - if message.attachments.any?
+          .row.attachment-thumbnails
+            - for attachment in message.attachments
+              .col-md-4
+                = attachment_link(attachment)
+      - if @box.parent.allows_sending_by?(@box_user)
+        .panel-footer
+          - if @collective.nil?
+            = link_to :reply.l, message_train.new_box_message_path(@box, conversation_id: message.conversation_id), class: 'btn btn-primary'
+          - else
+            = link_to :reply.l, message_train.new_collective_box_message_path(@collective.path_part, @box, conversation_id: message.conversation_id), class: 'btn btn-primary'

data/app/views/message_train/messages/_read_toggle.html.haml

@@ -1,4 +1,4 @@
-- if message.is_unread_for?(@box.parent)
+- if message.is_unread_for?(@box.participant)
   = message_toggle message, 'eye-open', :read, :mark_as_name.l(name: :read.l)
 - else
   = message_toggle message, 'eye-close', :unread, :mark_as_name.l(name: :unread.l)

data/app/views/message_train/messages/_trashed_toggle.html.haml

@@ -1,4 +1,4 @@
-- if message.is_untrashed_for?(@box.parent)
+- if message.is_untrashed_for?(@box.participant)
   = message_toggle message, 'trash', :trash, :mark_as_name.l(name: :trashed.l), data: { confirm: :are_you_sure.l}
 - else
   = message_toggle message, 'inbox', :untrash, :mark_as_name.l(name: :untrashed.l)

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

@@ -1,2 +1,2 @@
-- add_title 'Edit Draft'
+- add_title :edit_draft.l
 = render partial: 'form', locals: { message: @message }

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

@@ -1,2 +1,5 @@
-- add_title 'New Message'
+- if @message.conversation_id.nil?
+  - add_title :new_message.l
+- else
+  - add_title :reply.l
 = render partial: 'form', locals: { message: @message }

data/app/views/message_train/participants/_field.html.haml

@@ -1,4 +1,4 @@
 .form-group
   %label.control-label= "#{field_name.to_s.singularize.humanize.titleize} Recipients"
   .recipient-input.tag-list{ data: { field_name: "message[recipients_to_save][#{field_name}]", model: field_name }, id: "message_recipients_to_save_#{field_name}"  }
-    .tag-data= message.recipients_to_save[field_name]
+    .tag-data= message.recipients_to_save[field_name.to_s]

data/app/views/message_train/participants/_prefilled_field.html.haml

@@ -0,0 +1,4 @@
+- field_name = recipient.class.table_name.to_sym
+%p.lead
+  = :to_recipient.l(recipient: collective_name(@collective))
+  = hidden_field_tag "message[recipients_to_save][#{field_name}]", collective_slug(recipient)

data/app/views/message_train/receipt_mailer/notification_email.html.haml

@@ -0,0 +1,13 @@
+%h1
+  = @heading
+- if @recipient == @through
+  %p
+    = :at_time_you_received_a_message.l(time: @receipt.created_at, subject: @receipt.message.subject, path: message_train.box_conversation_path(:in, @receipt.message.conversation))
+  %p{ style: 'font-size: .8rem; color: #666' }
+    = :unsubscribe_from_option.l(from: :your_inbox.l)
+    = link_to :manage_your_email_notifications.l, message_train.unsubscribes_url
+- else
+  %p= :at_time_through_received_a_message.l(time: @receipt.created_at, through: @through_name, subject: @receipt.message.subject, path: message_train.collective_box_conversation_path(@through, :in, @receipt.message.conversation))
+  %p{ style: 'font-size: .8rem; color: #666' }
+    = :unsubscribe_from_option.l(from: @through_name)
+    = link_to :manage_your_email_notifications.l, message_train.unsubscribes_url

data/app/views/message_train/unsubscribes/index.html.haml

@@ -0,0 +1,10 @@
+- add_title :manage_your_email_notifications.l
+%table#subscriptions.table.table-bordered.table-condensed
+  - @subscriptions.each do |subscription|
+    %tr.subscription
+      %td= subscription[:from_name]
+      %td
+        - if subscription[:unsubscribe].nil?
+          = button_to :disable_notifications.l, message_train.unsubscribes_path(unsubscribe: { from_type: subscription[:from_type], from_id: subscription[:from_id] }), class: 'btn btn-danger', id: "unsubscribe-#{subscription[:from_type].downcase}-#{subscription[:from_id]}", confirm: :are_you_sure.l
+        - else
+          = button_to :enable_notifications.l, message_train.unsubscribe_path(subscription[:unsubscribe].id), method: :delete, class: 'btn btn-primary', id: "remove-unsubscribe-#{subscription[:unsubscribe].id}"

data/config/environment.rb

@@ -0,0 +1 @@
+ActionMailer::Base.register_template_extension('haml')

data/config/locales/en.yml

@@ -3,48 +3,90 @@ en:
     attributes:
       'message_train/message':
         recipients_to_save: 'Recipient'
+      'message_train/attachment':
+        attachment_file_name: 'File'
+  time:
+    formats:
+      fuzzy_today: '%l:%M %p'
+      fuzzy_this_week: '%a %l:%M %p'
+      fuzzy_date_without_year: '%b %-d'
+      fuzzy_date: '%b %-d, %Y'
+  access_to_that_box_denied: 'Access to that box denied'
   access_to_conversation_id_denied: "Access to Conversation %{id} denied"
   access_to_message_id_denied: "Access to Message %{id} denied"
   access_to_receipt_id_denied: "Access to Receipt %{id} denied"
+  add_attachment: 'Add Attachment'
   all: 'All'
   are_you_sure: 'Are you sure?'
+  at_time_you_received_a_message: "At %{time}, you received a message: <a href=\"%{path}\">%{subject}</a>"
+  at_time_through_received_a_message: "At %{time}, %{through} received a message: <a href=\"%{path}\">%{subject}</a>"
+  attachment_preview: 'Attachment Preview'
+  attachments: 'Attachments'
   box_title_in: 'Inbox'
-  box_title_sent: 'Sent Messages'
-  box_title_all: 'All Messages'
+  box_title_sent: 'Sent'
+  box_title_all: 'All'
   box_title_drafts: 'Drafts'
   box_title_trash: 'Trash'
-  box_title_ignored: 'Ignored Conversations'
-  cannot_mark_type: "Cannot mark %{type}"
+  box_title_ignored: 'Ignored'
   cannot_ignore_type: "Cannot ignore %{type}"
+  cannot_authorize_type: "Cannot authorize %{type}"
+  cannot_mark_empty_object: "Cannot mark: Empty Object %{object}"
+  cannot_mark_type: "Cannot mark %{type}"
+  cannot_mark_with_data_type: "Cannot mark with %{data_type}"
+  cannot_unignore_type: "Cannot unignore %{type}"
   check_all: 'Check All'
   class_id_not_found_in_box: "%{class} %{id} not found in box"
+  click_for_original: 'Click for Original'
+  collective_messages: "%{collective} Messages"
+  collective_unsubscribe_message: "You are now unsubscribed from %{collective_name}, which means that you will not be notified by email of any messages received by that %{collective_type}."
+  collective_unsubscribe_removed_message: "You are no longer unsubscribed from %{collective_name}, which means that you will now be notified by email of any messages received in that %{collective_type}."
   conversation_id_not_found: "Conversation %{id} not found"
   compose: 'Compose'
+  compose_to_collective: "Compose to %{collective}"
   delete_forever_this_cannot_be_undone: 'Delete forever? This cannot be undone.'
   deleted: 'Deleted'
+  disable_notifications: 'Disable Notifications'
+  edit_draft: 'Edit Draft'
+  enable_notifications: 'Enable Notifications'
   from_sender: "From: %{sender}"
   ignored: 'Ignored'
+  invalid_sender_for_thing: "Invalid sender for %{thing}"
+  just_now: 'Just Now'
+  manage_your_email_notifications: 'Manage Your Email Notifications'
   mark: 'Mark'
   mark_as_name: "Mark as %{name}" #e.g. Read, Unread etc.
   message_draft: 'Message Draft'
   message_saved_as_draft: 'Message saved as draft.'
   message_sent: 'Message sent.'
   messages: 'Messages'
+  messages_to_collective: "Messages to %{collective}"
+  messages_to_myself: 'Messages to Myself'
   name_not_found: "%{name} not found"
+  new_message: 'New Message'
+  new_message_on_site_name: "New Message on %{site_name}"
+  new_message_through_on_site_name: "New Message through %{through} on %{site_name}"
   none: 'None'
   nothing_to_do: 'Nothing to do'
   read: 'Read'
   recipient_not_found: "Recipient Not Found"
   recipients: 'Recipients'
+  reply: 'Reply'
+  remove_attachment: 'Remove Attachment'
+  save_as_draft: 'Save As Draft'
   send: 'Send'
-  started_at_time: "Started at %{time}"
   table_recipients: "%{table} Recipients"
   to_recipient: 'To: %{recipient}'
   toggle_dropdown: 'Toggle Dropdown'
   trashed: 'Trashed'
   unignored: 'Unignored'
   unread: 'Unread'
+  unsubscribe_message: "You are now unsubscribed from messages to you, which means that you will not be notified by email of any messages received in your inbox."
+  unsubscribe_from_option: "You received this email because you are set to receive notifications of messages to %{from}. To unsubscribe, please visit this link:"
+  unsubscribe_removed_message: "You are no longer unsubscribed from messages to you, which means that you will now be notified by email of any messages received in your inbox"
   untrashed: 'Untrashed'
   update_successful: 'Update successful'
-  wrong_number_of_arguments_for_box_expected_right_got_wrong: "Wrong number of arguments for box (expected %{right}, got %{wrong})"
-  you_must_sign_in_or_sign_up_to_continue: 'You must sign in or sign up to continue.'
+  updated_at_time: "Updated at %{time}"
+  wrong_number_of_arguments_for_thing_expected_right_got_wrong: "Wrong number of arguments for %{thing} (expected %{right}, got %{wrong})"
+  you_are_not_in_that_collective_type: "You are not in that %{collective_type}"
+  you_must_sign_in_or_sign_up_to_continue: 'You must sign in or sign up to continue.'
+  your_inbox: 'your inbox'

data/config/routes.rb

@@ -1,5 +1,5 @@
 MessageTrain::Engine.routes.draw do
-  authenticated MessageTrain.configuration.user_route_authentication_method do
+  concern :boxable do
     resources :boxes, path: 'box', param: :division, only: [:show, :update, :destroy] do
       resources :conversations, only: [:show, :update, :destroy]
       resources :messages, except: [:index, :destroy]
@@ -8,5 +8,13 @@ MessageTrain::Engine.routes.draw do
     end
   end
 
-  match '/box(/*path)', to: redirect(MessageTrain.configuration.user_sign_in_path), via: [:get, :put, :delete]
+  authenticated MessageTrain.configuration.user_route_authentication_method do
+    concerns :boxable
+    resources :collectives, as: :collective, only: [], concerns: :boxable
+    resources :unsubscribes, only: [:index, :create, :destroy]
+  end
+
+  match '/box(/*path)', to: redirect(MessageTrain.configuration.user_sign_in_path), via: [:get, :put, :post, :delete]
+  match '/collectives(/*path)', to: redirect(MessageTrain.configuration.user_sign_in_path), via: [:get, :put, :post, :delete]
+  match '/unsubscribes(/*path)', to: redirect(MessageTrain.configuration.user_sign_in_path), via: [:get, :put, :post, :delete]
 end

data/db/migrate/20150901183458_add_received_through_to_message_train_receipts.rb

@@ -0,0 +1,6 @@
+class AddReceivedThroughToMessageTrainReceipts < ActiveRecord::Migration
+  def change
+    add_reference :message_train_receipts, :received_through, polymorphic: true
+    add_index :message_train_receipts, [:received_through_type, :received_through_id], name: :index_message_train_receipts_on_received_through
+  end
+end

data/db/migrate/20151004184347_add_unique_index_to_receipts.rb

@@ -0,0 +1,5 @@
+class AddUniqueIndexToReceipts < ActiveRecord::Migration
+  def change
+    add_index :message_train_receipts, [:message_id, :recipient_type, :recipient_id], name: :message_recipient, unique: true
+  end
+end

data/db/migrate/20151124000820_create_message_train_unsubscribes.rb

@@ -0,0 +1,14 @@
+class CreateMessageTrainUnsubscribes < ActiveRecord::Migration
+  def change
+    create_table :message_train_unsubscribes do |t|
+      t.references :recipient, polymorphic: true
+      t.references :from, polymorphic: true
+
+      t.timestamps null: false
+    end
+
+    add_index :message_train_unsubscribes, [:recipient_type, :recipient_id], name: :unsubscribe_recipient
+    add_index :message_train_unsubscribes, [:from_type, :from_id], name: :unsubscribe_from
+    add_index :message_train_unsubscribes, [:recipient_type, :recipient_id, :from_type, :from_id], name: :unsubscribe, unique: true
+  end
+end

data/lib/generators/message_train/install/install_generator.rb

@@ -16,6 +16,8 @@ module MessageTrain
       template "initializer.rb", "config/initializers/message_train.rb"
     end
 
+    # Not doing this any more thanks to:
+    # http://blog.pivotal.io/pivotal-labs/labs/leave-your-migrations-in-your-rails-engines
     def add_migrations
       output "Next come migrations.", :magenta
       rake 'message_train:install:migrations'
@@ -23,8 +25,12 @@ module MessageTrain
 
     def add_route
       output "Adding MessageTrain to your routes.rb file", :magenta
-      gsub_file "config/routes.rb", /authenticated :[a-z_0-9]+ do\s+mount MessageTrain::Engine => '\/.*', :as => 'message_train'\s+end/, ''
-      route("authenticated :user do\n\t\tmount MessageTrain::Engine => '/', :as => 'message_train'\n\tend")
+      gsub_file "config/routes.rb", /mount MessageTrain::Engine => '\/.*', :as => 'message_train'/, ''
+      route("mount MessageTrain::Engine => '/', :as => 'message_train'")
+    end
+
+    def goodbye
+      output "Thanks for installing! Don't forget to run your migrations. See http://gemvein.com/museum/cases/message_train for configuration tips.", :magenta
     end
   end
 end

data/lib/generators/message_train/install/templates/initializer.rb

@@ -5,4 +5,8 @@ MessageTrain.configure do |config|
   # config.user_sign_in_path = '/user/sign_in'
   # config.user_route_authentication_method = :user
   # config.address_book_methods[:users] = :address_book
-end
+  config.from_email = 'from@example.com'
+  config.site_name = 'Example Site Name'
+end
+
+Rails.application.config.eager_load = true #FIXME: This is a weird place to put this. What would be better?

data/lib/message_train/configuration.rb

@@ -18,7 +18,12 @@ module MessageTrain
                   :user_route_authentication_method,
                   :address_book_method,
                   :address_book_methods,
-                  :recipient_tables
+                  :recipient_tables,
+                  :collectives_for_recipient_methods,
+                  :valid_senders_methods,
+                  :valid_recipients_methods,
+                  :from_email,
+                  :site_name
 
     def initialize
       self.recipient_tables = {}
@@ -29,6 +34,11 @@ module MessageTrain
       self.user_route_authentication_method = :user
       self.address_book_method = :address_book # This is a fallback
       self.address_book_methods = {}
+      self.collectives_for_recipient_methods = {}
+      self.valid_senders_methods = {}
+      self.valid_recipients_methods = {}
+      self.from_email = ''
+      self.site_name = 'Example Site Name'
     end
 
   end

data/lib/message_train/engine.rb

@@ -15,5 +15,6 @@ module MessageTrain
       # Rails.application.config.assets.paths << File.expand_path("../../assets/javascripts", __FILE__)
       # Rails.application.config.assets.precompile << %w( index )
     end
+
   end
 end

data/lib/message_train/mixin.rb

@@ -16,6 +16,7 @@ module MessageTrain
 
         if relationships.include? :recipient
           has_many :receipts, as: :recipient, class_name: 'MessageTrain::Receipt'
+          has_many :unsubscribes, as: :recipient, class_name: 'MessageTrain::Unsubscribe'
         end
 
         MessageTrain.configure(MessageTrain.configuration) do |config|
@@ -34,50 +35,234 @@ module MessageTrain
           if relationships.include? :recipient
             config.recipient_tables[table_sym] = name
           end
+
+          if options[:collectives_for_recipient].present?
+            config.collectives_for_recipient_methods[table_sym] = options[:collectives_for_recipient]
+          end
+
+          if options[:valid_senders].present?
+            config.valid_senders_methods[table_sym] = options[:valid_senders]
+          end
+
+          if options[:valid_recipients].present?
+            config.valid_recipients_methods[table_sym] = options[:valid_recipients]
+          end
         end
 
-        send(:define_method, :box) { |*args|
+        send(:define_method, :slug_part) {
+          send(MessageTrain.configuration.slug_columns[table_sym])
+        }
+
+        send(:define_method, :path_part) {
+          if MessageTrain.configuration.valid_senders_methods[table_sym].present?
+            # This must mean it's a collective
+            "#{self.class.table_name}:#{slug_part}"
+          end
+        }
+
+        send(:define_method, :valid_senders) {
+          valid_senders_method = MessageTrain.configuration.valid_senders_methods[self.class.table_name.to_sym] || :self_collection
+          send(valid_senders_method)
+        }
+
+        send(:define_method, :allows_sending_by?) { |sender|
+          valid_senders.include? sender
+        }
+
+        send(:define_method, :valid_recipients) {
+          valid_recipients_method = MessageTrain.configuration.valid_recipients_methods[self.class.table_name.to_sym] || :self_collection
+          send(valid_recipients_method)
+        }
+
+        send(:define_method, :allows_receiving_by?) { |recipient|
+          if valid_recipients.nil? or valid_recipients.empty?
+            false
+          else
+            valid_recipients.include? recipient
+          end
+        }
+
+        send(:define_method, :self_collection) { # This turns a single record into an active record collection.
+          model = self.class
+          model.where(id: self.id)
+        }
+
+        if relationships.include? :recipient
+          send(:define_method, :box) { |*args|
+            case args.count
+              when 0
+                division = :in
+                participant = self
+              when 1
+                division = args[0] || :in
+                participant = self
+              when 2
+                division = args[0] || :in
+                participant = args[1] || self
+              else
+                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
+            end
+            @box ||= MessageTrain::Box.new(self, division, participant)
+          }
+
+          send(:define_method, :collective_boxes) { |*args|
+            case args.count
+              when 0
+                division = :in
+                participant = self
+              when 1
+                division = args[0] || :in
+                participant = self
+              when 2
+                division = args[0] || :in
+                participant = args[1] || self
+              else # Treat all but the division as a hash of options
+                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
+            end
+            collective_box_tables = MessageTrain.configuration.collectives_for_recipient_methods
+            collective_boxes = {}
+            unless collective_box_tables.empty?
+              collective_box_tables.each do |table_sym, collectives_method|
+                class_name = MessageTrain.configuration.recipient_tables[table_sym]
+                model = class_name.constantize
+                collectives = model.send(collectives_method, @box_user)
+                unless collectives.empty?
+                  collectives.each do |collective|
+                    collective_boxes[table_sym] ||= []
+                    collective_boxes[table_sym] << collective.box(division, participant)
+                  end
+                end
+              end
+            end
+            collective_boxes
+          }
+
+          send(:define_method, :all_boxes) { |*args|
+            case args.count
+              when 0
+                participant = self
+              when 1
+                participant = args[0] || self
+              else # Treat all but the division as a hash of options
+                raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+            end
+            divisions = [:in, :sent, :all, :drafts, :trash, :ignored]
+            divisions.collect { |division| MessageTrain::Box.new(self, division, participant) }
+          }
+        end
+
+        send(:define_method, :conversations) { |*args|
           case args.count
             when 0
               division = :in
+              participant = self
             when 1
-              division = args[0]
-            else
-              raise :wrong_number_of_arguments_for_box_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s)
+              division = args[0] || :in
+              participant = self
+            when 2
+              division = args[0] || :in
+              participant = args[1] || self
+            else # Treat all but the division as a hash of options
+              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..2', wrong: args.count.to_s, thing: self.class.name)
           end
-          @box ||= MessageTrain::Box.new(self, division)
-        }
-
-        send(:define_method, :conversations) { |division|
+          my_conversations = MessageTrain::Conversation.with_messages_through(self)
           case division
             when :in
-              MessageTrain::Conversation.with_untrashed_to(self)
+              my_conversations.with_untrashed_to(participant)
             when :sent
-              MessageTrain::Conversation.with_untrashed_by(self)
+              my_conversations.with_untrashed_by(participant)
             when :all
-              MessageTrain::Conversation.with_untrashed_for(self)
+              my_conversations.with_untrashed_for(participant)
             when :drafts
-              MessageTrain::Conversation.with_drafts_by(self)
+              my_conversations.with_drafts_by(participant)
             when :trash
-              MessageTrain::Conversation.with_trashed_for(self)
+              my_conversations.with_trashed_for(participant)
             when :ignored
-              MessageTrain::Conversation.ignored(self)
+              my_conversations.ignored(participant)
             else
               nil
           end
         }
 
-        send(:define_method, :all_boxes) {
-          divisions = [:in, :sent, :all, :drafts, :trash, :ignored]
-          divisions.collect { |division| MessageTrain::Box.new(self, division) }
+        send(:define_method, :boxes_for_participant) { |participant|
+          original_order = [:in, :sent, :all, :drafts, :trash, :ignored]
+          divisions = [:all, :trash]
+          if self.respond_to?(:messages) || allows_sending_by?(participant)
+            divisions += [:sent, :drafts]
+          end
+          if allows_receiving_by?(participant)
+            divisions += [:in, :ignored]
+          end
+          divisions.sort_by! { |x| original_order.index x }
+          divisions.collect { |division| MessageTrain::Box.new(self, division, participant) }
+        }
+
+        send(:define_method, :all_conversations) { |*args|
+          case args.count
+            when 0
+              participant = self
+            when 1
+              participant = args[0] || self
+            else # Treat all but the division as a hash of options
+              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+          end
+          results = MessageTrain::Conversation.with_messages_through(self)
+          if results.empty?
+            []
+          else
+            results.with_messages_for(participant)
+          end
+        }
+
+        send(:define_method, :all_messages) { |*args|
+          case args.count
+            when 0
+              participant = self
+            when 1
+              participant = args[0] || self
+            else # Treat all but the division as a hash of options
+              raise :wrong_number_of_arguments_for_thing_expected_right_got_wrong.l(right: '0..1', wrong: args.count.to_s, thing: self.class.name)
+          end
+          results = MessageTrain::Message.with_receipts_through(self)
+          if results.empty?
+            []
+          else
+            results.with_receipts_for(participant)
+          end
+        }
+
+        send(:define_method, :unsubscribed_from?) { |from|
+          unsubscribes.where(from: from).exists?
         }
 
-        send(:define_method, :all_conversations) {
-          MessageTrain::Conversation.with_receipts_for(self)
+        send(:define_method, :unsubscribe_from) { |from|
+          unsubscribes.find_or_create_by(from: from)
         }
 
-        send(:define_method, :all_messages) {
-          MessageTrain::Message.with_receipts_for(self)
+        send(:define_method, :subscriptions) {
+          subscriptions = []
+          subscriptions << {
+              from: self,
+              from_type: self.class.name,
+              from_id: self.id,
+              from_name: :messages_to_myself.l,
+              unsubscribe: self.unsubscribes.find_by(from: self)
+          }
+          collective_boxes.values.each do |boxes|
+            boxes.each do |box|
+              if box.parent.allows_receiving_by?(self)
+                collective_name = box.parent.send(MessageTrain.configuration.name_columns[box.parent.class.table_name.to_sym])
+                subscriptions << {
+                    from: box.parent,
+                    from_type: box.parent.class.name,
+                    from_id: box.parent.id,
+                    from_name: :messages_to_collective.l(collective: collective_name),
+                    unsubscribe: self.unsubscribes.find_by(from: box.parent)
+                }
+              end
+            end
+          end
+          subscriptions
         }
       end
     end