noticed 1.3.2 → 1.6.3

data/lib/noticed/delivery_methods/base.rb

@@ -6,11 +6,11 @@ module Noticed
 
       class_attribute :option_names, instance_writer: false, default: []
 
-      attr_reader :notification, :options, :params, :recipient, :record
+      attr_reader :notification, :options, :params, :recipient, :record, :logger
 
       class << self
         # Copy option names from parent
-        def inherited(base) #:nodoc:
+        def inherited(base) # :nodoc:
           base.option_names = option_names.dup
           super
         end
@@ -29,16 +29,24 @@ module Noticed
         end
       end
 
-      def perform(args)
-        @notification = args[:notification_class].constantize.new(args[:params])
-        @options = args[:options]
+      def assign_args(args)
+        @notification = args.fetch(:notification_class).constantize.new(args[:params])
+        @options = args[:options] || {}
         @params = args[:params]
         @recipient = args[:recipient]
         @record = args[:record]
 
+        # Set the default logger
+        @logger = @options.fetch(:logger, Rails.logger)
+
         # Make notification aware of database record and recipient during delivery
         @notification.record = args[:record]
         @notification.recipient = args[:recipient]
+        self
+      end
+
+      def perform(args)
+        assign_args(args)
 
         return if (condition = @options[:if]) && !@notification.send(condition)
         return if (condition = @options[:unless]) && @notification.send(condition)
@@ -57,25 +65,26 @@ module Noticed
       # Helper method for making POST requests from delivery methods
       #
       # Usage:
-      #   post("http://example.com", basic_auth: {user:, pass:}, json: {}, form: {})
+      #   post("http://example.com", basic_auth: {user:, pass:}, headers: {}, json: {}, form: {})
       #
       def post(url, args = {})
         basic_auth = args.delete(:basic_auth)
+        headers = args.delete(:headers)
 
-        request = if basic_auth
-          HTTP.basic_auth(user: basic_auth[:user], pass: basic_auth[:pass])
-        else
-          HTTP
-        end
+        request = HTTP
+        request = request.basic_auth(user: basic_auth[:user], pass: basic_auth[:pass]) if basic_auth
+        request = request.headers(headers) if headers
 
         response = request.post(url, args)
 
         if options[:debug]
-          Rails.logger.debug("POST #{url}")
-          Rails.logger.debug("Response: #{response.code}: #{response}")
+          logger.debug("POST #{url}")
+          logger.debug("Response: #{response.code}: #{response}")
         end
 
         if !options[:ignore_failure] && !response.status.success?
+          puts response.status
+          puts response.body
           raise ResponseUnsuccessful.new(response)
         end
 

data/lib/noticed/delivery_methods/email.rb

@@ -4,17 +4,42 @@ module Noticed
       option :mailer
 
       def deliver
-        mailer.with(format).send(method.to_sym).deliver_now
+        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: "UserMailer"
+      # mailer: UserMailer
+      # mailer: :my_method - `my_method` should return Class
       def mailer
-        options.fetch(:mailer).constantize
+        option = options.fetch(:mailer)
+        case option
+        when String
+          option.constantize
+        when Symbol
+          notification.send(option)
+        else
+          option
+        end
       end
 
-      def method
-        options[:method] || notification.class.name.underscore
+      # 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

data/lib/noticed/delivery_methods/fcm.rb

