noticed 1.6.3 → 2.0.1

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,22 @@
 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
+        mailer = fetch_constant(:mailer)
+        email = evaluate_option(:method)
+        args = evaluate_option(:args) || []
+        mail = mailer.with(params).send(email, *args)
+        (!!evaluate_option(:enqueue)) ? mail.deliver_later : mail.deliver_now
       end
 
-      private
-
-      # 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
-
-      def format
-        params = if (method = options[:format])
-          notification.send(method)
-        else
-          notification.params
-        end
-        params.merge(recipient: recipient, record: record)
+      def params
+        (evaluate_option(:params) || notification&.params || {}).merge(
+          notification: notification,
+          record: notification&.record,
+          recipient: notification&.recipient
+        )
       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

data/lib/noticed/delivery_methods/ios.rb

@@ -2,26 +2,24 @@ require "apnotic"
 
 module Noticed
   module DeliveryMethods
-    class Ios < Base
-      cattr_accessor :connection_pool
+    class Ios < DeliveryMethod
+      cattr_accessor :development_connection_pool, :production_connection_pool
+
+      required_options :bundle_identifier, :key_id, :team_id, :apns_key, :device_tokens
 
       def deliver
-        raise ArgumentError, "bundle_identifier is missing" if bundle_identifier.blank?
-        raise ArgumentError, "key_id is missing" if key_id.blank?
-        raise ArgumentError, "team_id is missing" if team_id.blank?
-        raise ArgumentError, "Could not find APN cert at '#{cert_path}'" unless valid_cert_path?
+        evaluate_option(:device_tokens).each do |device_token|
+          apn = Apnotic::Notification.new(device_token)
+          format_notification(apn)
 
-        device_tokens.each do |device_token|
+          connection_pool = (!!evaluate_option(:development)) ? development_pool : production_pool
           connection_pool.with do |connection|
-            apn = Apnotic::Notification.new(device_token)
-            format_notification(apn)
-
             response = connection.push(apn)
             raise "Timeout sending iOS push notification" unless response
 
-            if bad_token?(response)
+            if bad_token?(response) && config[:invalid_token]
               # Allow notification to cleanup invalid iOS device tokens
-              cleanup_invalid_token(device_token)
+              notification.instance_exec(device_token, &config[:invalid_token])
             elsif !response.ok?
               raise "Request failed #{response.body}"
             end
@@ -32,53 +30,37 @@ module Noticed
       private
 
       def format_notification(apn)
-        apn.topic = bundle_identifier
+        apn.topic = evaluate_option(:bundle_identifier)
 
-        if (method = options[:format])
-          notification.send(method, apn)
-        elsif params[:message].present?
-          apn.alert = params[:message]
+        if (method = config[:format])
+          notification.instance_exec(apn, &method)
+        elsif notification.params.try(:has_key?, :message)
+          apn.alert = notification.params[:message]
         else
           raise ArgumentError, "No message for iOS delivery. Either include message in params or add the 'format' option in 'deliver_by :ios'."
         end
       end
 
-      def device_tokens
-        if notification.respond_to?(:ios_device_tokens)
-          Array.wrap(notification.ios_device_tokens(recipient))
-        else
-          raise NoMethodError, <<~MESSAGE
-            You must implement `ios_device_tokens` to send iOS notifications
-
-            # This must return an Array of iOS device tokens
-            def ios_device_tokens(recipient)
-              recipient.ios_device_tokens.pluck(:token)
-            end
-          MESSAGE
-        end
-      end
-
       def bad_token?(response)
         response.status == "410" || (response.status == "400" && response.body["reason"] == "BadDeviceToken")
       end
 
-      def cleanup_invalid_token(token)
-        return unless notification.respond_to?(:cleanup_device_token)
-        notification.send(:cleanup_device_token, token: token, platform: "iOS")
+      def development_pool
+        self.class.development_connection_pool ||= new_connection_pool(development: true)
       end
 
-      def connection_pool
-        self.class.connection_pool ||= new_connection_pool
+      def production_pool
+        self.class.production_connection_pool ||= new_connection_pool(development: false)
       end
 
