noticed 2.0.0 → 2.1.1

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

@@ -9,10 +9,13 @@ module Noticed
 
       attribute :params, default: {}
 
-      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
-        serialize :params, coder: Coder
-      else
-        serialize :params, Coder
+      # Ephemeral notifiers cannot serialize params since they aren't ActiveRecord backed
+      if respond_to? :serialize
+        if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
+          serialize :params, coder: Coder
+        else
+          serialize :params, Coder
+        end
       end
     end
 
@@ -35,6 +38,13 @@ module Noticed
       def deliver_by(name, options = {})
         raise NameError, "#{name} has already been used for this Notifier." if delivery_methods.has_key?(name)
 
+        if name == :database
+          Noticed.deprecator.warn <<-WARNING.squish
+            The :database delivery method has been deprecated and does nothing. Notifiers automatically save to the database now.
+          WARNING
+          return
+        end
+
         config = ActiveSupport::OrderedOptions.new.merge(options)
         yield config if block_given?
         delivery_methods[name] = DeliverBy.new(name, config)
@@ -45,14 +55,29 @@ module Noticed
       end
       alias_method :required_param, :required_params
 
+      def params(*names)
+        Noticed.deprecator.warn <<-WARNING.squish
+          `params` is deprecated and has been renamed to `required_params`
+        WARNING
+        required_params(*names)
+      end
+
+      def param(*names)
+        Noticed.deprecator.warn <<-WARNING.squish
+          `param :name` is deprecated and has been renamed to `required_param :name`
+        WARNING
+        required_params(*names)
+      end
+
       def with(params)
         record = params.delete(:record)
         new(params: params, record: record)
       end
 
-      def deliver(recipients = nil, options = {})
-        new.deliver(recipients, options)
+      def deliver(recipients = nil, **options)
+        new.deliver(recipients, **options)
       end
+      alias_method :deliver_later, :deliver
     end
 
     # CommentNotifier.deliver(User.all)
@@ -60,16 +85,17 @@ module Noticed
     # 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 = {})
+    def deliver(recipients = nil, enqueue_job: true, **options)
       validate!
 
       transaction do
-        save!
-
         recipients_attributes = Array.wrap(recipients).map do |recipient|
           recipient_attributes_for(recipient)
         end
 
+        self.notifications_count = recipients_attributes.size
+        save!
+
         if Rails.gem_version >= Gem::Version.new("7.0.0.alpha1")
           notifications.insert_all!(recipients_attributes, record_timestamps: true) if recipients_attributes.any?
         else
@@ -83,15 +109,16 @@ module Noticed
       end
 
       # Enqueue delivery job
-      EventJob.set(options).perform_later(self)
+      EventJob.set(options).perform_later(self) if enqueue_job
 
       self
     end
+    alias_method :deliver_later, :deliver
 
     def recipient_attributes_for(recipient)
       {
         type: "#{self.class.name}::Notification",
-        recipient_type: recipient.class.name,
+        recipient_type: recipient.class.base_class.name,
         recipient_id: recipient.id
       }
     end
@@ -103,7 +130,7 @@ module Noticed
 
     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?
+        raise ValidationError, "Param `#{param_name}` is required for #{self.class.name}." unless params.has_key?(param_name)
       end
     end
 

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

@@ -11,19 +11,19 @@ module Noticed
 
     class_methods do
       def mark_as_read
-        update_all(read_at: Time.current)
+        update_all(read_at: Time.current, updated_at: Time.current)
       end
 
       def mark_as_unread
-        update_all(read_at: nil)
+        update_all(read_at: nil, updated_at: Time.current)
       end
 
       def mark_as_seen
-        update_all(seen_at: Time.current)
+        update_all(seen_at: Time.current, updated_at: Time.current)
       end
 
       def mark_as_unseen
-        update_all(seen_at: nil)
+        update_all(seen_at: nil, updated_at: Time.current)
       end
     end
 
@@ -31,18 +31,34 @@ module Noticed
       update(read_at: Time.current)
     end
 
+    def mark_as_read!
+      update!(read_at: Time.current)
+    end
+
     def mark_as_unread
       update(read_at: nil)
     end
 
