noticed 1.6.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dca9fddb81724156c172bcb7ac9bdcbc7d3571554dd3b906d3df02395c730b23
-  data.tar.gz: 5a8676aa3224c61b6623b81db22aecde7fa175c5514da465dfd735269b91394a
+  metadata.gz: f2466298cbeef0bde1ae34d07ed5317032659ba413cc15797e211012c9d7847c
+  data.tar.gz: b4edc8f7a819331a2d66a39c04d491f8c534f44fae8c14edbc0ce2b366556c8f
 SHA512:
-  metadata.gz: 582f1a4e7282af29b7a66fcf322f13e2af6880757a3871a7cb74a44b3cc5fb9de6e404e5a62d78349cd7283caab14445bb63a508595878d98cadc352ea8bcbc1
-  data.tar.gz: 3764af8b5240a7b7de561512086497ea60ff9fecb1ff49d85ce2ea42509b97188519a97d9e05c884e0d48aebbfdca3cb27022b88347160e066942fd00b191ec5
+  metadata.gz: bf817631a96cf372b864e6df07c38f3c0a4e97f288ae63b934af36fa9102e22408802176e9642f6a1c3a22b46854c764dfd6a25d19da00c3da5c0eeeec778694
+  data.tar.gz: 4d7a596f35331bc8f38e1337398f72fdf38af34b631bae27db48c32b4f58f702023c3a5d44e00ebb9f7e8e990b1053d8bc76c5941db8c9b7a296e03e9f4c2a96

data/README.md

