activity_notification 2.0.0 → 2.1.4

data/docs/Testing.md

@@ -0,0 +1,148 @@
+## Testing
+
+### Testing your application
+
+First, you need to configure ActivityNotification as described above.
+
+#### Testing notifications with RSpec
+Prepare target and notifiable model instances to test generating notifications (e.g. `@user` and `@comment`).
+Then, you can call notify API and test if notifications of the target are generated.
+```ruby
+# Prepare
+@article_author = create(:user)
+@comment = @article_author.articles.create.comments.create
+expect(@article_author.notifications.unopened_only.count).to eq(0)
+
+# Call notify API
+@comment.notify :users
+
+# Test generated notifications
+expect(@article_author_user.notifications.unopened_only.count).to eq(1)
+expect(@article_author_user.notifications.unopened_only.latest.notifiable).to eq(@comment)
+```
+
+#### Testing email notifications with RSpec
+Prepare target and notifiable model instances to test sending notification email.
+Then, you can call notify API and test if notification email is sent.
+```ruby
+# Prepare
+@article_author = create(:user)
+@comment = @article_author.articles.create.comments.create
+expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+
+# Call notify API and send email now
+@comment.notify :users, send_later: false
+
+# Test sent notification email
+expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+expect(ActivityNotification::Mailer.deliveries.first.to[0]).to eq(@article_author.email)
+```
+Note that notification email will be sent asynchronously without false as *:send_later* option.
+```ruby
+# Prepare
+include ActiveJob::TestHelper
+@article_author = create(:user)
+@comment = @article_author.articles.create.comments.create
+expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+
+# Call notify API and send email asynchronously as default
+# Test sent notification email with ActiveJob queue
+expect {
+  perform_enqueued_jobs do
+    @comment.notify :users
+  end
+}.to change { ActivityNotification::Mailer.deliveries.size }.by(1)
+expect(ActivityNotification::Mailer.deliveries.first.to[0]).to eq(@article_author.email)
+```
+
+### Testing gem alone
+
+#### Testing with RSpec
+Pull git repository and execute RSpec.
+```console
+$ git pull https://github.com/simukappu/activity_notification.git
+$ cd activity_notification
+$ bundle install —path vendor/bundle
+$ bundle exec rspec
+  - or -
+$ bundle exec rake
+```
+
+##### Testing with DynamoDB Local
+You can use [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) to test Amazon DynamoDB integration in your local environment.
+
+At first, set up DynamoDB Local by install script:
+```console
+$ bin/install_dynamodblocal.sh
+```
+Then, start DynamoDB Local by start script:
+```console
+$ bin/start_dynamodblocal.sh
+```
+And you can stop DynamoDB Local by stop script:
+```console
+$ bin/stop_dynamodblocal.sh
+```
+
+In short, you can test DynamoDB integration by the following step:
+```console
+$ git pull https://github.com/simukappu/activity_notification.git
+$ cd activity_notification
+$ bundle install —path vendor/bundle
+$ bin/install_dynamodblocal.sh
+$ bin/start_dynamodblocal.sh
+$ AN_ORM=dynamoid bundle exec rspec
+```
+
+#### Example Rails application
+Test module includes example Rails application in *[spec/rails_app](/spec/rails_app)*. You can run the example application as common Rails application.
+```console
+$ cd spec/rails_app
+$ bin/rake db:migrate
+$ bin/rake db:seed
+$ bin/rails server
+```
+Then, you can access <http://localhost:3000> for the example application.
+
+##### Run with your local database
+As default, example Rails application runs with local SQLite database in *spec/rails_app/db/development.sqlite3*.
+This application supports to run with your local MySQL, PostgreSQL, MongoDB.
+Set **AN_TEST_DB** environment variable as follows.
+
+To use MySQL:
+```console
+$ export AN_TEST_DB=mysql
+```
+To use PostgreSQL:
+```console
+$ export AN_TEST_DB=postgresql
+```
+To use MongoDB:
+```console
+$ export AN_TEST_DB=mongodb
+```
+When you set **mongodb** as *AN_TEST_DB*, you have to use *activity_notification* with MongoDB. Also set **AN_ORM** like:
+```console
+$ export AN_ORM=mongoid
+```
+
+You can also run this Rails application in cross database environment like these:
+
+To use MySQL for your application and use MongoDB for *activity_notification*:
+```console
+$ export AN_ORM=mongoid AN_TEST_DB=mysql
+```
+To use PostgreSQL for your application and use Amazon DynamoDB for *activity_notification*:
+```console
+$ export AN_ORM=dynamoid AN_TEST_DB=postgresql
+```
+
+Then, configure *spec/rails_app/config/database.yml* or *spec/rails_app/config/mongoid.yml*, *spec/rails_app/config/dynamoid.rb* as your local database.
+Finally, run database migration, seed data script and the example appliation.
+```console
+$ cd spec/rails_app
+$ # You don't need migration when you use MongoDB only (AN_ORM=mongoid and AN_TEST_DB=mongodb)
+$ bin/rake db:migrate
+$ bin/rake db:seed
+$ bin/rails server Puma
+```

