activity_notification 2.3.2 → 2.4.0

data/docs/Setup.md

@@ -80,12 +80,6 @@ You need to configure Mongoid in your Rails application for your MongoDB environ
 
 #### Using Dynamoid ORM
 
-Currently, *activity_notification* only works with Dynamoid 3.1.0.
-
-```ruby
-gem 'dynamoid', '3.1.0'
-```
-
 When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, set **AN_ORM** environment variable to **dynamoid**:
 
 ```console
@@ -762,6 +756,49 @@ notification:
 
 This structure is valid for notifications with keys *"notification.comment.reply"* or *"comment.reply"*. As mentioned before, *"notification."* part of the key is optional. In addition for above example, `%{notifier_name}` and `%{article_title}` are used from parameter field in the notification record. Pluralization is supported (but optional) for grouped notifications using the `%{group_notification_count}` value.
 
+### Managing notifications
+
+*activity_notification* provides several methods to manage notifications programmatically. The most common operation is opening notifications to mark them as read.
+
+#### Opening notifications
+
+You can mark individual notifications as opened (read) using the **open!** method:
+
+```ruby
+# Open a single notification
+notification = current_user.notifications.first
+notification.open!
+
+# Open notification with specific timestamp
+notification.open!(opened_at: 1.hour.ago)
+
+# Open notification with opening group members
+notification.open!(with_members: true)
+
+# Open notification skipping validations when the associated notifiable record may have been deleted
+notification.open!(skip_validation: true)
+```
+
+The **open!** method accepts the following options:
+
+* **:opened_at** (Time) - Time to set as the opened timestamp (defaults to `Time.current`)
+* **:with_members** (Boolean) - Whether to open group member notifications as well (defaults to `false`)
+* **:skip_validation** (Boolean) - Whether to skip ActiveRecord validations when updating (defaults to `false`). Useful when the associated notifiable record may have been deleted but the notification still exists.
+
+You can also open all notifications for a target:
+
+```ruby
+# Open all unopened notifications for a user
+ActivityNotification::Notification.open_all_of(current_user)
+
+# Open notifications with filters
+ActivityNotification::Notification.open_all_of(
+  current_user,
+  filtered_by_type: 'Comment',
+  opened_at: 1.hour.ago
+)
+```
+
 ### Customizing controllers (optional)
 
 If the customization at the views level is not enough, you can customize each controller by following these steps:

data/gemfiles/Gemfile.rails-7.0

@@ -4,6 +4,8 @@ gemspec path: '../'
 
 gem 'rails', '~> 7.0.0'
 gem 'sprockets-rails'
+gem 'concurrent-ruby', '<= 1.3.4'
+gem 'sqlite3', '~> 1.4'
 
 group :development do
   gem 'bullet'

data/gemfiles/Gemfile.rails-7.2

@@ -4,8 +4,6 @@ gemspec path: '../'
 
 gem 'rails', '~> 7.2.0'
 gem 'sprockets-rails'
-# https://github.com/lynndylanhurley/devise_token_auth/pull/1632
-gem 'devise_token_auth', git: 'https://github.com/lynndylanhurley/devise_token_auth.git'
 
 group :development do
   gem 'bullet'

data/gemfiles/Gemfile.rails-8.0

@@ -0,0 +1,24 @@
+source 'https://rubygems.org'
+
+gemspec path: '../'
+
+gem 'rails', '~> 8.0.0'
+gem 'sprockets-rails'
+
+group :development do
+  gem 'bullet'
+  gem 'rack-cors'
+  gem 'sqlite3'
+end
+
+group :test do
+  gem 'rails-controller-testing'
+  gem 'ammeter'
+  gem 'timecop'
+  gem 'committee'
+  gem 'committee-rails', '< 0.6'
+  # gem 'coveralls', require: false
+  gem 'coveralls_reborn', require: false
+end
+
+gem 'dotenv-rails', groups: [:development, :test]

data/lib/activity_notification/apis/notification_api.rb

@@ -411,15 +411,63 @@ module ActivityNotification
       # @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]    :ids                    (nil)          Array of specific notification IDs to open
       # @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)
+        # If specific IDs are provided, filter by them
+        if options[:ids].present?
+          # :nocov:
+          case ActivityNotification.config.orm
+          when :mongoid
+            target_unopened_notifications = target_unopened_notifications.where(id: { '$in' => options[:ids] })
+          when :dynamoid
+            target_unopened_notifications = target_unopened_notifications.where('id.in': options[:ids])
+          else # :active_record
+            target_unopened_notifications = target_unopened_notifications.where(id: options[:ids])
+          end
+          # :nocov:
+        end
         opened_notifications = target_unopened_notifications.to_a.map { |n| n.opened_at = opened_at; n }
         target_unopened_notifications.update_all(opened_at: opened_at)
         opened_notifications
       end
 
+      # Destroys all notifications of the target matching the filter criteria.
+      #
+      # @param [Object] target Target of the notifications to destroy
+      # @param [Hash] options Options for filtering notifications to destroy
+      # @option options [String]   :filtered_by_type       (nil) Notifiable type for filter
+      # @option options [Object]   :filtered_by_group      (nil) Group instance for filter  
+      # @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 notifications later than specified time
+      # @option options [String]   :earlier_than           (nil) ISO 8601 format time to filter notifications earlier than specified time
+      # @option options [Array]    :ids                    (nil) Array of specific notification IDs to destroy
+      # @return [Array<Notification>] Destroyed notification records
+      def destroy_all_of(target, options = {})
+        target_notifications = target.notifications.filtered_by_options(options)
+        # If specific IDs are provided, filter by them
+        if options[:ids].present?
+          # :nocov:
+          case ActivityNotification.config.orm
+          when :mongoid
+            target_notifications = target_notifications.where(id: { '$in' => options[:ids] })
+          when :dynamoid
+            target_notifications = target_notifications.where('id.in': options[:ids])
+          else # :active_record
+            target_notifications = target_notifications.where(id: options[:ids])
+          end
+          # :nocov:
+        end
+        # Get the notifications before destroying them for return value
+        destroyed_notifications = target_notifications.to_a
+        target_notifications.destroy_all
+        destroyed_notifications
+      end
+
       # Returns if group member of the notifications exists.
       # This method is designed to be called from controllers or views to avoid N+1.
       #
@@ -517,7 +565,7 @@ module ActivityNotification
     # @param [Hash] options Options for notification email
     # @option options [Boolean]        :send_later            If it sends notification email asynchronously
     # @option options [String, Symbol] :fallback   (:default) Fallback template to use when MissingTemplate is raised
-    # @return [Mail::Message, ActionMailer::DeliveryJob] Email message or its delivery job
+    # @return [Mail::Message, ActionMailer::DeliveryJob, NilClass] Email message, its delivery job, or nil if notification not found
     def send_notification_email(options = {})
       if target.notification_email_allowed?(notifiable, key) &&
          notifiable.notification_email_allowed?(target, key) &&
@@ -559,6 +607,7 @@ module ActivityNotification
     # @param [Hash] options Options for opening notifications
     # @option options [DateTime] :opened_at   (Time.current) Time to set to opened_at of the notification record
     # @option options [Boolean] :with_members (true)         If it opens notifications including group members
+    # @option options [Boolean] :skip_validation (true)      If it skips validation of the notification record
     # @return [Integer] Number of opened notification records
     def open!(options = {})
       opened? and return 0
@@ -566,7 +615,7 @@ module ActivityNotification
       with_members = options.has_key?(:with_members) ? options[:with_members] : true
       unopened_member_count = with_members ? group_members.unopened_only.count : 0
       group_members.update_all(opened_at: opened_at) if with_members
-      update(opened_at: opened_at)
+      options[:skip_validation] ? update_attribute(:opened_at, opened_at) : update(opened_at: opened_at)
       unopened_member_count + 1
     end
 

data/lib/activity_notification/controllers/concerns/swagger/notifications_api.rb

@@ -92,6 +92,18 @@ module ActivityNotification
           extend Swagger::NotificationsParameters::TargetParameters
           extend Swagger::NotificationsParameters::FilterByParameters
 
+          parameter do
+            key :name, :ids
+            key :in, :query
+            key :description, "Array of specific notification IDs to open"
+            key :required, false
+            key :type, :array
+            items do
+              key :type, :string
+            end
+            key :example, ["1", "2", "3"]
+          end
+
           response 200 do
             key :description, "Opened notifications"
             content 'application/json' do
@@ -117,6 +129,53 @@ module ActivityNotification
         end
       end
 
+      swagger_path '/{target_type}/{target_id}/notifications/destroy_all' do
+        operation :post do
+          key :summary, 'Destroy all notifications'
+          key :description, 'Destroys all notifications of the target matching filter criteria.'
+          key :operationId, 'destroyAllNotifications'
+          key :tags, ['notifications']
+
+          extend Swagger::NotificationsParameters::TargetParameters
+          extend Swagger::NotificationsParameters::FilterByParameters
+
+          parameter do
+            key :name, :ids
+            key :in, :query
+            key :description, "Array of specific notification IDs to destroy"
+            key :required, false
+            key :type, :array
+            items do
+              key :type, :string
+            end
+            key :example, ["1", "2", "3"]
+          end
+
+          response 200 do
+            key :description, "Destroyed notifications"
+            content 'application/json' do
+              schema do
+                key :type, :object
+                property :count do
+                  key :type, :integer
+                  key :description, "Number of destroyed notification records"
+                  key :example, 3
+                end
+                property :notifications do
+                  key :type, :array
+                  items do
+                    key :'$ref', :Notification
+                  end
+                  key :description, "Destroyed notifications"
+                end
+              end
+            end
+          end
+          extend Swagger::ErrorResponses::InvalidParameterError
+          extend Swagger::ErrorResponses::ResourceNotFoundError
+        end
+      end
+
       swagger_path '/{target_type}/{target_id}/notifications/{id}' do
         operation :get do
           key :summary, 'Get notification'

data/lib/activity_notification/helpers/view_helpers.rb

@@ -145,6 +145,20 @@ module ActivityNotification
         send("open_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_path", target, options)
     end
 
+    # Returns destroy_all_notifications_path for the target
+    #
+    # @param [Object] target Target instance
+    # @param [Hash] params Request parameters
+    # @return [String] destroy_all_notifications_path for the target
+    # @todo Needs any other better implementation
+    # @todo Must handle devise namespace
+    def destroy_all_notifications_path_for(target, params = {})
+      options = params.dup
+      options.delete(:devise_default_routes) ?
+        send("destroy_all_#{routing_scope(options)}notifications_path", options) :
+        send("destroy_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_path", target, options)
+    end
+
     # Returns notifications_url for the target
     #
     # @param [Object] target Target instance
@@ -215,6 +229,20 @@ module ActivityNotification
         send("open_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_url", target, options)
     end
 
+    # Returns destroy_all_notifications_url for the target
+    #
+    # @param [Object] target Target instance
+    # @param [Hash] params Request parameters
+    # @return [String] destroy_all_notifications_url for the target
+    # @todo Needs any other better implementation
+    # @todo Must handle devise namespace
+    def destroy_all_notifications_url_for(target, params = {})
+      options = params.dup
+      options.delete(:devise_default_routes) ?
+        send("destroy_all_#{routing_scope(options)}notifications_url", options) :
+        send("destroy_all_#{routing_scope(options)}#{target.to_resource_name}_notifications_url", target, options)
+    end
+
     # Returns subscriptions_path for the target
     #
     # @param [Object] target Target instance

data/lib/activity_notification/mailers/helpers.rb

@@ -5,6 +5,7 @@ module ActivityNotification
     # Use to resolve parameters from email configuration and send notification email.
     module Helpers
       extend ActiveSupport::Concern
+      include ActivityNotification::NotificationResilience
 
       protected
 
@@ -13,10 +14,13 @@ module ActivityNotification
         # @param [Notification] notification Notification instance to send email
         # @param [Hash]         options      Options for notification email
         # @option options [String, Symbol] :fallback (:default) Fallback template to use when MissingTemplate is raised
+        # @return [Mail::Message, nil] Email message or nil if notification was not found
         def notification_mail(notification, options = {})
-          initialize_from_notification(notification)
-          headers = headers_for(notification.key, options)
-          send_mail(headers, options[:fallback])
+          with_notification_resilience(notification&.id, { target: 'unknown' }) do
+            initialize_from_notification(notification)
+            headers = headers_for(notification.key, options)
+            send_mail(headers, options[:fallback])
+          end
         end
 
         # Send batch notification email with configured options.
@@ -26,11 +30,14 @@ module ActivityNotification
         # @param [String]              batch_key     Key of the batch notification email
         # @param [Hash]                options       Options for notification email
         # @option options [String, Symbol] :fallback (:batch_default) Fallback template to use when MissingTemplate is raised
+        # @return [Mail::Message, nil] Email message or nil if notifications were not found
         def batch_notification_mail(target, notifications, batch_key, options = {})
-          initialize_from_notifications(target, notifications)
-          headers = headers_for(batch_key, options)
-          @notification = nil
-          send_mail(headers, options[:fallback])
+          with_notification_resilience(notifications&.first&.id, { target: target&.class&.name, batch: true }) do
+            initialize_from_notifications(target, notifications)
+            headers = headers_for(batch_key, options)
+            @notification = nil
+            send_mail(headers, options[:fallback])
+          end
         end
 
         # Initialize instance variables from notification.

data/lib/activity_notification/models/concerns/target.rb

@@ -419,6 +419,22 @@ module ActivityNotification
       Notification.open_all_of(self, options)
     end
 
+    # Destroys all notifications of the target matching the filter criteria.
+    #
+    # @param [Hash] options Options for filtering notifications to destroy
+    # @option options [String]   :filtered_by_type       (nil) Notifiable type for filter
+    # @option options [Object]   :filtered_by_group      (nil) Group instance for filter
+    # @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 notifications later than specified time
+    # @option options [String]   :earlier_than           (nil) ISO 8601 format time to filter notifications earlier than specified time
+    # @option options [Array]    :ids                    (nil) Array of specific notification IDs to destroy
+    # @return [Array<Notification>] Destroyed notification records
+    def destroy_all_notifications(options = {})
+      Notification.destroy_all_of(self, options)
+    end
+
 
     # Gets automatically arranged notification index of the target with included attributes like target, notifiable, group and notifier.
     # This method is the typical way to get notifications index from controller of view.

data/lib/activity_notification/models.rb

@@ -18,11 +18,11 @@ module ActivityNotification
 end
 
 if defined?(ActiveRecord::Base)
+  # :nocov:
   ActiveRecord::Base.class_eval { include ActivityNotification::Models }
 
   # https://github.com/simukappu/activity_notification/issues/166
   # https://discuss.rubyonrails.org/t/cve-2022-32224-possible-rce-escalation-bug-with-serialized-columns-in-active-record/81017
-  # :nocov:
   if (Gem::Version.new("5.2.8.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("6.0")) ||
     (Gem::Version.new("6.0.5.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("6.1")) ||
     (Gem::Version.new("6.1.6.1") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("7.0"))

data/lib/activity_notification/notification_resilience.rb

@@ -0,0 +1,115 @@
+module ActivityNotification
+  # Provides resilient notification handling across different ORMs
+  # Handles missing notification scenarios gracefully without raising exceptions
+  module NotificationResilience
+    extend ActiveSupport::Concern
+
+    # Exception classes for different ORMs
+    ORM_EXCEPTIONS = {
+      active_record: 'ActiveRecord::RecordNotFound',
+      mongoid: 'Mongoid::Errors::DocumentNotFound', 
+      dynamoid: 'Dynamoid::Errors::RecordNotFound'
+    }.freeze
+
+    class_methods do
+      # Returns the current ORM being used
+      # @return [Symbol] The ORM symbol (:active_record, :mongoid, :dynamoid)
+      def current_orm
+        ActivityNotification.config.orm
+      end
+
+      # Returns the exception class for the current ORM
+      # @return [Class] The exception class for missing records in current ORM
+      def record_not_found_exception_class
+        exception_name = ORM_EXCEPTIONS[current_orm]
+        return nil unless exception_name
+        
+        begin
+          exception_name.constantize
+        rescue NameError
+          nil
+        end
+      end
+
+      # Checks if an exception is a "record not found" exception for any supported ORM
+      # @param [Exception] exception The exception to check
+      # @return [Boolean] True if the exception indicates a missing record
+      def record_not_found_exception?(exception)
+        ORM_EXCEPTIONS.values.any? do |exception_name|
+          begin
+            exception.is_a?(exception_name.constantize)
+          rescue NameError
+            false
+          end
+        end
+      end
+    end
+
+    # Module-level methods that delegate to class methods
+    def self.current_orm
+      ActivityNotification.config.orm
+    end
+
+    def self.record_not_found_exception_class
+      exception_name = ORM_EXCEPTIONS[current_orm]
+      return nil unless exception_name
+      
+      begin
+        exception_name.constantize
+      rescue NameError
+        nil
+      end
+    end
+
+    def self.record_not_found_exception?(exception)
+      ORM_EXCEPTIONS.values.any? do |exception_name|
+        begin
+          exception.is_a?(exception_name.constantize)
+        rescue NameError
+          false
+        end
+      end
+    end
+
+    # Executes a block with resilient notification handling
+    # Catches ORM-specific "record not found" exceptions and logs them appropriately
+    # @param [String, Integer] notification_id The ID of the notification being processed
+    # @param [Hash] context Additional context for logging
+    # @yield Block to execute with resilient handling
+    # @return [Object, nil] Result of the block, or nil if notification was not found
+    def with_notification_resilience(notification_id = nil, context = {})
+      yield
+    rescue => exception
+      if self.class.record_not_found_exception?(exception)
+        log_missing_notification(notification_id, exception, context)
+        nil
+      else
+        raise exception
+      end
+    end
+
+    private
+
+    # Logs a warning when a notification is not found
+    # @param [String, Integer] notification_id The ID of the missing notification
+    # @param [Exception] exception The exception that was caught
+    # @param [Hash] context Additional context for logging
+    def log_missing_notification(notification_id, exception, context = {})
+      orm_name = self.class.current_orm
+      exception_class = exception.class.name
+      
+      message = "ActivityNotification: Notification"
+      message += " with id #{notification_id}" if notification_id
+      message += " not found for email delivery"
+      message += " (#{orm_name}/#{exception_class})"
+      message += ", likely destroyed before job execution"
+      
+      if context.any?
+        context_info = context.map { |k, v| "#{k}: #{v}" }.join(', ')
+        message += " [#{context_info}]"
+      end
+
+      Rails.logger.warn(message)
+    end
+  end
+end

data/lib/activity_notification/orm/dynamoid/extension.rb

@@ -83,92 +83,6 @@ module Dynamoid # :nodoc: all
   end
 end
 
-# Entend Dynamoid to support query and scan with 'null' and 'not_null' conditions
-# @private
-module Dynamoid # :nodoc: all
-  # @private
-  module Criteria
-    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
-    # @private
-    module NullOperatorExtension
-      # @private
-      def field_hash(key)
-        name, operation = key.to_s.split('.')
-        val = type_cast_condition_parameter(name, query[key])
-
-        hash = case operation
-               when 'null'
-                 { null: val }
-               when 'not_null'
-                 { not_null: val }
-               else
-                 return super(key)
-               end
-
-        { name.to_sym => hash }
-      end
-    end
-
-    # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/criteria/chain.rb
-    # @private
-    class Chain
-      prepend NullOperatorExtension
-    end
-  end
-
-  # @private
-  module AdapterPlugin
-    # @private
-    class AwsSdkV3
-
-      NULL_OPERATOR_FIELD_MAP = {
-        null:         'NULL',
-        not_null:     'NOT_NULL'
-      }.freeze
-
-      # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/adapter_plugin/aws_sdk_v3/query.rb
-      # @private
-      class Query < ::Dynamoid::AdapterPlugin::Query
-        # @private
-        def query_filter
-          conditions.except(*AwsSdkV3::RANGE_MAP.keys).reduce({}) do |result, (attr, cond)|
-            if AwsSdkV3::NULL_OPERATOR_FIELD_MAP.has_key?(cond.keys[0])
-              condition = { comparison_operator: AwsSdkV3::NULL_OPERATOR_FIELD_MAP[cond.keys[0]] }
-            else
-              condition = {
-                comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
-                attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
-              }
-            end
-            result[attr] = condition
-            result
-          end
-        end
-      end
-
-      # https://github.com/Dynamoid/dynamoid/blob/master/lib/dynamoid/adapter_plugin/aws_sdk_v3/scan.rb
-      # @private
-      class Scan < ::Dynamoid::AdapterPlugin::Scan
-        # @private
-        def scan_filter
-          conditions.reduce({}) do |result, (attr, cond)|
-            if AwsSdkV3::NULL_OPERATOR_FIELD_MAP.has_key?(cond.keys[0])
-              condition = { comparison_operator: AwsSdkV3::NULL_OPERATOR_FIELD_MAP[cond.keys[0]] }
-            else
-              condition = {
-                comparison_operator: AwsSdkV3::FIELD_MAP[cond.keys[0]],
-                attribute_value_list: AwsSdkV3.attribute_value_list(AwsSdkV3::FIELD_MAP[cond.keys[0]], cond.values[0].freeze)
-              }
-            end
-            result[attr] = condition
-            result
-          end
-        end
-      end
-    end
-  end
-end
-
 # Entend Dynamoid to support uniqueness validator
 # @private
 module Dynamoid # :nodoc: all
@@ -183,7 +97,10 @@ module Dynamoid # :nodoc: all
       # @param [Object] value      The value of the object.
       def validate_each(document, attribute, value)
         return unless validation_required?(document, attribute)
-        document.errors.add(attribute, :taken, options.except(:scope).merge(value: value)) if not_unique?(document, attribute, value)
+        if not_unique?(document, attribute, value)
+          error_options = options.except(:scope).merge(value: value)
+          document.errors.add(attribute, :taken, **error_options)
+        end
       end
 
       private

data/lib/activity_notification/orm/dynamoid/notification.rb

@@ -42,13 +42,30 @@ module ActivityNotification
         # Group owner instance has nil as :group_owner association.
         # @scope instance
         # @return [Notification] Group owner notification instance of this notification
-        belongs_to :group_owner, { class_name: "ActivityNotification::Notification", foreign_key: :group_owner_id, optional: true }
+        # Note: Dynamoid doesn't support belongs_to, so we implement it manually
 
         # Customized method that belongs to group owner notification instance of this notification.
         # @raise [Errors::RecordNotFound] Record not found error
         # @return [Notification] Group owner notification instance of this notification
         def group_owner
-          group_owner_id.nil? ? nil : Notification.find(group_owner_id)
+          group_owner_id.nil? ? nil : Notification.find(group_owner_id, raise_error: false)
+        end
+
+        # Setter method for group_owner association
+        # @param [Notification, nil] notification Group owner notification instance
+        def group_owner=(notification)
+          self.group_owner_id = notification.nil? ? nil : notification.id
+        end
+
+        # Override reload method to refresh the record from database
+        def reload
+          fresh_record = self.class.find(id)
+          if fresh_record
+            # Update specific attributes we care about
+            self.group_owner_id = fresh_record.group_owner_id
+            self.opened_at = fresh_record.opened_at
+          end
+          self
         end
 
         # Has many group member notification instances of this notification.