How to access notification_methods in Notifier concern?

[ogirginc]

Hi! I have a FirebaseNotifier that needs to access notification_methods on notifier classes. However, this does not work:

class DeleteUserNotifier < ApplicationNotifier
  include FirebaseNotifier

  validates :record, presence: true

  notification_methods do
    def url(*)
      user_path(record)
    end

    def title
      t('.title')
    end

    def body
      t('.body', name: record.name)
    end
end

module FirebaseNotifier
  extend ActiveSupport::Concern

  included do
    deliver_by :fcm do |config|
      # ...
      config.json = lambda { |device_token, notification|
        {
          message: {
            token: device_token,
            notification: { title: notification.title, body: notification.body }
          }
        }
      }
    end
  end
end

Previously, we were using Firebase as a custom method, and were able to access the notification in a scenario like DeliveryMethods::Firebase < Noticed::DeliveryMethod, but now I want to use the built-in fcm.

So the question is; what do I need to do to be able to access notification_methods on the concern?

Thanks in advance. :)

[excid3]

What does not work?

[ogirginc]

In FirebaseNotifier, I cannot use notification_methods defined in DeleteUserNotifier:

NameError
undefined local variable or method `notification' for an instance of DeleteUserNotifier::Notification (NameError)

[ogirginc]

Hmm, it really feels like I am missing something obvious here 😅

It did not work even without the concern:

# frozen_string_literal: true

class UserInviteJoinedNotifier < ApplicationNotifier
  deliver_by :expo do |config|
    config.class = 'DeliveryMethods::Expo'
    config.queue = 'notifications'
  end

  deliver_by :fcm do |config|
    config.credentials = JSON.parse(Rails.application.credentials.firebase, symbolize_names: true)
    config.device_tokens = -> { recipient.devices.where(token_type: :firebase).pluck(:token) }
    config.json = lambda { |device_token|
      {
        message: {
          token: device_token,
          notification: {
            title: notification.title,
            body: notification.body,
            url: notification.url(web: true)
          }
        }
      }
    }
    config.queue = 'notifications'
    config.invalid_token = ->(device_token) { device_token.destroy }
  end

  notification_methods do
    def url(*)
      user_path(user)
    end

    def title
      t('.title')
    end

    def body
      t('.body', name: user.name || user.email)
    end

    def channel_id
      'user'
    end

    delegate :name, to: :user

    def user
      @user ||= params[:record]
    end
  end
end

And when I have tried

    config.json = lambda { |device_token, notification|

I end up getting NameError

undefined local variable or method `notification' for an instance of RestoreTaskNotifier::Notification (NameError)
Did you mean?  notification_url

[ogirginc]

fyi, ApplicationNotifier inherits from Noticed::Event.

# frozen_string_literal: true

class ApplicationNotifier < Noticed::Event
  # Used for sending notifications to a recipients iOS devices
  def ios_device_tokens(user)
    user.notification_tokens.ios.pluck(:token)
  end

  # Used for sending notifications to a recipients Android devices
  def android_device_tokens(user)
    user.notification_tokens.android.pluck(:token)
  end

  # Remove notification token when a user removes the app from their device
  def cleanup_device_token(token:, platform:)
    NotificationToken.where(token:, platform: (platform == 'fcm' ? 'Android' : platform)).destroy_all
  end
end

[ogirginc]

Yep, it was me missing something very obvious here 😅

This won't work as the passing symbol breaks:

class TestNotifier < Noticed::Event
  deliver_by :fcm do |config|
    config.credentials = JSON.parse(Rails.application.credentials.firebase, symbolize_names: true)
    config.device_tokens = -> { recipient.devices.where(token_type: :firebase).pluck(:token) }
    config.queue = 'notifications'
    config.invalid_token = ->(device_token) { recipient.devices.find_by(token: device_token).destroy }
    config.json = :json_message
  end

  def json_message(device_token)
    {
      message: {
        token: device_token,
        notification: {
          title:,
          body:
        },
        webpush: {
          fcm_options: {
            link: url(web: true)
          }
        }
      }
    }
  end

  notification_methods do
    def url(*)
      'https://example.com/'
    end

    def title
      'Test Title'
    end

    def body
      'Test Body'
    end

    def name
      'Test Name'
    end

    def channel_id
      'Test Channel'
    end
  end
end

Though it will work when it's used as the docs:

class TestNotifier < Noticed::Event
  deliver_by :fcm do |config|
    config.credentials = JSON.parse(Rails.application.credentials.firebase, symbolize_names: true)
    config.device_tokens = -> { recipient.devices.where(token_type: :firebase).pluck(:token) }
    config.queue = 'notifications'
    config.invalid_token = ->(device_token) { recipient.devices.find_by(token: device_token)&.destroy }
    config.json = lambda { |device_token|
      {
        message: {
          token: device_token,
          notification: {
            title:,
            body:
          },
          webpush: {
            fcm_options: {
              link: url(web: true)
            }
          }
        }
      }
    }
  end

  notification_methods do
    def url(*)
      'https://example.com/'
    end

    def title
      'Test Title'
    end

    def body
      'Test Body'
    end

    def name
      'Test Name'
    end

    def channel_id
      'Test Channel'
    end
  end
end

TBH, I have no idea why I have used the symbol in the first place 😅