@@ -0,0 +1,96 @@
+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
+
+      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
+        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")
+      end
+
+      def credentials
+        @credentials ||= begin
+          option = options[:credentials]
+          credentials_hash = case option
+          when Hash
+            option
+          when Pathname
+            load_json(option)
+          when String
+            load_json(Rails.root.join(option))
+          when Symbol
+            notification.send(option)
+          else
+            Rails.application.credentials.fcm
+          end
+
+          credentials_hash.symbolize_keys
+        end
+      end
+
+      def load_json(path)
+        JSON.parse(File.read(path))
+      end
+
+      def project_id
+        credentials[:project_id]
+      end
+
+      def access_token
+        token = authorizer.fetch_access_token!
+        token["access_token"]
+      end
+
+      def authorizer
+        @authorizer ||= options.fetch(: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
+      end
+    end
+  end
+end

data/lib/noticed/delivery_methods/ios.rb

@@ -0,0 +1,171 @@
+require "apnotic"
+
+module Noticed
+  module DeliveryMethods
+    class Ios < Base
+      cattr_accessor :connection_pool
+
+      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?
+
+        device_tokens.each do |device_token|
+          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)
+              # Allow notification to cleanup invalid iOS device tokens
+              cleanup_invalid_token(device_token)
+            elsif !response.ok?
+              raise "Request failed #{response.body}"
+            end
+          end
+        end
+      end
+
+      private
+
+      def format_notification(apn)
+        apn.topic = bundle_identifier
+
+        if (method = options[:format])
+          notification.send(method, apn)
+        elsif params[:message].present?
+          apn.alert = 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")
+      end
+
+      def connection_pool
+        self.class.connection_pool ||= new_connection_pool
+      end
+
+      def new_connection_pool
+        handler = proc do |connection|
+          connection.on(:error) do |exception|
+            Rails.logger.info "Apnotic exception raised: #{exception}"
+          end
+        end
+
+        if development?
+          Apnotic::ConnectionPool.development(connection_pool_options, pool_options, &handler)
+        else
+          Apnotic::ConnectionPool.new(connection_pool_options, pool_options, &handler)
+        end
+      end
+
+      def connection_pool_options
+        {
+          auth_method: :token,
+          cert_path: cert_path,
+          key_id: key_id,
+          team_id: 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)
+        }
+      end
+    end
+  end
+end

data/lib/noticed/engine.rb

@@ -5,5 +5,9 @@ module Noticed
         include Noticed::HasNotifications
       end
     end
+
+    initializer "noticed.rails_5_2_support" do
+      require "rails_6_polyfills/base" if Rails::VERSION::MAJOR < 6
+    end
   end
 end

data/lib/noticed/has_notifications.rb

@@ -1,6 +1,6 @@
 module Noticed
   module HasNotifications
-    # Defines a method for the association and a before_destory callback to remove notifications
+    # Defines a method for the association and a before_destroy callback to remove notifications
     # where this record is a param
     #
     #    class User < ApplicationRecord
@@ -15,10 +15,19 @@ module Noticed
 
     class_methods do
       def has_noticed_notifications(param_name: model_name.singular, **options)
-        model = options.fetch(:model_name, "Notification").constantize
-
         define_method "notifications_as_#{param_name}" do
-          model.where(params: {param_name.to_sym => self})
+          model = options.fetch(:model_name, "Notification").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)
@@ -28,5 +37,13 @@ module Noticed
         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/model.rb

@@ -1,11 +1,23 @@
 module Noticed
   module Model
+    DATABASE_ERROR_CLASS_NAMES = lambda {
+      classes = [ActiveRecord::NoDatabaseError]
+      classes << ActiveRecord::ConnectionNotEstablished
+      classes << Mysql2::Error if defined?(::Mysql2)
+      classes << PG::ConnectionBad if defined?(::PG)
+      classes
+    }.call.freeze
+
     extend ActiveSupport::Concern
 
     included do
       self.inheritance_column = nil
 
-      serialize :params, noticed_coder
+      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
+        serialize :params, coder: noticed_coder
+      else
+        serialize :params, noticed_coder
+      end
 
       belongs_to :recipient, polymorphic: true
 
@@ -32,7 +44,9 @@ module Noticed
         else
           Noticed::TextCoder
         end
-      rescue ActiveRecord::NoDatabaseError
+      rescue *DATABASE_ERROR_CLASS_NAMES => _error
+        warn("Noticed was unable to bootstrap correctly as the database is unavailable.")
+
         Noticed::TextCoder
       end
     end
@@ -42,6 +56,7 @@ module Noticed
       @_notification ||= begin
         instance = type.constantize.with(params)
         instance.record = self
+        instance.recipient = recipient
         instance
       end
     end
@@ -61,5 +76,10 @@ module Noticed
     def read?
       read_at?
     end
+
+    # If a GlobalID record in params is no longer found, the params will default with a noticed_error key
+    def deserialize_error?
+      !!params[:noticed_error]
+    end
   end
 end