data/gemfiles/Gemfile.rails-4.2

@@ -9,12 +9,16 @@ gem 'pg', '~> 0.21.0'
 
 group :development do
   gem 'bullet'
+  gem 'rack-cors'
 end
 
 group :test do
   gem 'ammeter'
   gem 'timecop'
-  gem 'coveralls', require: false
+  gem 'committee'
+  gem 'committee-rails'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
 end
 
 gem 'dotenv-rails', groups: [:development, :test]

data/gemfiles/Gemfile.rails-5.0

@@ -7,14 +7,19 @@ gem 'sqlite3', '~> 1.3.13'
 
 group :development do
   gem 'bullet'
+  gem 'rack-cors'
 end
 
 group :test do
+  gem 'rspec-rails', '< 4.0.0'
   gem 'rails-controller-testing'
   gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
-  gem 'coveralls', require: false
+  gem 'committee'
+  gem 'committee-rails'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
 end
 
 gem 'dotenv-rails', groups: [:development, :test]

data/gemfiles/Gemfile.rails-5.1

@@ -6,14 +6,19 @@ gem 'rails', '~> 5.1.0'
 
 group :development do
   gem 'bullet'
+  gem 'rack-cors'
 end
 
 group :test do
+  gem 'rspec-rails', '< 4.0.0'
   gem 'rails-controller-testing'
   gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
-  gem 'coveralls', require: false
+  gem 'committee'
+  gem 'committee-rails'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
 end
 
 gem 'dotenv-rails', groups: [:development, :test]

data/gemfiles/Gemfile.rails-5.2

@@ -6,14 +6,19 @@ gem 'rails', '~> 5.2.0'
 
 group :development do
   gem 'bullet'
+  gem 'rack-cors'
 end
 
 group :test do
+  gem 'rspec-rails', '< 4.0.0'
   gem 'rails-controller-testing'
   gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
-  gem 'coveralls', require: false
+  gem 'committee'
+  gem 'committee-rails'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
 end
 
 gem 'dotenv-rails', groups: [:development, :test]

data/gemfiles/{Gemfile.rails-6.0.rc → Gemfile.rails-6.0}

@@ -2,20 +2,21 @@ source 'https://rubygems.org'
 
 gemspec path: '../'
 
-gem 'rails', '~> 6.0.0.rc2'
+gem 'rails', '~> 6.0.0'
 
 group :development do
   gem 'bullet'
+  gem 'rack-cors'
 end
 
 group :test do
-  #TODO https://github.com/rails/rails/issues/35417
-  gem 'rspec-rails', git: 'https://github.com/rspec/rspec-rails', branch: '4-0-dev'
-
   gem 'rails-controller-testing'
   gem 'ammeter'
   gem 'timecop'
-  gem 'coveralls', require: false
+  gem 'committee'
+  gem 'committee-rails'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
 end
 
 gem 'dotenv-rails', groups: [:development, :test]

data/lib/activity_notification.rb

@@ -17,6 +17,7 @@ module ActivityNotification
   autoload :Config
   autoload :Renderable
   autoload :VERSION
+  autoload :GEM_VERSION
 
   module Mailers
     autoload :Helpers,        'activity_notification/mailers/helpers'
@@ -60,10 +61,22 @@ require 'activity_notification/helpers/errors'
 require 'activity_notification/helpers/polymorphic_helpers'
 require 'activity_notification/helpers/view_helpers'
 require 'activity_notification/controllers/common_controller'
+require 'activity_notification/controllers/common_api_controller'
 require 'activity_notification/controllers/store_controller'
 require 'activity_notification/controllers/devise_authentication_controller'
 require 'activity_notification/optional_targets/base'
 
