noticed 1.3.2 → 1.6.0

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,5 +1,13 @@
 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
@@ -32,7 +40,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 +52,7 @@ module Noticed
       @_notification ||= begin
         instance = type.constantize.with(params)
         instance.record = self
+        instance.recipient = recipient
         instance
       end
     end
@@ -61,5 +72,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.0"
 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

data/lib/rails_6_polyfills/actioncable/test_helper.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module ActionCable
+  # Have ActionCable pick its Test SubscriptionAdapter when it's called for in cable.yml
+  module Server
+    class Configuration
+      def pubsub_adapter
+        cable["adapter"] == "test" ? ActionCable::SubscriptionAdapter::Test : super
+      end
+    end
+  end
+
+  # Provides helper methods for testing Action Cable broadcasting
+  module TestHelper
+    def before_setup # :nodoc:
+      server = ActionCable.server
+      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
+
+      @old_pubsub_adapter = server.pubsub
+
+      server.instance_variable_set(:@pubsub, test_adapter)
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
+    end
+
+    # Asserts that the number of broadcasted messages to the stream matches the given number.
+    #
+    #   def test_broadcasts
+    #     assert_broadcasts 'messages', 0
+    #     ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     assert_broadcasts 'messages', 1
+    #     ActionCable.server.broadcast 'messages', { text: 'world' }
+    #     assert_broadcasts 'messages', 2
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of
+    # messages to be broadcasted.
+    #
+    #   def test_broadcasts_again
+    #     assert_broadcasts('messages', 1) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
+    #     end
+    #
+    #     assert_broadcasts('messages', 2) do
+    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
+    #     end
+    #   end
+    #
+    def assert_broadcasts(stream, number)
+      if block_given?
+        original_count = broadcasts_size(stream)
+        yield
+        new_count = broadcasts_size(stream)
+        actual_count = new_count - original_count
+      else
+        actual_count = broadcasts_size(stream)
+      end
+
+      assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
+    end
+
+    # Asserts that no messages have been sent to the stream.
+    #
+    #   def test_no_broadcasts
+    #     assert_no_broadcasts 'messages'
+    #     ActionCable.server.broadcast 'messages', { text: 'hi' }
+    #     assert_broadcasts 'messages', 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any message to be sent.
+    #
+    #   def test_broadcasts_again
+    #     assert_no_broadcasts 'messages' do
+    #       # No job messages should be sent from this block
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_broadcasts 'messages', 0, &block
+    #
+    def assert_no_broadcasts(stream, &block)
+      assert_broadcasts stream, 0, &block
+    end
+
+    # Asserts that the specified message has been sent to the stream.
+    #
+    #   def test_assert_transmitted_message
+    #     ActionCable.server.broadcast 'messages', text: 'hello'
+    #     assert_broadcast_on('messages', text: 'hello')
+    #   end
+    #
+    # If a block is passed, that block should cause a message with the specified data to be sent.
+    #
+    #   def test_assert_broadcast_on_again
+    #     assert_broadcast_on('messages', text: 'hello') do
+    #       ActionCable.server.broadcast 'messages', text: 'hello'
+    #     end
+    #   end
+    #
+    def assert_broadcast_on(stream, data)
+      # Encode to JSON and back–we want to use this value to compare
+      # with decoded JSON.
+      # Comparing JSON strings doesn't work due to the order of the keys.
+      serialized_msg =
+        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+      new_messages = broadcasts(stream)
+      if block_given?
+        old_messages = new_messages
+        clear_messages(stream)
+
+        yield
+        new_messages = broadcasts(stream)
+        clear_messages(stream)
+
+        # Restore all sent messages
+        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+      end
+
+      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+      assert message, "No messages sent with #{data} to #{stream}"
+    end
+
+    def pubsub_adapter # :nodoc:
+      ActionCable.server.pubsub
+    end
+
+    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
+
+    private
+
+    def broadcasts_size(channel)
+      broadcasts(channel).size
+    end
+  end
+end