+    def mark_as_unread!
+      update!(read_at: nil)
+    end
+
     def mark_as_seen
       update(seen_at: Time.current)
     end
 
+    def mark_as_seen!
+      update!(seen_at: Time.current)
+    end
+
     def mark_as_unseen
       update(seen_at: nil)
     end
 
+    def mark_as_unseen!
+      update!(seen_at: nil)
+    end
+
     def read?
       read_at?
     end

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

@@ -19,14 +19,23 @@ module Noticed
       end
 
       def perform_later(event_or_notification, options = {})
-        options[:wait] = evaluate_option(:wait, event_or_notification) if config.has_key?(:wait)
-        options[:wait_until] = evaluate_option(:wait_until, event_or_notification) if config.has_key?(:wait_until)
-        options[:queue] = evaluate_option(:queue, event_or_notification) if config.has_key?(:queue)
-        options[:priority] = evaluate_option(:priority, event_or_notification) if config.has_key?(:priority)
+        options[:wait] ||= evaluate_option(:wait, event_or_notification) if config.has_key?(:wait)
+        options[:wait_until] ||= evaluate_option(:wait_until, event_or_notification) if config.has_key?(:wait_until)
+        options[:queue] ||= evaluate_option(:queue, event_or_notification) if config.has_key?(:queue)
+        options[:priority] ||= evaluate_option(:priority, event_or_notification) if config.has_key?(:priority)
 
         constant.set(options).perform_later(name, event_or_notification)
       end
 
+      def ephemeral_perform_later(notifier, recipient, params, options = {})
+        options[:wait] ||= evaluate_option(:wait, recipient) if config.has_key?(:wait)
+        options[:wait_until] ||= evaluate_option(:wait_until, recipient) if config.has_key?(:wait_until)
+        options[:queue] ||= evaluate_option(:queue, recipient) if config.has_key?(:queue)
+        options[:priority] ||= evaluate_option(:priority, recipient) if config.has_key?(:priority)
+
+        constant.set(options).perform_later(name, "#{notifier}::Notification", recipient: recipient, params: params)
+      end
+
       def evaluate_option(name, context)
         option = config[name]
 

data/app/models/noticed/ephemeral.rb

@@ -0,0 +1,53 @@
+module Noticed
+  class Ephemeral
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Noticed::Deliverable
+
+    attribute :record
+    attribute :params, default: {}
+
+    class Notification
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :recipient
+      attribute :event
+
+      delegate :params, :record, to: :event
+
+      def self.new_with_params(recipient, params)
+        instance = new(recipient: recipient)
+        instance.event = module_parent.new(params: params)
+        instance
+      end
+    end
+
+    # Dynamically define Notification on each Ephemeral Notifier
+    def self.inherited(notifier)
+      super
+      notifier.const_set :Notification, Class.new(Noticed::Ephemeral::Notification)
+    end
+
+    def deliver(recipients)
+      recipients = Array.wrap(recipients)
+      bulk_delivery_methods.each do |_, deliver_by|
+        deliver_by.ephemeral_perform_later(self.class.name, recipients, params)
+      end
+
+      recipients.each do |recipient|
+        delivery_methods.each do |_, deliver_by|
+          deliver_by.ephemeral_perform_later(self.class.name, recipient, params)
+        end
+      end
+    end
+
+    def record
+      params[:record]
+    end
+
+    def notification_methods(&block)
+      const_get(:Notification).class_eval(&block)
+    end
+  end
+end

data/app/models/noticed/notification.rb

@@ -4,13 +4,11 @@ module Noticed
     include Readable
     include Translation
 
-    belongs_to :event
+    belongs_to :event, counter_cache: true
     belongs_to :recipient, polymorphic: true
 
     scope :newest_first, -> { order(created_at: :desc) }
 
     delegate :params, :record, to: :event
-
-    attribute :params, default: {}
   end
 end

data/db/migrate/20240129184740_add_notifications_count_to_noticed_event.rb

@@ -0,0 +1,5 @@
+class AddNotificationsCountToNoticedEvent < ActiveRecord::Migration[7.1]
+  def change
+    add_column :noticed_events, :notifications_count, :integer
+  end
+end

data/lib/generators/noticed/delivery_method_generator.rb

@@ -12,6 +12,7 @@ module Noticed
       desc "Generates a class for a custom delivery method with the given NAME."
 
       def generate_notification