-      def new_connection_pool
+      def new_connection_pool(development:)
         handler = proc do |connection|
           connection.on(:error) do |exception|
             Rails.logger.info "Apnotic exception raised: #{exception}"
           end
         end
 
-        if development?
+        if development
           Apnotic::ConnectionPool.development(connection_pool_options, pool_options, &handler)
         else
           Apnotic::ConnectionPool.new(connection_pool_options, pool_options, &handler)
@@ -88,83 +70,14 @@ module Noticed
       def connection_pool_options
         {
           auth_method: :token,
-          cert_path: cert_path,
-          key_id: key_id,
-          team_id: team_id
+          cert_path: StringIO.new(config.fetch(:apns_key)),
+          key_id: config.fetch(:key_id),
+          team_id: config.fetch(:team_id)
         }
       end
 
-      def bundle_identifier
-        option = options[:bundle_identifier]
-        case option
-        when String
-          option
-        when Symbol
-          notification.send(option)
-        else
-          Rails.application.credentials.dig(:ios, :bundle_identifier)
-        end
-      end
-
-      def cert_path
-        option = options[:cert_path]
-        case option
-        when String
-          option
-        when Symbol
-          notification.send(option)
-        else
-          Rails.root.join("config/certs/ios/apns.p8")
-        end
-      end
-
-      def key_id
-        option = options[:key_id]
-        case option
-        when String
-          option
-        when Symbol
-          notification.send(option)
-        else
-          Rails.application.credentials.dig(:ios, :key_id)
-        end
-      end
-
-      def team_id
-        option = options[:team_id]
-        case option
-        when String
-          option
-        when Symbol
-          notification.send(option)
-        else
-          Rails.application.credentials.dig(:ios, :team_id)
-        end
-      end
-
-      def development?
-        option = options[:development]
-        case option
-        when Symbol
-          !!notification.send(option)
-        else
-          !!option
-        end
-      end
-
-      def valid_cert_path?
-        case cert_path
-        when File, StringIO
-          cert_path.size > 0
-        else
-          File.exist?(cert_path)
-        end
-      end
-
       def pool_options
-        {
-          size: options.fetch(:pool_size, 5)
-        }
+        {size: evaluate_option(:pool_size) || 5}
       end
     end
   end

data/lib/noticed/delivery_methods/microsoft_teams.rb

@@ -1,31 +1,14 @@
 module Noticed
   module DeliveryMethods
-    class MicrosoftTeams < Base
-      def deliver
-        post(url, json: format)
-      end
+    class MicrosoftTeams < DeliveryMethod
+      required_options :json
 
-      private
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          {
-            title: notification.params[:title],
-            text: notification.params[:text],
-            sections: notification.params[:sections],
-            potentialAction: notification.params[:notification_action]
-          }
-        end
+      def deliver
+        post_request url, headers: evaluate_option(:headers), json: evaluate_option(:json)
       end
 
       def url
-        if (method = options[:url])
-          notification.send(method)
-        else
-          Rails.application.credentials.microsoft_teams[:notification_url]
-        end
+        evaluate_option(:url) || Rails.application.credentials.dig(:microsoft_teams, :notification_url)
       end
     end
   end

data/lib/noticed/delivery_methods/slack.rb

@@ -1,26 +1,16 @@
 module Noticed
   module DeliveryMethods
-    class Slack < Base
-      def deliver
-        post(url, json: format)
-      end
+    class Slack < DeliveryMethod
+      DEFAULT_URL = "https://slack.com/api/chat.postMessage"
 
-      private
+      required_options :json
 
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          notification.params
-        end
+      def deliver
+        post_request url, headers: evaluate_option(:headers), json: evaluate_option(:json)
       end
 
       def url
-        if (method = options[:url])
-          notification.send(method)
-        else
-          Rails.application.credentials.slack[:notification_url]
-        end
+        evaluate_option(:url) || DEFAULT_URL
       end
     end
   end

data/lib/noticed/delivery_methods/test.rb

@@ -1,20 +1,10 @@
 module Noticed
   module DeliveryMethods
-    class Test < Base
+    class Test < DeliveryMethod
       class_attribute :delivered, default: []
