noticed 1.6.3 → 2.0.1

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,78 @@
+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_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
+
+    def unread?
+      !read_at?
+    end
+
+    def seen?
+      seen_at?
+    end
+
+    def unseen?
+      !seen_at?
+    end
+  end
+end

data/app/models/noticed/application_record.rb

@@ -0,0 +1,6 @@
+module Noticed
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name_prefix = "noticed_"
+  end
+end

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

@@ -0,0 +1,43 @@
+module Noticed
+  module Deliverable
+    class DeliverBy
+      attr_reader :name, :config, :bulk
+
+      def initialize(name, config, bulk: false)
+        @name, @config, @bulk, = name, config, bulk
+      end
+
+      def constant
+        namespace = bulk ? "Noticed::BulkDeliveryMethods" : "Noticed::DeliveryMethods"
+        config.fetch(:class, [namespace, name.to_s.camelize].join("::")).constantize
+      end
+
+      def validate!
+        constant.required_option_names.each do |option|
+          raise ValidationError, "option `#{option}` must be set for `deliver_by :#{name}`" unless config[option].present?
+        end
+      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)
+
+        constant.set(options).perform_later(name, event_or_notification)
+      end
+
+      def evaluate_option(name, context)
+        option = config[name]
+
+        if option&.respond_to?(:call)
+          context.instance_exec(&option)
+        elsif option.is_a?(Symbol) && context.respond_to?(option)
+          context.send(option)
+        else
+          option
+        end
+      end
+    end
+  end
+end

data/app/models/noticed/event.rb

@@ -0,0 +1,15 @@
+module Noticed
+  class Event < ApplicationRecord
+    include Deliverable
+    include NotificationMethods
+    include Translation
+    include Rails.application.routes.url_helpers
+
+    belongs_to :record, polymorphic: true, optional: true
+    has_many :notifications, dependent: :delete_all
+
+    accepts_nested_attributes_for :notifications
+
+    scope :newest_first, -> { order(created_at: :desc) }
+  end
+end

data/app/models/noticed/notification.rb

@@ -0,0 +1,14 @@
+module Noticed
+  class Notification < ApplicationRecord
+    include Rails.application.routes.url_helpers
+    include Readable
+    include Translation
+
+    belongs_to :event
+    belongs_to :recipient, polymorphic: true
+
+    scope :newest_first, -> { order(created_at: :desc) }
+
+    delegate :params, :record, to: :event
+  end
+end

data/db/migrate/20231215190233_create_noticed_tables.rb

@@ -0,0 +1,25 @@
+class CreateNoticedTables < ActiveRecord::Migration[6.1]
+  def change
+    create_table :noticed_events do |t|
+      t.string :type
+      t.belongs_to :record, polymorphic: true
+      if t.respond_to?(:jsonb)
+        t.jsonb :params
+      else
+        t.json :params
+      end
+
+      t.timestamps
+    end
+
+    create_table :noticed_notifications do |t|
+      t.string :type
+      t.belongs_to :event, null: false
+      t.belongs_to :recipient, polymorphic: true, null: false
+      t.datetime :read_at
+      t.datetime :seen_at
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/noticed/delivery_method_generator.rb

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

data/lib/generators/noticed/install_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Noticed
+  module Generators
+    class ModelGenerator < Rails::Generators::Base
+      include Rails::Generators::ResourceHelpers
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_migrations
+        rails_command "railties:install:migrations FROM=noticed", inline: true
+      end
+
+      def done
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/noticed/{notification_generator.rb → notifier_generator.rb}

@@ -4,7 +4,7 @@ require "rails/generators/named_base"
 
 module Noticed
   module Generators
-    class NotificationGenerator < Rails::Generators::NamedBase
+    class NotifierGenerator < Rails::Generators::NamedBase
       include Rails::Generators::ResourceHelpers
 
       source_root File.expand_path("../templates", __FILE__)
@@ -12,7 +12,7 @@ module Noticed
       desc "Generates a notification with the given NAME."
 
       def generate_notification
-        template "notification.rb", "app/notifications/#{file_path}.rb"
+        template "notifier.rb", "app/notifiers/#{file_path}.rb"
       end
     end
   end

data/lib/generators/noticed/templates/README

@@ -1,7 +1,8 @@
 
-🚚 Your notifications database model has been generated!
+🚚 You're ready to start sending notifications!
 
 Next steps:
-1. Run "rails db:migrate"
-2. Add "has_many :notifications, as: :recipient, dependent: :destroy" to your User model(s).
-3. Generate notifications with "rails g noticed:notification"
+1. Run `rails db:migrate`
+2. Add `has_many :notifications, as: :recipient, dependent: :destroy, class_name: "Noticed::Notification"` to your User model(s).
+2. Add `has_many :notifications, as: :record, dependent: :destroy, class_name: "Noticed::Event"` to your model(s) that notifications reference.
+3. Generate notifiers with "rails g noticed:notifier"

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

@@ -1,12 +1,8 @@
-class DeliveryMethods::<%= class_name %> < Noticed::DeliveryMethods::Base
+class DeliveryMethods::<%= class_name %> < Noticed::DeliveryMethod
+  # 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

@@ -0,0 +1,24 @@
+# To deliver this notification:
+#
+# <%= class_name %>.with(record: @post, message: "New post").deliver(User.all)
+
+class <%= class_name %> < Noticed::Event
+  # Add your delivery methods
+  #
+  # deliver_by :email do |config|
+  #   config.mailer = "UserMailer"
+  #   config.method = "new_post"
+  # end
+  #
+  # bulk_deliver_by :slack do |config|
+  #   config.url = -> { Rails.application.credentials.slack_webhook_url }
+  # end
+  #
+  # deliver_by :custom do |config|
+  #   config.class = "MyDeliveryMethod"
+  # end
+
+  # Add required params
+  #
+  # required_param :message
+end