+# Load Swagger API references
+require 'activity_notification/apis/swagger'
+require 'activity_notification/models/concerns/swagger/notification_schema'
+require 'activity_notification/models/concerns/swagger/subscription_schema'
+require 'activity_notification/models/concerns/swagger/error_schema'
+require 'activity_notification/controllers/concerns/swagger/notifications_parameters'
+require 'activity_notification/controllers/concerns/swagger/subscriptions_parameters'
+require 'activity_notification/controllers/concerns/swagger/error_responses'
+require 'activity_notification/controllers/concerns/swagger/notifications_api'
+require 'activity_notification/controllers/concerns/swagger/subscriptions_api'
+
 # Load role for models
 require 'activity_notification/models'
 

data/lib/activity_notification/apis/notification_api.rb

@@ -10,10 +10,7 @@ module ActivityNotification
       # Defines mailer class to send notification
       set_notification_mailer
 
-      # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-      # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-      # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-      # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+      # :nocov:
       unless ActivityNotification.config.orm == :dynamoid
         # Selects all notification index.
         #   ActivityNotification::Notification.all_index!
@@ -108,6 +105,8 @@ module ActivityNotification
         # @option options [String]     :filtered_by_group_type (nil) Group type for filter, valid with :filtered_by_group_id
         # @option options [String]     :filtered_by_group_id   (nil) Group instance id for filter, valid with :filtered_by_group_type
         # @option options [String]     :filtered_by_key        (nil) Key of the notification for filter
+        # @option options [String]     :later_than             (nil) ISO 8601 format time to filter notification index later than specified time
+        # @option options [String]     :earlier_than           (nil) ISO 8601 format time to filter notification index earlier than specified time
         # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ["created_at >= ?", time.hour.ago] with ActiveRecord or {:created_at.gt => time.hour.ago} with Mongoid)
         # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
         scope :filtered_by_options,               ->(options = {}) {
@@ -126,6 +125,12 @@ module ActivityNotification
           if options.has_key?(:filtered_by_key)
             filtered_notifications = filtered_notifications.filtered_by_key(options[:filtered_by_key])
           end
+          if options.has_key?(:later_than)
+            filtered_notifications = filtered_notifications.later_than(Time.iso8601(options[:later_than]))
+          end
+          if options.has_key?(:earlier_than)
+            filtered_notifications = filtered_notifications.earlier_than(Time.iso8601(options[:earlier_than]))
+          end
           if options.has_key?(:custom_filter)
             filtered_notifications = filtered_notifications.where(options[:custom_filter])
           end
@@ -187,10 +192,7 @@ module ActivityNotification
           pluck(:key).uniq
         end
       end
-      # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-      # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-      # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-      # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
+      # :nocov:
     end
 
     class_methods do
@@ -217,8 +219,6 @@ module ActivityNotification
       # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Boolean]                 :pass_full_options        (false)                               Whether it passes full options to notifiable.notification_targets, not a key only
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
@@ -257,8 +257,6 @@ module ActivityNotification
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Boolean]                 :pass_full_options        (false)                               Whether it passes full options to notifiable.notification_targets, not a key only
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
@@ -285,8 +283,6 @@ module ActivityNotification
       # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Array<Notificaion>] Array of generated notifications
@@ -314,8 +310,6 @@ module ActivityNotification
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Array<Notificaion>] Array of generated notifications
@@ -340,8 +334,6 @@ module ActivityNotification
       # @option options [Boolean]                 :notify_later             (false)                               Whether it generates notifications asynchronously
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcasts notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Notification] Generated notification instance
@@ -351,7 +343,6 @@ module ActivityNotification
         else
           send_email               = options.has_key?(:send_email)               ? options[:send_email]               : true
           send_later               = options.has_key?(:send_later)               ? options[:send_later]               : true
-          broadcast_action_cable   = options.has_key?(:broadcast_action_cable)   ? options[:broadcast_action_cable]   : true
           publish_optional_targets = options.has_key?(:publish_optional_targets) ? options[:publish_optional_targets] : true
           # Generate notification
           notification = generate_notification(target, notifiable, options)
@@ -359,12 +350,6 @@ module ActivityNotification
           if notification.present? && send_email
             notification.send_notification_email({ send_later: send_later })
           end
