noticed 1.6.2 → 2.0.0

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,16 @@
+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
+
+    attribute :params, default: {}
+  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/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,50 @@
+module Noticed
+  class DeliveryMethod < ApplicationJob
+    include ApiClient
+    include RequiredOptions
+
+    class_attribute :logger, default: Rails.logger
+
+    attr_reader :config, :event, :notification
+    delegate :recipient, to: :notification
+
+    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

data/lib/noticed/delivery_methods/action_cable.rb

@@ -1,46 +1,14 @@
 module Noticed
   module DeliveryMethods
-    class ActionCable < Base
-      def deliver
-        channel.broadcast_to stream, format
-      end
+    class ActionCable < DeliveryMethod
+      required_options :channel, :stream, :message
 
-      private
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          notification.params
-        end
-      end
-
-      def channel
-        @channel ||= begin
-          value = options[:channel]
-          case value
-          when String
-            value.constantize
-          when Symbol
-            notification.send(value)
-          when Class
-            value
-          else
-            Noticed::NotificationChannel
-          end
-        end
-      end
+      def deliver
+        channel = fetch_constant(:channel)
+        stream = evaluate_option(:stream)
+        message = evaluate_option(:message)
 
-      def stream
-        value = options[:stream]
-        case value
-        when String
-          value
-        when Symbol
-          notification.send(value)
-        else
-          recipient
-        end
+        channel.broadcast_to stream, message
       end
     end
   end

data/lib/noticed/delivery_methods/discord.rb

@@ -0,0 +1,11 @@
+module Noticed
+  module DeliveryMethods
+    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/delivery_methods/email.rb

@@ -1,54 +1,18 @@
 module Noticed
   module DeliveryMethods
-    class Email < Base
-      option :mailer
+    class Email < DeliveryMethod
+      required_options :mailer, :method
 
       def deliver
-        if options[:enqueue]
-          mailer.with(format).send(mailer_method.to_sym).deliver_later
-        else
-          mailer.with(format).send(mailer_method.to_sym).deliver_now
-        end
-      end
-
-      private
+        mailer = fetch_constant(:mailer)
+        email = evaluate_option(:method)
+        params = (evaluate_option(:params) || notification&.params || {}).merge(record: notification&.record)
+        args = evaluate_option(:args)
 
-      # mailer: "UserMailer"
-      # mailer: UserMailer
-      # mailer: :my_method - `my_method` should return Class
-      def mailer
-        option = options.fetch(:mailer)
-        case option
-        when String
-          option.constantize
-        when Symbol
-          notification.send(option)
-        else
-          option
-        end
-      end
-
-      # Method should be a symbol
-      #
-      # If notification responds to symbol, call that method and use return value
-      # If notification does not respond to symbol, use the symbol for the mailer method
-      # Otherwise, use the underscored notification class name as the mailer method
-      def mailer_method
-        method_name = options[:method]&.to_sym
-        if method_name.present?
-          notification.respond_to?(method_name) ? notification.send(method_name) : method_name
-        else
-          notification.class.name.underscore
-        end
-      end
+        mail = mailer.with(params)
+        mail = args.present? ? mail.send(email, *args) : mail.send(email)
 
-      def format
-        params = if (method = options[:format])
-          notification.send(method)
-        else
-          notification.params
-        end
-        params.merge(recipient: recipient, record: record)
+        (!!evaluate_option(:enqueue)) ? mail.deliver_later : mail.deliver_now
       end
     end
   end

data/lib/noticed/delivery_methods/fcm.rb

@@ -1,95 +1,54 @@
 require "googleauth"
 
-# class CommentNotifier
-#  deliver_by :fcm, credentials: Rails.root.join("config/certs/fcm.json"), format: :format_notification
-#
-#  deliver_by :fcm, credentials: :fcm_credentials
-#   def fcm_credentials
-#     { project_id: "api-12345" }
-#   end
-# end
-
 module Noticed
   module DeliveryMethods
-    class Fcm < Base
-      BASE_URI = "https://fcm.googleapis.com/v1/projects/"
-
-      option :format
+    class Fcm < DeliveryMethod
+      required_option :credentials, :device_tokens, :json
 
       def deliver
-        device_tokens.each do |device_token|
-          post("#{BASE_URI}#{project_id}/messages:send", headers: {authorization: "Bearer #{access_token}"}, json: {message: format(device_token)})
-        rescue ResponseUnsuccessful => exception
-          if exception.response.code == 404
-            cleanup_invalid_token(device_token)
-          else
-            raise
-          end
+        evaluate_option(:device_tokens).each do |device_token|
+          send_notification device_token
         end
       end
 
-      def cleanup_invalid_token(device_token)
-        return unless notification.respond_to?(:cleanup_device_token)
-        notification.send(:cleanup_device_token, token: device_token, platform: "fcm")
+      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]))
+      rescue Noticed::ResponseUnsuccessful => exception
+        if exception.response.code == "404" && config[:invalid_token]
+          notification.instance_exec(device_token, &config[:invalid_token])
+        else
+          raise
+        end
       end
 
       def credentials
         @credentials ||= begin
-          option = options[:credentials]
-          credentials_hash = case option
+          value = evaluate_option(:credentials)
+          case value
           when Hash
-            option
+            value
           when Pathname
-            load_json(option)
+            load_json(value)
           when String
-            load_json(Rails.root.join(option))
-          when Symbol
-            notification.send(option)
+            load_json(Rails.root.join(value))
           else
-            Rails.application.credentials.fcm
+            raise ArgumentError, "FCM credentials must be a Hash, String, Pathname, or Symbol"
           end
-
-          credentials_hash.symbolize_keys
         end
       end
 
       def load_json(path)
-        JSON.parse(File.read(path))
-      end
-
-      def project_id
-        credentials[:project_id]
+        JSON.parse(File.read(path), symbolize_names: true)
       end
 
       def access_token
-        token = authorizer.fetch_access_token!
-        token["access_token"]
-      end
-
-      def authorizer
-        @authorizer ||= options.fetch(:authorizer, Google::Auth::ServiceAccountCredentials).make_creds(
+        @authorizer ||= (evaluate_option(:authorizer) || Google::Auth::ServiceAccountCredentials).make_creds(
           json_key_io: StringIO.new(credentials.to_json),
           scope: "https://www.googleapis.com/auth/firebase.messaging"
         )
-      end
-
-      def format(device_token)
-        notification.send(options[:format], device_token)
-      end
-
-      def device_tokens
-        if notification.respond_to?(:fcm_device_tokens)
-          Array.wrap(notification.fcm_device_tokens(recipient))
-        else
-          raise NoMethodError, <<~MESSAGE
-            You must implement `fcm_device_tokens` to send Firebase Cloud Messaging notifications
-
-            # This must return an Array of FCM device tokens
-            def fcm_device_tokens(recipient)
-              recipient.fcm_device_tokens.pluck(:token)
-            end
-          MESSAGE
-        end
+        @authorizer.fetch_access_token!["access_token"]
       end
     end
   end