data/lib/noticed/translation.rb

@@ -7,6 +7,10 @@ module Noticed
       :notifications
     end
 
+    def class_scope
+      self.class.name.underscore.tr("/", ".")
+    end
+
     def translate(key, **options)
       I18n.translate(scope_translation_key(key), **options)
     end
@@ -14,7 +18,7 @@ module Noticed
 
     def scope_translation_key(key)
       if key.to_s.start_with?(".")
-        "#{i18n_scope}.#{self.class.name.underscore}#{key}"
+        "#{i18n_scope}.#{class_scope}#{key}"
       else
         key
       end

data/lib/noticed/version.rb

@@ -1,3 +1,3 @@
 module Noticed
-  VERSION = "1.3.2"
+  VERSION = "1.6.3"
 end

data/lib/noticed.rb

@@ -12,26 +12,19 @@ module Noticed
   autoload :NotificationChannel, "noticed/notification_channel"
 
   module DeliveryMethods
-    autoload :Base, "noticed/delivery_methods/base"
     autoload :ActionCable, "noticed/delivery_methods/action_cable"
+    autoload :Base, "noticed/delivery_methods/base"
     autoload :Database, "noticed/delivery_methods/database"
     autoload :Email, "noticed/delivery_methods/email"
-    autoload :Slack, "noticed/delivery_methods/slack"
+    autoload :Fcm, "noticed/delivery_methods/fcm"
+    autoload :Ios, "noticed/delivery_methods/ios"
     autoload :MicrosoftTeams, "noticed/delivery_methods/microsoft_teams"
+    autoload :Slack, "noticed/delivery_methods/slack"
     autoload :Test, "noticed/delivery_methods/test"
     autoload :Twilio, "noticed/delivery_methods/twilio"
     autoload :Vonage, "noticed/delivery_methods/vonage"
   end
 
-  def self.notify(recipients:, notification:)
-    recipients.each do |recipient|
-      notification.notify(recipient)
-    end
-
-    # Clear the recipient after sending to the group
-    notification.recipient = nil
-  end
-
   mattr_accessor :parent_class
   @@parent_class = "ApplicationJob"
 

data/lib/rails_6_polyfills/actioncable/test_adapter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "action_cable/subscription_adapter/base"
+require "action_cable/subscription_adapter/subscriber_map"
+require "action_cable/subscription_adapter/async"
+
+module ActionCable
+  module SubscriptionAdapter
+    # == Test adapter for Action Cable
+    #
+    # The test adapter should be used only in testing. Along with
+    # <tt>ActionCable::TestHelper</tt> it makes a great tool to test your Rails application.
+    #
+    # To use the test adapter set +adapter+ value to +test+ in your +config/cable.yml+ file.
+    #
+    # NOTE: Test adapter extends the <tt>ActionCable::SubscriptionsAdapter::Async</tt> adapter,
+    # so it could be used in system tests too.
+    class Test < Async
+      def broadcast(channel, payload)
+        broadcasts(channel) << payload
+        super
+      end
+
+      def broadcasts(channel)
+        channels_data[channel] ||= []
+      end
+
+      def clear_messages(channel)
+        channels_data[channel] = []
+      end
+
+      def clear
+        @channels_data = nil
+      end
+
+      private
+
+      def channels_data
+        @channels_data ||= {}
+      end
+    end
+  end
+
+  # Update how broadcast_for determines the channel name so it's consistent with the Rails 6 way
+  module Channel
+    module Broadcasting
+      delegate :broadcast_to, to: :class
+      module ClassMethods
+        def broadcast_to(model, message)
+          ActionCable.server.broadcast(broadcasting_for(model), message)
+        end
+
+        def broadcasting_for(model)
+          serialize_broadcasting([channel_name, model])
+        end
+
+        def serialize_broadcasting(object) # :nodoc:
+          case # standard:disable Style/EmptyCaseCondition
+          when object.is_a?(Array)
+            object.map { |m| serialize_broadcasting(m) }.join(":")
+          when object.respond_to?(:to_gid_param)
+            object.to_gid_param
+          else
+            object.to_param
+          end
+        end
+      end
+    end
+  end
+end