@@ -1,88 +1,124 @@
-<p align="center">
-  <h1>Noticed</h1>
-</p>
-
+# Noticed 
 ### 🎉  Notifications for your Ruby on Rails app.
 
 [![Build Status](https://github.com/excid3/noticed/workflows/Tests/badge.svg)](https://github.com/excid3/noticed/actions) [![Gem Version](https://badge.fury.io/rb/noticed.svg)](https://badge.fury.io/rb/noticed)
 
-Currently, we support these notification delivery methods out of the box:
+Noticed helps you send notifications in your Rails apps. Notifications can be sent to any number of recipients. You might want a Slack notification with 0 recipients to let your team know when something happens. A notification can also be sent to 1+ recipients with individual deliveries (like an email to each recipient).
+
+The core concepts of Noticed are:
+
+1. `Notifier` - Classes that define how notifications are delivered and when.
+2. `Noticed::Event` - When a `Notifier` is delivered, a `Noticed::Event` record is created in the database to store params for the delivery.`Notifiers` are ActiveRecord objects inherited from `Noticed::Event` using Single Table Inheritance.
+3. `Noticed::Notification` - Keeps track of each recipient for `Noticed::Event` and the seen & read status for each.
+4. Delivery methods are ActiveJob instances and support the same features like wait, queue, and priority.
+
+## Delivery Methods
+Individual Delivery methods (one notification to each recipient):
+
+* [ActionCable](docs/delivery_methods/action_cable.md)
+* [Apple Push Notification Service](docs/delivery_methods/ios.md)
+* [Email](docs/delivery_methods/email.md)
+* [Firebase Cloud Messaging](docs/delivery_methods/fcm.md) (iOS, Android, and web clients)
+* [Microsoft Teams](docs/delivery_methods/microsoft_teams.md)
+* [Slack](docs/delivery_methods/slack.md)
+* [Twilio Messaging](docs/delivery_methods/twilio_messaging.md) - SMS, Whatsapp
+* [Vonage SMS](docs/delivery_methods/vonage_sms.md)
+* [Test](docs/delivery_methods/test.md)
 
-* Database
-* Email
-* ActionCable channels
-* Slack
-* Microsoft Teams
-* Twilio (SMS)
-* Vonage / Nexmo (SMS)
-* iOS Apple Push Notifications
-* Firebase Cloud Messaging (Android and more)
+Bulk delivery methods (one notification for all recipients):
 
-And you can easily add new notification types for any other delivery methods.
+* [Discord](docs/bulk_delivery_methods/discord.md)
+* [Slack](docs/bulk_delivery_methods/slack.md)
+* [Webhook](docs/bulk_delivery_methods/webhook.md)
 
 ## 🎬 Screencast
 
-<div style="width:50%">
-  <a href="https://www.youtube.com/watch?v=Scffi4otlFc"><img src="https://i.imgur.com/UvVKWwD.png" title="How to add Notifications to Rails with Noticed" /></a>
-</div>
+<a href="https://www.youtube.com/watch?v=Scffi4otlFc"><img src="https://i.imgur.com/UvVKWwD.png" title="How to add Notifications to Rails with Noticed" width="50%" /></a>
 
 [Watch Screencast](https://www.youtube.com/watch?v=Scffi4otlFc)
 
 ## 🚀 Installation
-Run the following command to add Noticed to your Gemfile
+Run the following command to add Noticed to your Gemfile:
 
 ```ruby
 bundle add "noticed"
 ```
 
-To save notifications to your database, use the following command to generate a Notification model.
+Add the migrations:
 
-```ruby
-rails generate noticed:model
+```bash
+rails noticed:install:migrations
+rails db:migrate
 ```
 
-This will generate a Notification model and instructions for associating User models with the notifications table.
-
 ## 📝 Usage
 
-To generate a notification object, simply run:
+To generate a Notifier, simply run:
 
-`rails generate noticed:notification CommentNotification`
+`rails generate noticed:notifier CommentNotifier`
 
-#### Sending Notifications
-
-To send a notification to a user:
+#### Add Delivery Methods
+Then add delivery methods to the Notifier. See [docs/delivery_methods](docs/) for a full list.
 
 ```ruby
-# Instantiate a new notification
-notification = CommentNotification.with(comment: @comment)
+# app/notifiers/comment_notifier.rb
+class CommentNotifier < Noticed::Event
+  bulk_deliver_by :webhook do |config|
+    config.url = "https://example.org..."
+    config.json = ->{ text: "New comment: #{record.body}" }
+  end
 
-# Deliver notification in background job
-notification.deliver_later(@comment.post.author)
+  deliver_by :email do |config|
+    config.mailer = "UserMailer"
+    config.method = :new_comment
+  end
+end
+```
 
-# Deliver notification immediately
-notification.deliver(@comment.post.author)
+#### Sending Notifications
 
-# Deliver notification to multiple recipients
-notification.deliver_later(User.all)
+To send a notification to user(s):
+
+```ruby
+# Instantiate a new notifier
+CommentNotifier.with(record: @comment, foo: "bar").deliver_later(User.all)
 ```
 
-This will instantiate a new notification with the `comment` stored in the notification's params.
+This instantiates a new `CommentNotifier` with params. Similar to ActiveJob, you can pass any params can be serialized.  `record:` is a special param that gets assigned to the `record` polymorphic association in the database.
+
+Delivering will create a `Noticed::Event` record and associated `Noticed::Notification` records for each recipient.
 
-Each delivery method is able to transform this metadata that's best for the format. For example, the database may simply store the comment so it can be linked when rendering in the navbar. The websocket mechanism may transform this into a browser notification or insert it into the navbar.
+After saving, a job will be enqueued for processing this notification and delivering it to all recipients.
 
-#### Notification Objects
+Each delivery method also spawns its own job. This allows you to skip email notifications if the user had already opened a push notification, for example.
 
-Notifications inherit from `Noticed::Base`. This provides all their functionality and allows them to be delivered.
+#### Notifier Objects
 
-To add delivery methods, simply `include` the module for the delivery methods you would like to use.
+Notifiers inherit from `Noticed::Event`. This provides all their functionality and allows them to be delivered.
 
 ```ruby
-class CommentNotification < Noticed::Base
-  deliver_by :database
+class CommentNotifier < Noticed::Event
   deliver_by :action_cable
-  deliver_by :email, mailer: 'CommentMailer', if: :email_notifications?
+  deliver_by :email do |config|
+    config.mailer = "UserMailer"
+    config.if = ->(recipient) { !!recipient.preferences[:email] }
+    config.wait = 5.minutes
+  end
+end
+```
+
+**Shared Options**
 
+* `if: :method_name`  - Calls `method_name` and cancels delivery method if `false` is returned. This can also be specified as a Proc / lambda.
+* `unless: :method_name`  - Calls `method_name` and cancels delivery method if `true` is returned
+* `wait:` - Delays the delivery for the given duration of time. Can be an `ActiveSupport::Duration`, Proc / lambda, or Symbol.
+
+##### Helper Methods
+
+You can define helper methods inside your Notifier object to make it easier to render.
+
+```ruby
+class CommentNotifier < Noticed::Event
   # I18n helpers
   def message
     t(".message")
@@ -94,77 +130,38 @@ class CommentNotification < Noticed::Base
     post_path(params[:post])
   end
 
-  def email_notifications?
-    !!recipient.preferences[:email]
-  end
-
-  after_deliver do
-    # Anything you want
+  # Defines methods added to the Noticed::Notification
+  notification_methods do
+    def personalized_welcome
+      "Hello #{recipient.first_name}."
+    end
   end
 end
 ```
 
-**Shared Options**
-
-* `if: :method_name`  - Calls `method_name` and cancels delivery method if `false` is returned
-* `unless: :method_name`  - Calls `method_name` and cancels delivery method if `true` is returned
-* `delay: ActiveSupport::Duration` - Delays the delivery for the given duration of time
-* `delay: :method_name` - Calls `method_name` which should return an `ActiveSupport::Duration` and delays the delivery for the given duration of time
-
-##### Helper Methods
-
-You can define helper methods inside your Notification object to make it easier to render.
+In your views, you can loop through notifications and access
+```erb
+<%= current_user.notifications.includes(:event).each do |notification| %>
+  <%= link_to notification.personalized_welcome, notification.event.url %>
+<% end %>
+```
 
 ##### URL Helpers
 
-Rails url helpers are included in notification classes by default so you have full access to them just like you would in your controllers and views.
-
-Don't forget, you'll need to configure `default_url_options` in order for Rails to know what host and port to use when generating URLs.
+URL helpers are included in Notifier classes so you have full access to them just like in your controllers and views. Configure `default_url_options` in order for Rails to know what host and port to use when generating URLs.
 
 ```ruby
 Rails.application.routes.default_url_options[:host] = 'localhost:3000'
 ```
 
-**Callbacks**
-
-Like ActiveRecord, notifications have several different types of callbacks.
-
-```ruby
-class CommentNotification < Noticed::Base
-  deliver_by :database
-  deliver_by :email, mailer: 'CommentMailer'
-
-  # Callbacks for the entire delivery
-  before_deliver :whatever
-  around_deliver :whatever
-  after_deliver :whatever
-
-  # Callbacks for each delivery method
-  before_database :whatever
-  around_database :whatever
-  after_database :whatever
-
-  before_email :whatever
-  around_email :whatever
-  after_email :whatever
-end
-```
-
-When using `deliver_later` callbacks will be run around queuing the delivery method jobs (not inside the jobs as they actually execute).
-
-Defining custom delivery methods allows you to add callbacks that run inside the background job as each individual delivery is executed. See the Custom Delivery Methods section for more information.
-
 ##### Translations
 
-We've added `translate` and `t` helpers like Rails has to provide an easy way of scoping translations. If the key starts with a period, it will automatically scope the key under `notifications` and the underscored name of the notification class it is used in.
+`translate` and `t` helpers are available in Notifiers. If the key starts with a period, it will automatically scope the key under `notifiers` and the underscored name of the notification class it is used in.
 
 For example:
 
- `t(".message")` looks up `en.notifications.new_comment.message`
-
-Or when notification class is in module:
-
-`t(".message") # in Admin::NewComment` looks up `en.notifications.admin.new_comment.message`
+`t(".message")` looks up `en.notifiers.new_comment.message`
+`t(".message") # in Admin::NewComment` looks up `en.notifiers.admin.new_comment.message`
 
 ##### User Preferences
 
@@ -173,30 +170,20 @@ You can use the `if:` and `unless: ` options on your delivery methods to check t
 For example:
 
 ```ruby
-class CommentNotification < Noticed::Base
-  deliver_by :email, mailer: 'CommentMailer', if: :email_notifications?
-
-  def email_notifications?
-    recipient.email_notifications?
+class CommentNotifier < Noticed::Base
+  deliver_by :email do |config|
+    config.mailer = 'CommentMailer'
+    config.method = :new_comment
+    config.if = ->{ recipient.email_notifications? }
   end
 end
 ```
 
-## 🐞 Debugging
-
-In order to figure out what's up when you run in to errors, you can set the `debug` parameter to `true` in your notification, which will give you a more detailed error message about what went wrong.
-
-Example:
-
-```ruby
-deliver_by :slack, debug: true
-```
-
 ## ✅ Best Practices
 
 ### Creating a notification from an Active Record callback
 
-A common use case is to trigger a notification when a record is created. For example,
+Always use `after_commit` hooks to send notifications from ActiveRecord callbacks. For example, to send a notification automatically after a message is created:
 
 ```ruby
 class Message < ApplicationRecord
@@ -207,58 +194,46 @@ class Message < ApplicationRecord
   private
 
   def notify_recipient
-    NewMessageNotification.with(message: self).deliver_later(recipient)
+    NewMessageNotifier.with(message: self).deliver_later(recipient)
   end
 ```
 
-If you are creating the notification on a background job (i.e. via `#deliver_later`), make sure you use a `commit` hook such as `after_create_commit` or `after_commit`.
-
 Using `after_create` might cause the notification delivery methods to fail. This is because the job was enqueued while inside a database transaction, and the `Message` record might not yet be saved to the database.
 
 A common symptom of this problem is undelivered notifications and the following error in your logs.
 
 > `Discarded Noticed::DeliveryMethods::Email due to a ActiveJob::DeserializationError.`
 
-### Renaming notifications
+### Renaming Notifiers
 
-If you rename the class of a notification object your existing queries can break. This is because Noticed serializes the class name and sets it to the `type` column on the `Notification` record.
+If you rename the class of a notification object your existing queries can break. This is because ActiveRecord serializes the class name and sets it to the `type` column on the Noticed records.
 
-You can catch these errors at runtime by using `YourNotificationClassName.name` instead of hardcoding the string when performing a query.
+You can catch these errors at runtime by using `YourNotifierClassName.name` instead of hardcoding the string when performing a query.
 
 ```ruby
-Notification.where(type: YourNotificationClassName.name) # good
-Notification.where(type: "YourNotificationClassName") # bad
+Noticed::Event.where(type: YourNotifierClassName.name) # good
+Noticed::Event.where(type: "YourNotifierClassName") # bad
 ```
 
 When renaming a notification class you will need to backfill existing notifications to reference the new name.
 
 ```ruby
-Notification.where(type: "OldNotificationClassName").update_all(type: NewNotificationClassName.name)
+Noticed::Event.where(type: "OldNotifierClassName").update_all(type: NewNotifierClassName.name)
+Noticed::Notification.where(type: "OldNotifierClassName::Notification").update_all(type: NewNotifierClassName::Notification.name)
 ```
 
 ## 🚛 Delivery Methods
 
-The delivery methods are designed to be modular so you can customize the way each type gets delivered.
+The delivery methods are modular so you can customize the way each type gets delivered.
 
-For example, emails will require a subject, body, and email address while an SMS requires a phone number and simple message. You can define the formats for each of these in your Notification and the delivery method will handle the processing of it.
-
-* [Database](docs/delivery_methods/database.md)
-* [Email](docs/delivery_methods/email.md)
-* [ActionCable](docs/delivery_methods/action_cable.md)
-* [iOS Apple Push Notifications](docs/delivery_methods/ios.md)
-* [Microsoft Teams](docs/delivery_methods/microsoft_teams.md)
-* [Slack](docs/delivery_methods/slack.md)
-* [Test](docs/delivery_methods/test.md)
-* [Twilio](docs/delivery_methods/twilio.md)
-* [Vonage](docs/delivery_methods/vonage.md)
-* [Firebase Cloud Messaging](docs/delivery_methods/fcm.md)
+For example, emails will require a subject, body, and email address while an SMS requires a phone number and simple message. You can define the formats for each of these in your Notifier and the delivery method will handle the processing of it.
 
 ### Fallback Notifications
 
 A common pattern is to deliver a notification via the database and then, after some time has passed, email the user if they have not yet read the notification. You can implement this functionality by combining multiple delivery methods, the `delay` option, and the conditional `if` / `unless` option.
 
 ```ruby
-class CommentNotification < Noticed::Base
+class CommentNotifier< Noticed::Base
   deliver_by :database
   deliver_by :email, mailer: 'CommentMailer', delay: 15.minutes, unless: :read?
 end
@@ -269,7 +244,7 @@ Here a notification will be created immediately in the database (for display dir
 You can also configure multiple fallback options:
 
 ```ruby
-class CriticalSystemNotification < Noticed::Base
+class CriticalSystemNotifier < Noticed::Base
   deliver_by :database
   deliver_by :slack
   deliver_by :email, mailer: 'CriticalSystemMailer', delay: 10.minutes, if: :unread?
@@ -307,14 +282,14 @@ end
 You can use the custom delivery method thus created by adding a `deliver_by` line with a unique name and `class` option in your notification class.
 
 ```ruby
-class MyNotification < Noticed::Base
+class MyNotifier < Noticed::Base
   deliver_by :discord, class: "DeliveryMethods::Discord"
 end
 ```
 
 Delivery methods have access to the following methods and attributes:
 
-* `notification` - The instance of the Notification. You can call methods on the notification to let the user easily override formatting and other functionality of the delivery method.
+* `record` - The instance of the Notification. You can call methods on the notification to let the user easily override formatting and other functionality of the delivery method.
 * `options` - Any configuration options on the `deliver_by` line.
 * `recipient` - The object who should receive the notification. This is typically a User, Account, or other ActiveRecord model.
 * `params` - The params passed into the notification. This is details about the event that happened. For example, a user commenting on a post would have params of `{ user: User.first }`
@@ -343,7 +318,7 @@ class DeliveryMethods::Discord < Noticed::DeliveryMethods::Base
   end
 end
 
-class CommentNotification < Noticed::Base
+class CommentNotifier < Noticed::Base
   deliver_by :discord, class: 'DeliveryMethods::Discord'
 end
 ```
@@ -353,7 +328,7 @@ Now it will raise an error because a required argument is missing.
 To fix the error, the argument has to be passed correctly. For example:
 
 ```ruby
-class CommentNotification < Noticed::Base
+class CommentNotifier < Noticed::Base
   deliver_by :discord, class: 'DeliveryMethods::Discord', username: User.admin.username
 end
 ```
@@ -399,10 +374,10 @@ user.notifications.mark_as_unread!
 
 #### Instance methods
 
-Convert back into a Noticed notification object:
+Convert back into a Noticed notifier object:
 
 ```ruby
-@notification.to_notification
+@notification.to_notifier
 ```
 
 Mark notification as read / unread:
@@ -445,11 +420,11 @@ class Post < ApplicationRecord
 end
 
 # Create a CommentNotification with a post param
-CommentNotification.with(post: @post).deliver(user)
+CommentNotifier.with(post: @post).deliver(user)
 # Lookup Notifications where params: {post: @post}
 @post.notifications_as_post
 
-CommentNotification.with(parent: @post).deliver(user)
+CommentNotifier.with(parent: @post).deliver(user)
 @post.notifications_as_parent
 ```
 

data/app/jobs/noticed/application_job.rb

@@ -0,0 +1,9 @@
+module Noticed
+  class ApplicationJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    discard_on ActiveJob::DeserializationError
+  end
+end

data/app/jobs/noticed/event_job.rb

@@ -0,0 +1,19 @@
+module Noticed
+  class EventJob < ApplicationJob
+    queue_as :default
+
+    def perform(event)
+      # Enqueue bulk deliveries
+      event.bulk_delivery_methods.each do |_, deliver_by|
+        deliver_by.perform_later(event)
+      end
+
+      # Enqueue individual deliveries
+      event.notifications.each do |notification|
+        event.delivery_methods.each do |_, deliver_by|
+          deliver_by.perform_later(notification)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/noticed/deliverable.rb

@@ -0,0 +1,115 @@
+module Noticed
+  module Deliverable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :bulk_delivery_methods, instance_writer: false, default: {}
+      class_attribute :delivery_methods, instance_writer: false, default: {}
+      class_attribute :required_param_names, instance_writer: false, default: []
+
+      attribute :params, default: {}
+
+      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
+        serialize :params, coder: Coder
+      else
+        serialize :params, Coder
+      end
+    end
+
+    class_methods do
+      def inherited(base)
+        base.bulk_delivery_methods = bulk_delivery_methods.dup
+        base.delivery_methods = delivery_methods.dup
+        base.required_param_names = required_param_names.dup
+        super
+      end
+
+      def bulk_deliver_by(name, options = {})
+        raise NameError, "#{name} has already been used for this Notifier." if bulk_delivery_methods.has_key?(name)
+
+        config = ActiveSupport::OrderedOptions.new.merge(options)
+        yield config if block_given?
+        bulk_delivery_methods[name] = DeliverBy.new(name, config, bulk: true)
+      end
+
+      def deliver_by(name, options = {})
+        raise NameError, "#{name} has already been used for this Notifier." if delivery_methods.has_key?(name)
+
+        config = ActiveSupport::OrderedOptions.new.merge(options)
+        yield config if block_given?
+        delivery_methods[name] = DeliverBy.new(name, config)
+      end
+
+      def required_params(*names)
+        required_param_names.concat names
+      end
+      alias_method :required_param, :required_params
+
+      def with(params)
+        record = params.delete(:record)
+        new(params: params, record: record)
+      end
+
+      def deliver(recipients = nil, options = {})
+        new.deliver(recipients, options)
+      end
+    end
+
+    # CommentNotifier.deliver(User.all)
+    # CommentNotifier.deliver(User.all, priority: 10)
+    # CommentNotifier.deliver(User.all, queue: :low_priority)
+    # CommentNotifier.deliver(User.all, wait: 5.minutes)
+    # CommentNotifier.deliver(User.all, wait_until: 1.hour.from_now)
+    def deliver(recipients = nil, options = {})
+      validate!
+
+      transaction do
+        save!
+
+        recipients_attributes = Array.wrap(recipients).map do |recipient|
+          recipient_attributes_for(recipient)
+        end
+
+        if Rails.gem_version >= Gem::Version.new("7.0.0.alpha1")
+          notifications.insert_all!(recipients_attributes, record_timestamps: true) if recipients_attributes.any?
+        else
+          time = Time.current
+          recipients_attributes.each do |attributes|
+            attributes[:created_at] = time
+            attributes[:updated_at] = time
+          end
+          notifications.insert_all!(recipients_attributes) if recipients_attributes.any?
+        end
+      end
+
+      # Enqueue delivery job
+      EventJob.set(options).perform_later(self)
+
+      self
+    end
+
+    def recipient_attributes_for(recipient)
+      {
+        type: "#{self.class.name}::Notification",
+        recipient_type: recipient.class.name,
+        recipient_id: recipient.id
+      }
+    end
+
+    def validate!
+      validate_params!
+      validate_delivery_methods!
+    end
+
+    def validate_params!
+      required_param_names.each do |param_name|
+        raise ValidationError, "Param `#{param_name}` is required for #{self.class.name}." unless params[param_name].present?
+      end
+    end
+
+    def validate_delivery_methods!
+      bulk_delivery_methods.values.each(&:validate!)
+      delivery_methods.values.each(&:validate!)
+    end
+  end
+end

data/app/models/concerns/noticed/notification_methods.rb

@@ -0,0 +1,17 @@
+module Noticed
+  module NotificationMethods
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Generate a Notification class each time a Notifier is defined
+      def inherited(notifier)
+        super
+        notifier.const_set :Notification, Class.new(Noticed::Notification)
+      end
+
+      def notification_methods(&block)
+        const_get(:Notification).class_eval(&block)
+      end
+    end
+  end
+end

data/app/models/concerns/noticed/readable.rb

@@ -0,0 +1,62 @@
+module Noticed
+  module Readable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :read, -> { where.not(read_at: nil) }
+      scope :unread, -> { where(read_at: nil) }
+      scope :seen, -> { where.not(seen_at: nil) }
+      scope :unseen, -> { where(seen_at: nil) }
+    end
+
+    class_methods do
+      def mark_as_read
+        update_all(read_at: Time.current)
+      end
+
+      def mark_as_unread
+        update_all(read_at: nil)
+      end
+
+      def mark_as_seen
+        update_all(seen_at: Time.current)
+      end
+
+      def mark_as_unseen
+        update_all(seen_at: nil)
+      end
+    end
+
+    def mark_as_read
+      update(read_at: Time.current)
+    end
+
+    def mark_as_unread
+      update(read_at: nil)
+    end
+
+    def mark_as_seen
+      update(seen_at: Time.current)
+    end
+
+    def mark_as_unseen
+      update(seen_at: nil)
+    end
+
+    def read?
+      read_at?
+    end
+
+    def unread?
+      !read_at?
+    end
+
+    def seen?
+      seen_at?
+    end
+
+    def unseen?
+      !seen_at?
+    end
+  end
+end