notify_user 0.1.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12da1c1e7ee14dfcbba8a54801e75d654615e599
-  data.tar.gz: 34e6d23884ab55ca3509f72d2790b77a4c1ab4f8
+  metadata.gz: 77798252ab441cbfca131b125e40292b701210dd
+  data.tar.gz: 5cc16d6d5c354588db35b6a0797ce61da23a669d
 SHA512:
-  metadata.gz: 4b89ad049ba111308ee77de5a79614ac315f7783ac4e92d97c613640b295027aa649cb145a6becddbe56eedb5cf790da08e2a5c3699bd46be95ec087bdf9b647
-  data.tar.gz: 2538cf1ecd80bd7a71c7b23a9ccfbf7abf8257abad192ba7d569a91ef5345cf2c763d75a1982e14fc5a1822afb626db4df92bafe02aef7e88ad129089f9c9da7
+  metadata.gz: fdb8a7efaa8c5e7af6bc9b8a84ae0189ce564c4492d25d8cb00c991a1964df787e00a392e77cea452c358e34380bc785d4638177304dd74df052a5d0ddc90d7c
+  data.tar.gz: 13e3307a5e50a15aade5b029bdf9483b3d20df4bd1b704b6057c2ba60dd30dc36433f14542520c5b0203cb485f5afe5f01a55304e19b79d601cf2f5160a1d710

data/README.md