-          # Broadcast to ActionCable subscribers
-          if notification.present? && broadcast_action_cable
-            action_cable_rendering_options = options[:action_cable_rendering] || {}
-            action_cable_rendering_options[:fallback] = action_cable_rendering_options[:fallback] || :default
-            notification.broadcast_to_action_cable_channel(action_cable_rendering_options)
-          end
           # Publish to optional targets
           if notification.present? && publish_optional_targets
             notification.publish_to_optional_targets(options[:optional_targets] || {})
@@ -390,8 +375,6 @@ module ActivityNotification
       # @option options [Hash]                    :parameters               ({})                                  Additional parameters of the notifications
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
-      # @option options [Boolean]                 :broadcast_action_cable   (true)                                Whether it broadcast∂s notification to ActionCable channel
-      # @option options [Hash]                    :action_cable_rendering   ({fallback: :default})                Options for rendering params used by ActionCable, e.g. {fallback: :text} or {fallback: :default} etc. See also Renderable#render.
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
       # @return [Notification] Generated notification instance
@@ -426,14 +409,15 @@ module ActivityNotification
       # @option options [String]   :filtered_by_group_type (nil)          Group type for filter, valid with :filtered_by_group_id
       # @option options [String]   :filtered_by_group_id   (nil)          Group instance id for filter, valid with :filtered_by_group_type
       # @option options [String]   :filtered_by_key        (nil)          Key of the notification for filter
-      # @return [Integer] Number of opened notification records
-      # @todo Add filter option
+      # @option options [String]   :later_than             (nil)          ISO 8601 format time to filter notification index later than specified time
+      # @option options [String]   :earlier_than           (nil)          ISO 8601 format time to filter notification index earlier than specified time
+      # @return [Array<Notification>] Opened notification records
       def open_all_of(target, options = {})
         opened_at = options[:opened_at] || Time.current
         target_unopened_notifications = target.notifications.unopened_only.filtered_by_options(options)
-        unopened_notification_count = target_unopened_notifications.count
+        opened_notifications = target_unopened_notifications.to_a.map { |n| n.opened_at = opened_at; n }
         target_unopened_notifications.update_all(opened_at: opened_at)
-        unopened_notification_count
+        opened_notifications
       end
 
       # Returns if group member of the notifications exists.
@@ -470,7 +454,7 @@ module ActivityNotification
       #
       # @return [Array<Notificaion>] Available options for kinds of notify methods
       def available_options
-        [:key, :group, :group_expiry_delay, :notifier, :parameters, :send_email, :send_later].freeze
+        [:key, :group, :group_expiry_delay, :notifier, :parameters, :send_email, :send_later, :pass_full_options].freeze
       end
 
       # Defines mailer class to send notification
@@ -511,16 +495,23 @@ module ActivityNotification
 
         notification = new({ target: target, notifiable: notifiable, key: key, group: group, parameters: parameters, notifier: notifier, group_owner: group_owner })
         notification.prepare_to_store.save
+        notification.after_store
         notification
       end
     end
 
+    # :nocov:
     # Returns prepared notification object to store
     # @return [Object] prepared notification object to store
     def prepare_to_store
       self
     end
 
+    # Call after store action with stored notification
+    def after_store
+    end
+    # :nocov:
+
     # Sends notification email to the target.
     #
     # @param [Hash] options Options for notification email
@@ -538,64 +529,6 @@ module ActivityNotification
       end
     end
 