data/lib/noticed/api_client.rb

@@ -0,0 +1,44 @@
+require "net/http"
+
+module Noticed
+  module ApiClient
+    extend ActiveSupport::Concern
+
+    # Helper method for making POST requests from delivery methods
+    #
+    # Usage:
+    #   post_request("http://example.com", basic_auth: {user:, pass:}, headers: {}, json: {}, form: {})
+    #
+    def post_request(url, args = {})
+      args.compact!
+
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.instance_of? URI::HTTPS
+
+      headers = args.delete(:headers) || {}
+      headers["Content-Type"] = "application/json" if args.has_key?(:json)
+
+      request = Net::HTTP::Post.new(uri.request_uri, headers)
+
+      if (basic_auth = args.delete(:basic_auth))
+        request.basic_auth basic_auth.fetch(:user), basic_auth.fetch(:pass)
+      end
+
+      if (json = args.delete(:json))
+        request.body = json.to_json
+      elsif (form = args.delete(:form))
+        request.set_form(form, "multipart/form-data")
+      end
+
+      logger.debug("POST #{url}")
+      logger.debug(request.body)
+      response = http.request(request)
+      logger.debug("Response: #{response.code}: #{response.body.inspect}")
+
+      raise ResponseUnsuccessful.new(response, url, args) unless response.code.start_with?("20")
+
+      response
+    end
+  end
+end

data/lib/noticed/bulk_delivery_method.rb

@@ -0,0 +1,46 @@
+module Noticed
+  class BulkDeliveryMethod < ApplicationJob
+    include ApiClient
+    include RequiredOptions
+
+    class_attribute :logger, default: Rails.logger
+
+    attr_reader :config, :event
+
+    def perform(delivery_method_name, event)
+      @event = event
+      @config = event.bulk_delivery_methods.fetch(delivery_method_name).config
+
+      return false if config.has_key?(:if) && !evaluate_option(:if)
+      return false if config.has_key?(:unless) && evaluate_option(:unless)
+
+      deliver
+    end
+
+    def deliver
+      raise NotImplementedError, "Bulk delivery methods must implement the `deliver` method"
+    end
+
+    def fetch_constant(name)
+      option = config[name]
+      option.is_a?(String) ? option.constantize : option
+    end
+
+    def evaluate_option(name)
+      option = config[name]
+
+      # Evaluate Proc within the context of the notifier
+      if option&.respond_to?(:call)
+        event.instance_exec(&option)
+
+      # Call method if symbol and matching method
+      elsif option.is_a?(Symbol) && event.respond_to?(option)
+        event.send(option)
+
+      # Return the value
+      else
+        option
+      end
+    end
+  end
+end

data/lib/noticed/bulk_delivery_methods/discord.rb

@@ -0,0 +1,11 @@
+module Noticed
+  module BulkDeliveryMethods
+    class Discord < BulkDeliveryMethod
+      required_options :json, :url
+
+      def deliver
+        post_request evaluate_option(:url), headers: evaluate_option(:headers), json: evaluate_option(:json)
+      end
+    end
+  end
+end

data/lib/noticed/bulk_delivery_methods/slack.rb

@@ -0,0 +1,17 @@
+module Noticed
+  module BulkDeliveryMethods
+    class Slack < BulkDeliveryMethod
+      DEFAULT_URL = "https://slack.com/api/chat.postMessage"
+
+      required_options :json
+
+      def deliver
+        post_request url, headers: evaluate_option(:headers), json: evaluate_option(:json)
+      end
+
+      def url
+        evaluate_option(:url) || DEFAULT_URL
+      end
+    end
+  end
+end

data/lib/noticed/bulk_delivery_methods/webhook.rb

@@ -0,0 +1,18 @@
+module Noticed
+  module BulkDeliveryMethods
+    class Webhook < BulkDeliveryMethod
+      required_options :url
+
+      def deliver
+        Rails.logger.debug(evaluate_option(:json))
+        post_request(
+          evaluate_option(:url),
+          basic_auth: evaluate_option(:basic_auth),
+          headers: evaluate_option(:headers),
+          json: evaluate_option(:json),
+          form: evaluate_option(:form)
+        )
+      end
+    end
+  end
+end

data/lib/noticed/coder.rb

@@ -1,3 +1,5 @@
+require "active_job/arguments"
+
 module Noticed
   class Coder
     def self.load(data)

data/lib/noticed/delivery_method.rb

@@ -0,0 +1,51 @@
+module Noticed
+  class DeliveryMethod < ApplicationJob
+    include ApiClient
+    include RequiredOptions
+
+    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
+
+      # Look up config from Notifier and merge overrides
+      @config = event.delivery_methods.fetch(delivery_method_name).config.merge(overrides)
+
+      return false if config.has_key?(:if) && !evaluate_option(:if)
+      return false if config.has_key?(:unless) && evaluate_option(:unless)
+
+      deliver
+    end
+
+    def deliver
+      raise NotImplementedError, "Delivery methods must implement the `deliver` method"
+    end
+
+    def fetch_constant(name)
+      option = config[name]
+      option.is_a?(String) ? option.constantize : option
+    end
+
+    def evaluate_option(name)
+      option = config[name]
+
+      # Evaluate Proc within the context of the Notification
+      if option&.respond_to?(:call)
+        notification.instance_exec(&option)
+
+      # Call method if symbol and matching method on Notifier
+      elsif option.is_a?(Symbol) && event.respond_to?(option)
+        event.send(option, self)
+
+      # Return the value
+      else
+        option
+      end
+    end
+  end
+end