-      class_attribute :callbacks, default: []
-
-      after_deliver do
-        self.class.callbacks << :after
-      end
-
-      def self.clear!
-        delivered.clear
-        callbacks.clear
-      end
 
       def deliver
-        self.class.delivered << notification
+        delivered << notification
       end
     end
   end

data/lib/noticed/delivery_methods/twilio_messaging.rb

@@ -0,0 +1,37 @@
+module Noticed
+  module DeliveryMethods
+    class TwilioMessaging < DeliveryMethod
+      def deliver
+        post_request url, basic_auth: {user: account_sid, pass: auth_token}, form: json
+      end
+
+      def json
+        evaluate_option(:json) || {
+          From: phone_number,
+          To: recipient.phone_number,
+          Body: params.fetch(:message)
+        }
+      end
+
+      def url
+        evaluate_option(:url) || "https://api.twilio.com/2010-04-01/Accounts/#{account_sid}/Messages.json"
+      end
+
+      def account_sid
+        evaluate_option(:account_sid) || credentials.fetch(:account_sid)
+      end
+
+      def auth_token
+        evaluate_option(:auth_token) || credentials.fetch(:auth_token)
+      end
+
+      def phone_number
+        evaluate_option(:phone_number) || credentials.fetch(:phone_number)
+      end
+
+      def credentials
+        evaluate_option(:credentials) || Rails.application.credentials.twilio
+      end
+    end
+  end
+end

data/lib/noticed/delivery_methods/vonage_sms.rb

@@ -0,0 +1,20 @@
+module Noticed
+  module DeliveryMethods
+    class VonageSms < DeliveryMethod
+      DEFAULT_URL = "https://rest.nexmo.com/sms/json"
+
+      required_options :json
+
+      def deliver
+        headers = evaluate_option(:headers)
+        json = evaluate_option(:json)
+        response = post_request url, headers: headers, json: json
+        raise ResponseUnsuccessful.new(response, url, headers: headers, json: json) if JSON.parse(response.body).dig("messages", 0, "status") != "0"
+      end
+
+      def url
+        evaluate_option(:url) || DEFAULT_URL
+      end
+    end
+  end
+end

data/lib/noticed/delivery_methods/webhook.rb

@@ -0,0 +1,17 @@
+module Noticed
+  module DeliveryMethods
+    class Webhook < DeliveryMethod
+      required_options :url
+
+      def deliver
+        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/engine.rb

@@ -1,13 +1,5 @@
 module Noticed
   class Engine < ::Rails::Engine
-    initializer "noticed.has_notifications" do
-      ActiveSupport.on_load(:active_record) do
-        include Noticed::HasNotifications
-      end
-    end
-
-    initializer "noticed.rails_5_2_support" do
-      require "rails_6_polyfills/base" if Rails::VERSION::MAJOR < 6
-    end
+    isolate_namespace Noticed
   end
 end

data/lib/noticed/required_options.rb

@@ -0,0 +1,21 @@
+module Noticed
+  module RequiredOptions
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :required_option_names, instance_writer: false, default: []
+    end
+
+    class_methods do
+      def inherited(base)
+        base.required_option_names = required_option_names.dup
+        super
+      end
+
+      def required_options(*names)
+        required_option_names.concat names
+      end
+      alias_method :required_option, :required_options
+    end
+  end
+end

data/lib/noticed/translation.rb

@@ -4,7 +4,7 @@ module Noticed
 
     # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
     def i18n_scope
-      :notifications
+      :notifiers
     end
 
     def class_scope
@@ -12,13 +12,17 @@ module Noticed
     end
 
     def translate(key, **options)
-      I18n.translate(scope_translation_key(key), **options)
+      if defined?(::ActiveSupport::HtmlSafeTranslation)
+        ActiveSupport::HtmlSafeTranslation.translate scope_translation_key(key), **options
+      else
+        I18n.translate scope_translation_key(key), **options
+      end
     end
     alias_method :t, :translate
 
     def scope_translation_key(key)
       if key.to_s.start_with?(".")
-        "#{i18n_scope}.#{class_scope}#{key}"
+        [i18n_scope, class_scope].compact.join(".") + key
       else
         key
       end