module NotifyOn::Creator

Private Instance Methods

create_notify_on_notifications(options) click to toggle source
# File lib/notify_on/creator.rb, line 6
def create_notify_on_notifications(options)

  # skip_notifications disables all notifications for an instance.
  return if skip_notifications == true

  # Collect notifications so we can return the set if we are creating more
  # than one (when "to" is an array or collection).
  notifications = []

  # "to" must be a method or attribute, and here we resolve it.
  to = options[:to].to_s == 'self' ? self : send(options[:to].to_s)

  # We don't need a sender all the time, but we figure out who it is now
  # so we can more easily work with the object.
  sender = options[:from].blank? ? nil : send(options[:from].to_s)

  # Ensure "to" is an array so we can iterate over it, even if that's only
  # happening once.
  (to.respond_to?(:each) ? to : [to]).each do |recipient|

    # If we have an update strategy, then we first need to look for an
    # exiting notification.
    notification = find_from_update_strategy(recipient, sender, options)

    # Create a new notification if we didn't have an update strategy or
    # couldn't find one. Much of the advanced work happens within the
    # model, which is why we store "options" in the record.
    notification = NotifyOn::Notification.new(
      :recipient => recipient,
      :sender => sender,
      :description_raw => options[:message],
      :options => options
    ) if notification.nil?

    # Update the shared attributes regardless of whether the notification
    # is being created or updated.
    notification.assign_attributes(
      :unread => true,
      :trigger => self,
      :link_raw => options[:link]
    )

    # Make sure we can save the notification.
    notification.save!

    # Attempt to send the notification via Pusher. There are catches in
    # place to prevent it from being pushed if disabled.
    # -- NotifyOn::PusherSupport
    notification.push!

    # Send the notification via email, if requested.
    # -- NotifyOn::EmailSupport
    notification.send_email! if options[:email].present?

    # Add notification to the collection for response.
    notifications << notification
  end

  # Return the collection of notifications that we created.
  notifications
end
find_from_update_strategy(to, from, options) click to toggle source
# File lib/notify_on/creator.rb, line 68
def find_from_update_strategy(to, from, options)
  # Exit if we don't have a strategy, and currently we only support the
  # :sender strategy.
  return nil unless options[:update] && options[:update][:strategy] &&
                    options[:update][:strategy] == :sender &&
                    from.present?
  if (scope = options[:update][:scope]).present?
    to.notifications.from_with_type(from, self.class.name).recent
      .includes(:trigger => [scope])
      .select{ |n| n.trigger.send(scope) == self.send(scope)}[0]
  else
    to.notifications.from_with_type(from, self.class.name).recent
      .limit(1)[0]
  end
end