@@ -141,6 +141,22 @@ Unsubscribe link helper - add this to your views/notify_user/layouts/action_mail
 	</p>
 <% end %>
 ```
+##Unsubscribing/Subscribing to a specific group_id or resource
+Unsubscribing from a specific `group_id` eg. specific resource.
+`put /notify_user/notifications/unsubscribe_from_object.json`
+expects
+```
+subscription: {type: "NotificationType", group_id: 1, unsubscribe: true|false}
+```
+returns
+`response_code 201`
+
+##Upgrade v0.1.4 to v0.2
+Run aggregate_interval generator which generates the migrations to add a sent_time field to notifications
+```
+rails generate notify_user:aggr_interval
+rake db:migrate
+```
 
 ##Upgrading to JSON params data type
 Run json_update generator which generates the migrations to change the params datatype to json as well as convert the current data to json

data/Rakefile

@@ -1,4 +1,10 @@
-require "bundler"
+begin
+  require 'bundler/setup'
+  require 'appraisal'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
 require 'rake'
 Bundler.setup
 Bundler::GemHelper.install_tasks

data/app/controllers/notify_user/base_notifications_controller.rb

@@ -3,14 +3,14 @@ class NotifyUser::BaseNotificationsController < ApplicationController
   before_filter :authenticate!, :except => [:unauth_unsubscribe]
 
   def index
-    collection                                     
+    collection
     respond_to_method
   end
 
   def collection
     @notifications = NotifyUser::BaseNotification.for_target(@user)
                                                   .order("created_at DESC")
-                                                  .limit(30)
+                                                  .where('parent_id IS NULL')
     collection_pagination
   end
 
@@ -32,17 +32,33 @@ class NotifyUser::BaseNotificationsController < ApplicationController
   end
 
   def mark_all
-    @notifications = NotifyUser::BaseNotification.for_target(@user).where('state IN (?)', ["pending","sent"])
+    @notifications = NotifyUser::BaseNotification.for_target(@user).where('state != ?', 'read')
     @notifications.update_all(state: :read)
-    redirect_to notify_user_notifications_path  
+    render json: @notifications
   end
 
   def notifications_count
-    @notifications = NotifyUser::BaseNotification.for_target(@user).where('state IN (?)', ["sent", "pending"])
-    render json: {:count => @notifications.count}
+    @notifications = NotifyUser::BaseNotification.for_target(@user)
+      .where('parent_id IS NULL')
+      .where('state IN (?)', ["sent_as_aggregation_parent", "sent", "pending"])
+
+    render json: { :count => @notifications.count }
   end
 
-  #get 
+  def unsubscribe_from_object
+    case params[:subscription][:unsubscribe]
+    when true
+      NotifyUser::Unsubscribe.unsubscribe(@user, params[:subscription][:type], params[:subscription][:group_id])
+    when false
+      NotifyUser::Unsubscribe.subscribe(@user, params[:subscription][:type], params[:subscription][:group_id])
+    else
+      raise "unsubscribe field required"
+    end
+
+    render json: {status: "OK"}, status: 201
+  end
+
+  #get
   def read
     @notification = NotifyUser::BaseNotification.for_target(@user).where('id = ?', params[:id]).first
     unless @notification.read?
@@ -58,8 +74,8 @@ class NotifyUser::BaseNotificationsController < ApplicationController
 
   def unsubscribe
     if params[:type]
-      unsubscribe_from(params[:type])
-      redirect_to notify_user_notifications_unsubscribe_path  
+      NotifyUser::Unsubscribe.unsubscribe(@user, params[:type])
+      redirect_to notify_user_notifications_unsubscribe_path
     end
     @types = build_notification_types
     @unsubscribale_types = NotifyUser.unsubscribable_notifications
@@ -82,28 +98,25 @@ class NotifyUser::BaseNotificationsController < ApplicationController
           NotifyUser::Unsubscribe.unsubscribe(@user,type[:type])
         else
           if unsubscribe.empty?
-            #if unsubscribe doesn't exist create it 
+            #if unsubscribe doesn't exist create it
             unsubscribe = NotifyUser::Unsubscribe.create(target: @user, type: type[:type])
           end
         end
       end
       flash[:message] = "Successfully updated your notifcation settings"
-    end  
-    redirect_to notify_user_notifications_unsubscribe_path  
+    end
+    redirect_to notify_user_notifications_unsubscribe_path
   end
 
   def update_subscriptions(types)
     types.each do |type|
       unsubscribe = NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type[:type])
       if type[:status] == '0'
-        if unsubscribe.empty?
-          #if unsubscribe doesn't exist create it 
-          unsubscribe = NotifyUser::Unsubscribe.create(target: @user, type: type[:type])
-        end
+        NotifyUser::Unsubscribe.unsubscribe(@user, type[:type])
       else
-        subscribe_to(type[:type])
+        NotifyUser::Unsubscribe.subscribe(@user, type[:type])
       end
-    end 
+    end
   end
 
   def unauth_unsubscribe
@@ -122,7 +135,7 @@ class NotifyUser::BaseNotificationsController < ApplicationController
   end
 
   def subscribe
-    subscribe_to(params[:type]) if params[:type]
+    NotifyUser::Unsubscribe.subscribe(@user, params[:type]) if params[:type]
     redirect_to notify_user_notifications_unsubscribe_path
   end
 
@@ -141,6 +154,7 @@ class NotifyUser::BaseNotificationsController < ApplicationController
   end
 
   private
+
   def build_notification_types()
     #dirty way to build a json hash with pagination
     types = {:subscriptions => []}
@@ -151,28 +165,15 @@ class NotifyUser::BaseNotificationsController < ApplicationController
     NotifyUser::BaseNotification.channels.each do |type, options|
         channel = (type.to_s + "_channel").camelize.constantize
         types[:subscriptions] << {type: type, description: channel.default_options[:description],
-          status: NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type).empty?}
-    end 
+          status: NotifyUser::Unsubscribe.has_unsubscribed_from?(@user, type)}
+    end
 
     #iterates over type
     notification_types.each do |type|
         types[:subscriptions] << {type: type, description: type.constantize.description,
-          status: NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type).empty?}
+          status: NotifyUser::Unsubscribe.has_unsubscribed_from?(@user, type)}
     end
     return types
   end
 
-  def unsubscribe_from(type)
-      unsubscribe = NotifyUser::Unsubscribe.new(target: @user, type: type)
-      if unsubscribe.save
-        flash[:message] = "successfully unsubscribed from #{type} notifications"
-      else
-        flash[:message] = "Please try again"
-      end
-  end
-
-  def subscribe_to(type)
-    NotifyUser::Unsubscribe.unsubscribe(@user,type)
-    flash[:message] = "successfully subscribed to #{type} notifications"
-  end
 end

data/app/mailers/notify_user/notification_mailer.rb

@@ -3,7 +3,7 @@ module NotifyUser
     helper NotifyUser::ApplicationHelper
 
     layout "notify_user/layouts/action_mailer"
-  
+
     def notification_email(notification, options)
       @notification = notification
 

data/app/models/notify_user/apn_connection.rb

@@ -1,43 +1,61 @@
 module NotifyUser
   class APNConnection
 
-    attr_accessor :connection
-
     def initialize
-      setup
+      connection
+    end
+
+    def connection
+      @connection ||= setup_connection
+    end
+
+    def write(data)
+      raise "Connection is closed" unless @connection.open?
+      @connection.write(data)
     end
 
-    def setup
+    def reset
+      @connection.close if @connection
+      @connection = nil
+      connection
+    end
+
+    private
+
+    def apn_environment
+      return nil unless ENV['APN_ENVIRONMENT']
+
+      ENV['APN_ENVIRONMENT'].downcase.to_sym
+    end
+
+    def setup_connection
+      return if Rails.env.test?
+
       @uri, @certificate = if Rails.env.development? || apn_environment == :development
         Rails.logger.info "Using development gateway. Rails env: #{Rails.env}, APN_ENVIRONMENT: #{apn_environment}"
         [
           ::Houston::APPLE_DEVELOPMENT_GATEWAY_URI,
-          File.read("#{Rails.root}/config/keys/development_push.pem")
+          File.read(development_certificate)
         ]
       else
         Rails.logger.info "Using production gateway. Rails env: #{Rails.env}, APN_ENVIRONMENT: #{apn_environment}"
         [
           ::Houston::APPLE_PRODUCTION_GATEWAY_URI,
-          File.read("#{Rails.root}/config/keys/production_push.pem")
+          File.read(production_certificate)
         ]
       end
 
       @connection = ::Houston::Connection.new(@uri, @certificate, nil)
-      @connection.open
     end
 
-    def write(data)
-      raise "Connection is closed" unless @connection.open?
-      @connection.write(data)
+    def development_certificate
+      file_path = ENV['APN_DEVELOPMENT_PATH'] || 'config/keys/development_push.pem'
+      "#{Rails.root}/#{file_path}"
     end
 
-    private
-
-    def apn_environment
-      return nil unless ENV['APN_ENVIRONMENT']
-
-      ENV['APN_ENVIRONMENT'].downcase.to_sym
+    def production_certificate
+      file_path = ENV['APN_PRODUCTION_PATH'] || "config/keys/production_push.pem"
+      "#{Rails.root}/#{file_path}"
     end
-
   end
 end

data/app/models/notify_user/apns.rb

@@ -1,28 +1,138 @@
+require_relative 'apn_connection'
+require 'houston'
+
 module NotifyUser
-  class Apns
-    SYMBOL_NAMES_SIZE = 10
-    PAYLOAD_LIMIT = 255
+  class Apns < Push
+    NO_ERROR = -42
+    INVALID_TOKEN_ERROR = 8
+    CONNECTION = APNConnection.new
+
+    attr_accessor :push_options
 
-    def initialize(notification, options)
-      @notification = notification
-      @options = options
+    def initialize(notifications, devices, options)
+      super(notifications, devices, options)
+
+      @push_options = setup_options
+      @devices = devices
     end
 
-    # Sends push notification:
     def push
-      raise "Base APNS class should not be used."
+      send_notifications
     end
 
     private
 
-    # Calculates the bytes already used:
-    def used_space
-      used_space = SYMBOL_NAMES_SIZE + @notification.id.size + @notification.created_at.to_time.to_i.size +
-                    @notification.type.size
+    attr_accessor :devices
+
+    def connection
+      CONNECTION.connection
+    end
+
+    def reset_connection
+      CONNECTION.reset
+    end
+
+    def setup_options
+      space_allowance = PAYLOAD_LIMIT - used_space
+
+      mobile_message = ''
+      if @notification.parent_id
+        parent = @notification.class.find(@notification.parent_id)
+        mobile_message = parent.mobile_message(space_allowance)
+      else
+        mobile_message = @notification.mobile_message(space_allowance)
+      end
+      mobile_message.gsub!('\n', "\n")
+
+      push_options = {
+        alert: mobile_message,
+        badge: @notification.count_for_target,
+        category: @notification.params[:category] || @notification.type,
+        custom_data: @notification.params,
+        sound: @options[:sound] || 'default'
+      }
+
+      if @options[:silent]
+        push_options.merge!({
+          alert: '',
+          sound: '',
+          content_available: true
+        }).delete(:badge)
+      end
+
+      push_options
+    end
+
+    def valid?(payload)
+      payload.to_json.bytesize <= PAYLOAD_LIMIT
+    end
+
+    def send_notifications
+      connection.open if connection.closed?
+
+      Rails.logger.info "PAYLOAD"
+      Rails.logger.info "----"
+      Rails.logger.info "#{@push_options}"
+
+      unless valid?(@push_options)
+        Rails.logger.info "Error: Payload exceeds size limit."
+      end
+
+      devices.each_with_index do |device, index|
+        notification = ::Houston::Notification.new(@push_options.dup.merge({ token: device.token, id: index }))
+        connection.write(notification.message)
+      end
+
+      error_index = io_errors
+
+      if error_index == NO_ERROR
+        return true
+      else
+        # Resend all notifications after the once that produced the error:
+        send_notifications
+      end
+    rescue OpenSSL::SSL::SSLError, Errno::EPIPE, Errno::ETIMEDOUT => e
+      Rails.logger.error "[##{connection.object_id}] Exception occurred: #{e.inspect}."
+      reset_connection
+      Rails.logger.debug "[##{connection.object_id}] Socket reestablished."
+      retry
+    end
+
+    def io_errors
+      error_index = NO_ERROR
+      ssl = connection.ssl
+
+      Rails.logger.info "READING ERRORS"
+      Rails.logger.info "----"
+      read_socket, write_socket = IO.select([ssl], [], [ssl], 1)
+      Rails.logger.info "#{ssl}"
+
+      if (read_socket && read_socket[0])
+        error = connection.read(6)
+
+        Rails.logger.info "#{error}"
+
+        if error
+          command, status, error_index = error.unpack("ccN")
+
+          Rails.logger.info "Error: #{status} with id: #{error_index}."
+
+          # Remove all the devices prior to the error (we assume they were successful), and close the current connection:
+          if error_index != NO_ERROR
+            device = devices.at(error_index)
 
-      used_space += @notification.params[:action_id].size if @notification.params[:action_id]
+            # If we encounter the Invalid Token error from APNS, just remove the device:
+            if status == INVALID_TOKEN_ERROR
+              Rails.logger.info "Invalid token encountered, removing device. Token: #{device.token}."
+              device.destroy
+            end
 
-      used_space
+            devices.slice!(0..error_index)
+            reset_connection
+          end
+        end
+      end
+      return error_index
     end
   end
 end

data/app/models/notify_user/base_notification.rb

@@ -11,7 +11,7 @@ module NotifyUser
     after_commit :deliver, on: :create
 
     if ActiveRecord::VERSION::MAJOR < 4
-      attr_accessible :params, :target, :type, :state
+      attr_accessible :params, :target, :type, :state, :group_id, :parent_id
     end
 
     # Override point in case of collisions, plus keeps the table name tidy.
@@ -29,6 +29,7 @@ module NotifyUser
     belongs_to :target, polymorphic: true
 
     validates_presence_of :target_id, :target_type, :target, :type, :state
+    validate :presence_of_group_id
 
     aasm column: :state do
 
@@ -41,12 +42,25 @@ module NotifyUser
       # Email/SMS/APNS has been sent.
       state :sent
 
+      # Identifies which notification within the aggregation window that was actually delayed
+      state :sent_as_aggregation_parent
+      state :pending_as_aggregation_parent
+
       # The user has seen this notification.
       state :read
 
       # Record that we have sent message(s) to the user about this notification.
       event :mark_as_sent do
-        transitions from: [:pending, :pending_no_aggregation], to: :sent
+        transitions from: [:pending_as_aggregation_parent], to: :sent_as_aggregation_parent, :if => :pending_as_aggregation_parent?
+        transitions from: [:pending, :pending_no_aggregation], to: :sent, :unless => :pending_as_aggregation_parent?
+        after do
+          self.sent_time = Time.now
+          self.save
+        end
+      end
+
+      event :mark_as_pending_as_aggregation_parent do
+        transitions from: [:pending], to: :pending_as_aggregation_parent
       end
 
       event :dont_aggregate do
@@ -57,7 +71,7 @@ module NotifyUser
       # A notification can go straight from pending to read if it's seen in a view before
       # sent in an email.
       event :mark_as_read do
-        transitions from: [:pending, :sent], to: :read
+        transitions from: [:pending, :sent, :pending_as_aggregation_parent, :sent_as_aggregation_parent], to: :read
       end
     end
 
@@ -71,23 +85,35 @@ module NotifyUser
 
     # returns the global unread notification count for a user
     def count_for_target
-      NotifyUser::BaseNotification.for_target(target).where('state IN (?)', ["sent", "pending"]).count
+      NotifyUser::BaseNotification.for_target(target)
+        .where('parent_id IS NULL')
+        .where('state IN (?)', ["sent_as_aggregation_parent", "sent", "pending"])
+        .count
+    end
+
+    def self.aggregate_message(notifications)
+      string = ActionView::Base.new(
+             ActionController::Base.view_paths).render(
+             :template => self.class.views[:mobile_sdk][:aggregate_path].call(self), :formats => [:html],
+             :locals => { :notifications => notifications})
+
+      return ::CGI.unescapeHTML("#{string}")
     end
 
     def message
       string = ActionView::Base.new(
-             Rails.configuration.paths["app/views"]).render(
+             ActionController::Base.view_paths).render(
              :template => self.class.views[:mobile_sdk][:template_path].call(self), :formats => [:html],
-             :locals => { :params => self.params})
+             :locals => { :params => self.params, :notification => self})
 
       return ::CGI.unescapeHTML("#{string}")
     end
 
     def mobile_message(length=115)
       string = truncate(ActionView::Base.new(
-             Rails.configuration.paths["app/views"]).render(
+             ActionController::Base.view_paths).render(
              :template => self.class.views[:mobile_sdk][:template_path].call(self), :formats => [:html],
-             :locals => { :params => self.params}), :length => length)
+             :locals => { :params => self.params, :notification => self}), :length => length)
 
       return ::CGI.unescapeHTML("#{string}")
     end
@@ -103,15 +129,33 @@ module NotifyUser
       self
     end
 
+    def grouped_by_id(group_id)
+      self.group_id = group_id
+      self
+    end
+
     def notify!
       # Bang version of 'notify' ignores aggregation
       dont_aggregate!
     end
 
     # Send any Emails/SMS/APNS
-    def notify
+    def notify(deliver=true)
+      #All notifications except the notification at interval 0 should have there parent_id set
+      if self.aggregate_grouping
+        parents = current_parents.where(parent_id: nil).where('created_at >= ?', 24.hours.ago).order('created_at DESC')
+
+        if parents.any?
+          self.parent_id = parents.first.id
+        end
+      end
+
       # Sends with aggregation if enabled
       save
+
+      ## if deliver == false don't perform deliver log but still perform aggregation logic
+      ## notification then gets marked as sent
+      mark_as_sent! unless deliver
     end
 
     def generate_unsubscribe_hash
@@ -119,6 +163,25 @@ module NotifyUser
       return NotifyUser::UserHash.where(target_id: self.target.id).where(target_type: self.target.class.base_class).where(type: self.type).where(active: true).first || NotifyUser::UserHash.create(target: self.target, type: self.type, active: true)
     end
 
+    def aggregation_interval
+      pending_and_sent_aggregation_parents.count
+    end
+
+    def delay_time(options)
+      a_interval = options[:aggregate_per][aggregation_interval]
+
+      # uses the last interval by default once we deplete the intervals
+      a_interval = options[:aggregate_per].last if a_interval.nil?
+
+      # last sent notification
+      last_sent_parent = sent_aggregation_parents.first
+      # Uses the time of the last notification sent otherwise will send it now.
+      delay_time = last_sent_parent ? last_sent_parent.sent_time : created_at
+
+      # If this is the first notification the aggregate interval will return 0. Thus sending the notification now!
+      return delay_time + a_interval.minutes
+    end
+
     ## Notification description
     class_attribute :description
     self.description = ""
@@ -128,12 +191,23 @@ module NotifyUser
     self.channels = {
     }
 
+    ## Aggregation
+
+    class_attribute :aggregate_per
+    self.aggregate_per = 1.minute
+
+    ## True will implement a grouping/aggregation algorithm so that even though 10 notifications are delivered eg. Push Notifications
+    ## Only 1 notification will be displayed to the user within the notification.json payload
+    class_attribute :aggregate_grouping
+    self.aggregate_grouping = false
+
     # Not sure about this. The JSON and web feeds don't fit into channels, because nothing is broadcast through
     # them. Not sure if they really need another concept though, they could just be formats on the controller.
     class_attribute :views
     self.views = {
       mobile_sdk: {
-        template_path: Proc.new {|n| "notify_user/#{n.class.name.underscore}/mobile_sdk/notification" }
+        template_path: Proc.new {|n| "notify_user/#{n.class.name.underscore}/mobile_sdk/notification" },
+        aggregate_path: Proc.new {|n| "notify_user/#{n.class.name.underscore}/mobile_sdk/aggregate_notifications" }
       }
     }
 
@@ -144,11 +218,6 @@ module NotifyUser
       self.channels = channels_clone
     end
 
-    ## Aggregation
-
-    class_attribute :aggregate_per
-    self.aggregate_per = 1.minute
-
     ## Sending
 
     def self.for_target(target)
@@ -156,31 +225,91 @@ module NotifyUser
       .where(target_type: target.class.base_class)
     end
 
+    # Returns all parent notifications with a given group_id
+    def current_parents
+      self.class
+      .for_target(self.target)
+      .where(group_id: group_id)
+    end
+
+    def aggregation_parents
+      current_parents
+      .where('id != ?', id)
+    end
+
+    def sent_aggregation_parents
+      aggregation_parents
+      .where(state: :sent_as_aggregation_parent)
+      .order('created_at DESC')
+    end
+
+    def pending_and_sent_aggregation_parents
+      aggregation_parents
+      .where(state: [:sent_as_aggregation_parent, :pending_as_aggregation_parent])
+      .order('created_at DESC')
+    end
+
+    # Used for aggregation when grouping isn't enabled
+    def self.pending_aggregations_marked_as_parent(notification)
+      where(type: notification.type)
+      .for_target(notification.target)
+      .where(state: :pending_as_aggregation_parent)
+    end
+
+    # Used for aggregation when grouping based on group_id for target
+    def self.pending_aggregations_grouped_marked_as_parent(notification)
+      where(type: notification.type)
+      .for_target(notification.target)
+      .where(state: :pending_as_aggregation_parent)
+      .where(group_id: notification.group_id)
+    end
+
+    # Used to find all pending notifications with aggregation enabled for target
+    def self.pending_aggregation_by_group_with(notification)
+      for_target(notification.target)
+      .where(state: [:pending, :pending_as_aggregation_parent])
+      .where(group_id: notification.group_id)
+    end
+
+    # Used to find all pending notifications for target
     def self.pending_aggregation_with(notification)
       where(type: notification.type)
       .for_target(notification.target)
-      .where(state: :pending)
+      .where(state: [:pending, :pending_as_aggregation_parent])
     end
 
     def aggregation_pending?
       # A notification of the same type, that would have an aggregation job associated with it,
       # already exists.
-      return (self.class.pending_aggregation_with(self).where('id != ?', id).count > 0)
+
+      # When group aggregation is enabled we provide a different scope
+      if self.aggregate_grouping
+        return (self.class.pending_aggregations_grouped_marked_as_parent(self).where('id != ?', id).count > 0)
+      else
+        return (self.class.pending_aggregations_marked_as_parent(self).where('id != ?', id).count > 0)
+      end
     end
 
     # Aggregates appropriately
     def deliver
       if pending? and not user_has_unsubscribed?
-        self.mark_as_sent!
-
         # if aggregation is false bypass aggregation completely
         self.channels.each do |channel_name, options|
           if(options[:aggregate_per] == false)
+            self.mark_as_sent!
             self.class.delay.deliver_notification_channel(self.id, channel_name)
           else
-            # only notifies channels if no pending aggreagte notifications
-            if not aggregation_pending?
-              self.class.delay_for(options[:aggregate_per] || self.aggregate_per).notify_aggregated_channel(self.id, channel_name)
+            # only notifies channels if no pending aggregate notifications
+            unless aggregation_pending?
+              self.mark_as_pending_as_aggregation_parent!
+
+              # adds fallback support for integer or array of integers
+              if options[:aggregate_per].kind_of?(Array)
+                self.class.delay_until(delay_time(options)).notify_aggregated_channel(self.id, channel_name)
+              else
+                a_interval = options[:aggregate_per] ? options[:aggregate_per].minutes : self.aggregate_per
+                self.class.delay_for(a_interval).notify_aggregated_channel(self.id, channel_name)
+              end
             end
           end
         end
@@ -221,7 +350,7 @@ module NotifyUser
       channel_options = channels[channel_name.to_sym]
       channel = (channel_name.to_s + "_channel").camelize.constantize
 
-      unless self.unsubscribed_from_channel?(notification.target, channel_name)
+      unless notification.user_has_unsubscribed?(channel_name)
         channel.deliver(notification, channel_options)
       end
     end
@@ -232,7 +361,7 @@ module NotifyUser
       channel = (channel_name.to_s + "_channel").camelize.constantize
 
       #check if user unsubsribed from channel type
-      unless self.unsubscribed_from_channel?(notifications.first.target, channel_name)
+      unless notifications.first.user_has_unsubscribed?(channel_name)
         channel.deliver_aggregated(notifications, channel_options)
       end
     end
@@ -242,12 +371,18 @@ module NotifyUser
       notification = self.find(notification_id) # Raise an exception if not found.
 
       # Find any pending notifications with the same type and target, which can all be sent in one message.
-      notifications = self.pending_aggregation_with(notification)
+      if self.aggregate_grouping
+        notifications = self.pending_aggregation_by_group_with(notification)
+      else
+        notifications = self.pending_aggregation_with(notification)
+      end
 
       notifications.map(&:mark_as_sent)
       notifications.map(&:save)
 
-      return if notifications.empty?
+      # If the notification has been marked as read before it's sent we don't want to send it.
+      return if notification.read? || notifications.empty?
+
       if notifications.length == 1
         # Despite waiting for more to aggregate, we only got one in the end.
         self.deliver_notification_channel(notifications.first.id, channel_name)
@@ -257,24 +392,26 @@ module NotifyUser
       end
     end
 
+    def user_has_unsubscribed?(channel_name=nil)
+      #return true if user has unsubscribed
+      return Unsubscribe.has_unsubscribed_from?(self.target, self.type, self.group_id, channel_name)
+    end
+
     private
 
-    def unsubscribed_validation
-      errors.add(:target, (" has unsubscribed from this type")) if user_has_unsubscribed?
+    def presence_of_group_id
+      if self.aggregate_grouping && group_id.blank?
+        errors.add(:group_id, "required when aggregate_grouping is set to true")
+      end
     end
 
-    def user_has_unsubscribed?
-      #return true if user has unsubscribed
-      return true unless NotifyUser::Unsubscribe.has_unsubscribed_from(self.target, self.type).empty?
-
-      return false
+    def unsubscribed_validation
+      errors.add(:target, (" has unsubscribed from this type")) if user_has_unsubscribed?
     end
 
     def self.unsubscribed_from_channel?(user, type)
       #return true if user has unsubscribed
       return !NotifyUser::Unsubscribe.has_unsubscribed_from(user, type).empty?
     end
-
-
   end
 end