+        template "application_delivery_method.rb", "app/notifiers/application_delivery_method.rb"
         template "delivery_method.rb", "app/notifiers/delivery_methods/#{singular_name}.rb"
       end
     end

data/lib/generators/noticed/notifier_generator.rb

@@ -7,12 +7,21 @@ module Noticed
     class NotifierGenerator < Rails::Generators::NamedBase
       include Rails::Generators::ResourceHelpers
 
+      check_class_collision suffix: "Notifier"
+
       source_root File.expand_path("../templates", __FILE__)
 
       desc "Generates a notification with the given NAME."
 
       def generate_notification
-        template "notifier.rb", "app/notifiers/#{file_path}.rb"
+        template "application_notifier.rb", "app/notifiers/application_notifier.rb"
+        template "notifier.rb", "app/notifiers/#{file_path}_notifier.rb"
+      end
+
+      private
+
+      def file_name # :doc:
+        @_file_name ||= super.sub(/_notifier\z/i, "")
       end
     end
   end

data/lib/generators/noticed/templates/application_delivery_method.rb.tt

@@ -0,0 +1,2 @@
+class ApplicationDeliveryMethod < Noticed::DeliveryMethod
+end

data/lib/generators/noticed/templates/application_notifier.rb.tt

@@ -0,0 +1,2 @@
+class ApplicationNotifier < Noticed::Event
+end

data/lib/generators/noticed/templates/delivery_method.rb.tt

@@ -1,12 +1,8 @@
-class DeliveryMethods::<%= class_name %> < Noticed::DeliveryMethods::Base
+class DeliveryMethods::<%= class_name %> < ApplicationDeliveryMethod
+  # Specify the config options your delivery method requires in its config block
+  required_options # :foo, :bar
+
   def deliver
     # Logic for sending the notification
   end
-
-  # You may override this method to validate options for the delivery method
-  # Invalid options should raise a ValidationError
-  #
-  # def self.validate!(options)
-  #   raise ValidationError, "required_option missing" unless options[:required_option]
-  # end
 end

data/lib/generators/noticed/templates/notifier.rb.tt

@@ -2,7 +2,7 @@
 #
 # <%= class_name %>.with(record: @post, message: "New post").deliver(User.all)
 
-class <%= class_name %> < Noticed::Event
+class <%= class_name %>Notifier < ApplicationNotifier
   # Add your delivery methods
   #
   # deliver_by :email do |config|

data/lib/noticed/bulk_delivery_method.rb

@@ -7,9 +7,15 @@ module Noticed
 
     attr_reader :config, :event
 
-    def perform(delivery_method_name, event)
-      @event = event
-      @config = event.bulk_delivery_methods.fetch(delivery_method_name).config
+    def perform(delivery_method_name, event, recipients: nil, params: {}, overrides: {})
+      # Ephemeral notifications
+      if event.is_a? String
+        @event = @notification.event
+        @config = overrides
+      else
+        @event = event
+        @config = event.bulk_delivery_methods.fetch(delivery_method_name).config.merge(overrides)
+      end
 
       return false if config.has_key?(:if) && !evaluate_option(:if)
       return false if config.has_key?(:unless) && evaluate_option(:unless)

data/lib/noticed/bulk_delivery_methods/test.rb

@@ -0,0 +1,11 @@
+module Noticed
+  module BulkDeliveryMethods
+    class Test < DeliveryMethod
+      class_attribute :delivered, default: []
+
+      def deliver
+        delivered << notification
+      end
+    end
+  end
+end

data/lib/noticed/delivery_method.rb

@@ -1,16 +1,26 @@
 module Noticed
-  class DeliveryMethod < ApplicationJob
+  class DeliveryMethod < Noticed.parent_class.constantize
     include ApiClient
     include RequiredOptions
 
+    extend ActiveModel::Callbacks
+    define_model_callbacks :deliver
+
     class_attribute :logger, default: Rails.logger
 
     attr_reader :config, :event, :notification
     delegate :recipient, to: :notification
+    delegate :record, :params, to: :event
 