-    # :only-rails5-plus#only-rails-with-callback-issue:
-    # :only-rails5-plus#only-rails-without-callback-issue:
-    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-    if Rails::VERSION::MAJOR >= 5
-      # Broadcast to ActionCable subscribers
-      # @param [Hash] params Parameters for rendering notifications
-      # @option params [String, Symbol] :target                 (nil)                     Target type name to find template or i18n text
-      # @option params [String]         :partial_root           ("activity_notification/notifications/#{target}", controller.target_view_path, 'activity_notification/notifications/default') Partial template name
-      # @option params [String]         :partial                (self.key.tr('.', '/'))   Root path of partial template
-      # @option params [String]         :layout                 (nil)                     Layout template name
-      # @option params [String]         :layout_root            ('layouts')               Root path of layout template
-      # @option params [String, Symbol] :fallback               (nil)                     Fallback template to use when MissingTemplate is raised. Set :text to use i18n text as fallback.
-      # @option params [String]         :filter                 (nil)                     Filter option to load notification index (Nothing as auto, 'opened' or 'unopened')
-      # @option params [String]         :limit                  (nil)                     Limit to query for notifications
-      # @option params [String]         :without_grouping       ('false')                 If notification index will include group members
-      # @option params [String]         :with_group_members     ('false')                 If notification index will include group members
-      # @option params [String]         :filtered_by_type       (nil)                     Notifiable type for filter
-      # @option params [String]         :filtered_by_group_type (nil)                     Group type for filter, valid with :filtered_by_group_id
-      # @option params [String]         :filtered_by_group_id   (nil)                     Group instance id for filter, valid with :filtered_by_group_type
-      # @option params [String]         :filtered_by_key        (nil)                     Key of the notification for filter
-      # @option params [Hash]           others                                            Parameters to be set as locals
-      def broadcast_to_action_cable_channel(params = {})
-        if target.notification_action_cable_allowed?(notifiable, key) &&
-          notifiable.notification_action_cable_allowed?(target, key)
-          target_channel_name = "#{ActivityNotification.config.notification_channel_prefix}_#{target_type}#{ActivityNotification.config.composite_key_delimiter}#{target_id}"
-          index_options = params.slice(:filter, :limit, :without_grouping, :with_group_members, :filtered_by_type, :filtered_by_group_type, :filtered_by_group_id, :filtered_by_key)
-          ActionCable.server.broadcast(target_channel_name,
-            id:                          id,
-            view:                        render(ActivityNotification::NotificationsController.renderer, params),
-            text:                        text(params),
-            notifiable_path:             notifiable_path,
-            group_owner_id:              group_owner_id,
-            group_owner_view:            group_owner? ? nil : group_owner.render(ActivityNotification::NotificationsController.renderer, params),
-            unopened_notification_count: target.unopened_notification_count(index_options)
-          )
-        end
-      end
-    # :only-rails5-plus#only-rails-with-callback-issue:
-    # :only-rails5-plus#only-rails-without-callback-issue:
-    # :only-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-    # :only-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-    # :except-rails5-plus#only-rails-with-callback-issue:
-    # :except-rails5-plus#only-rails-without-callback-issue:
-    # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-    # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-    else
-      # Broadcast to ActionCable subscribers
-      # Do nothing with Rails < 5.0
-      # @param [Hash] params Parameters for rendering notifications
-      def broadcast_to_action_cable_channel(params = {})
-      end
-    end
-    # :except-rails5-plus#only-rails-with-callback-issue:
-    # :except-rails5-plus#only-rails-without-callback-issue:
-    # :except-rails5-plus#only-rails-with-callback-issue#except-dynamoid:
-    # :except-rails5-plus#only-rails-without-callback-issue#except-dynamoid:
-
     # Publishes notification to the optional targets.
     #
     # @param [Hash] options Options for optional targets
@@ -604,8 +537,13 @@ module ActivityNotification
       notifiable.optional_targets(target.to_resources_name, key).map { |optional_target|
         optional_target_name = optional_target.to_optional_target_name
         if optional_target_subscribed?(optional_target_name)
-          optional_target.notify(self, options[optional_target_name] || {})
-          [optional_target_name, true]
+          begin
+            optional_target.notify(self, options[optional_target_name] || {})
+            [optional_target_name, true]
+          rescue => e
+            Rails.logger.error(e)
+            [optional_target_name, e]
+          end
         else
           [optional_target_name, false]
         end
@@ -741,10 +679,16 @@ module ActivityNotification
     #
     # @return [String] Notifiable path URL to move after opening notification
     def notifiable_path
-      notifiable.present? or raise ActiveRecord::RecordNotFound.new("Couldn't find notifiable #{notifiable_type}")
+      notifiable.blank? and raise ActivityNotification::NotifiableNotFoundError.new("Couldn't find associated notifiable (#{notifiable_type}) of #{self.class.name} with 'id'=#{id}")
       notifiable.notifiable_path(target_type, key)
     end
 
+    # Returns printable notifiable model name to show in view or email.
+    # @return [String] Printable notifiable model name
+    def printable_notifiable_name
+      notifiable.printable_notifiable_name(target, key)
+    end
+
     # Returns if the target subscribes this notification.
     # @return [Boolean] If the target subscribes the notification
     def subscribed?