-    def perform(delivery_method_name, notification, overrides: {})
-      @notification = notification
-      @event = notification.event
+    def perform(delivery_method_name, notification, recipient: nil, params: {}, overrides: {})
+      # Ephemeral notifications
+      if notification.is_a? String
+        @notification = notification.constantize.new_with_params(recipient, params)
+        @event = @notification.event
+      else
+        @notification = notification
+        @event = notification.event
+      end
 
       # Look up config from Notifier and merge overrides
       @config = event.delivery_methods.fetch(delivery_method_name).config.merge(overrides)
@@ -18,7 +28,9 @@ module Noticed
       return false if config.has_key?(:if) && !evaluate_option(:if)
       return false if config.has_key?(:unless) && evaluate_option(:unless)
 
-      deliver
+      run_callbacks :deliver do
+        deliver
+      end
     end
 
     def deliver
@@ -39,7 +51,7 @@ module Noticed
 
       # Call method if symbol and matching method on Notifier
       elsif option.is_a?(Symbol) && event.respond_to?(option)
-        event.send(option, self)
+        event.send(option, notification)
 
       # Return the value
       else

data/lib/noticed/delivery_methods/action_cable.rb

@@ -1,11 +1,11 @@
 module Noticed
   module DeliveryMethods
     class ActionCable < DeliveryMethod
-      required_options :channel, :stream, :message
+      required_options :message
 
       def deliver
-        channel = fetch_constant(:channel)
-        stream = evaluate_option(:stream)
+        channel = fetch_constant(:channel) || Noticed::NotificationChannel
+        stream = evaluate_option(:stream) || recipient
         message = evaluate_option(:message)
 
         channel.broadcast_to stream, message

data/lib/noticed/delivery_methods/email.rb

@@ -6,14 +6,18 @@ module Noticed
       def deliver
         mailer = fetch_constant(:mailer)
         email = evaluate_option(:method)
-        params = (evaluate_option(:params) || notification&.params || {}).merge(record: notification&.record)
-        args = evaluate_option(:args)
-
-        mail = mailer.with(params)
-        mail = args.present? ? mail.send(email, *args) : mail.send(email)
-
+        args = evaluate_option(:args) || []
+        mail = mailer.with(params).send(email, *args)
         (!!evaluate_option(:enqueue)) ? mail.deliver_later : mail.deliver_now
       end
+
+      def params
+        (evaluate_option(:params) || notification&.params || {}).merge(
+          notification: notification,
+          record: notification&.record,
+          recipient: notification&.recipient
+        )
+      end
     end
   end
 end

data/lib/noticed/delivery_methods/fcm.rb

@@ -14,7 +14,7 @@ module Noticed
       def send_notification(device_token)
         post_request("https://fcm.googleapis.com/v1/projects/#{credentials[:project_id]}/messages:send",
           headers: {authorization: "Bearer #{access_token}"},
-          json: notification.instance_exec(device_token, &config[:json]))
+          json: format_notification(device_token))
       rescue Noticed::ResponseUnsuccessful => exception
         if exception.response.code == "404" && config[:invalid_token]
           notification.instance_exec(device_token, &config[:invalid_token])
@@ -23,6 +23,15 @@ module Noticed
         end
       end
 
+      def format_notification(device_token)
+        method = config[:json]
+        if method.is_a?(Symbol) && event.respond_to?(method)
+          event.send(method, device_token)
+        else
+          notification.instance_exec(device_token, &method)
+        end
+      end
+
       def credentials
         @credentials ||= begin
           value = evaluate_option(:credentials)

data/lib/noticed/delivery_methods/ios.rb

@@ -32,7 +32,12 @@ module Noticed
       def format_notification(apn)
         apn.topic = evaluate_option(:bundle_identifier)
 
-        if (method = config[:format])
+        method = config[:format]
+        # Call method on Notifier if defined
+        if method&.is_a?(Symbol) && event.respond_to?(method)
+          event.send(method, apn)
+        # If Proc, evaluate it on the Notification
+        elsif method&.respond_to?(:call)
           notification.instance_exec(apn, &method)
         elsif notification.params.try(:has_key?, :message)
           apn.alert = notification.params[:message]
@@ -70,9 +75,9 @@ module Noticed
       def connection_pool_options
         {
           auth_method: :token,
-          cert_path: StringIO.new(config.fetch(:apns_key)),
-          key_id: config.fetch(:key_id),
-          team_id: config.fetch(:team_id)
+          cert_path: StringIO.new(evaluate_option(:apns_key)),
+          key_id: evaluate_option(:key_id),
+          team_id: evaluate_option(:team_id)
         }
       end
 

data/lib/noticed/engine.rb

@@ -1,5 +1,11 @@
 module Noticed
   class Engine < ::Rails::Engine
     isolate_namespace Noticed
+
+    initializer "noticed.has_notifications" do
+      ActiveSupport.on_load(:active_record) do
+        include Noticed::HasNotifications
+      end
+    end
   end
 end

data/lib/noticed/has_notifications.rb

@@ -0,0 +1,49 @@
+module Noticed
+  module HasNotifications
+    # Defines a method for the association and a before_destroy callback to remove notifications
+    # where this record is a param
+    #
+    #    class User < ApplicationRecord
+    #      has_noticed_notifications
+    #      has_noticed_notifications param_name: :owner, destroy: false, model: "Notification"
+    #    end
+    #
+    #    @user.notifications_as_user
+    #    @user.notifications_as_owner
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_noticed_notifications(param_name: model_name.singular, **options)
+        define_method :"notifications_as_#{param_name}" do
+          model = options.fetch(:model_name, "Noticed::Event").constantize
+          case current_adapter
+          when "postgresql", "postgis"
+            model.where("params @> ?", Noticed::Coder.dump(param_name.to_sym => self).to_json)
+          when "mysql2"
+            model.where("JSON_CONTAINS(params, ?)", Noticed::Coder.dump(param_name.to_sym => self).to_json)
+          when "sqlite3"
+            model.where("json_extract(params, ?) = ?", "$.#{param_name}", Noticed::Coder.dump(self).to_json)
+          else
+            # This will perform an exact match which isn't ideal
+            model.where(params: {param_name.to_sym => self})
+          end
+        end
+
+        if options.fetch(:destroy, true)
+          before_destroy do
+            send(:"notifications_as_#{param_name}").destroy_all
+          end
+        end
+      end
+    end
+
+    def current_adapter
+      if ActiveRecord::Base.respond_to?(:connection_db_config)
+        ActiveRecord::Base.connection_db_config.adapter
+      else
+        ActiveRecord::Base.connection_config[:adapter]
+      end
+    end
+  end
+end

data/lib/noticed/notification_channel.rb

@@ -0,0 +1,19 @@
+module Noticed
+  class NotificationChannel < ApplicationCable::Channel
+    def subscribed
+      stream_for current_user
+    end
+
+    def unsubscribed
+      stop_all_streams
+    end
+
+    def mark_as_seen(data)
+      current_user.notifications.where(id: data["ids"]).mark_as_seen
+    end
+
+    def mark_as_read(data)
+      current_user.notifications.where(id: data["ids"]).mark_as_read
+    end
+  end
+end

data/lib/noticed/version.rb

@@ -1,3 +1,3 @@
 module Noticed
-  VERSION = "2.0.0"
+  VERSION = "2.1.1"
 end

data/lib/noticed.rb

@@ -14,12 +14,15 @@ module Noticed
   autoload :BulkDeliveryMethod, "noticed/bulk_delivery_method"
   autoload :Coder, "noticed/coder"
   autoload :DeliveryMethod, "noticed/delivery_method"
+  autoload :HasNotifications, "noticed/has_notifications"
+  autoload :NotificationChannel, "noticed/notification_channel"
   autoload :RequiredOptions, "noticed/required_options"
   autoload :Translation, "noticed/translation"
 
   module BulkDeliveryMethods
     autoload :Discord, "noticed/bulk_delivery_methods/discord"
     autoload :Slack, "noticed/bulk_delivery_methods/slack"
+    autoload :Test, "noticed/bulk_delivery_methods/test"
     autoload :Webhook, "noticed/bulk_delivery_methods/webhook"
   end
 
@@ -39,6 +42,9 @@ module Noticed
     autoload :Webhook, "noticed/delivery_methods/webhook"
   end
 
+  mattr_accessor :parent_class
+  @@parent_class = "Noticed::ApplicationJob"
+
   class ValidationError < StandardError
   end