notify_user 0.1.4 → 0.3.1

data/app/models/notify_user/gcm.rb

@@ -0,0 +1,58 @@
+require 'gcm'
+
+module NotifyUser
+  class Gcm < Push
+    PAYLOAD_LIMIT = 4096
+
+    attr_accessor :client, :push_options
+
+    def initialize(notifications, devices, options)
+      super(notifications, devices, options)
+
+      @push_options = setup_options
+    end
+
+    def push
+      send_notifications
+    end
+
+    def client
+      @client ||= GCM.new(ENV['GCM_API_KEY'])
+    end
+
+    def valid?(payload)
+      payload.to_json.bytesize <= PAYLOAD_LIMIT
+    end
+
+    private
+
+    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
+
+      {
+        data: {
+          notification_id: @notification.id,
+          message: mobile_message,
+          type: @options[:category] || @notification.type,
+          unread_count: @notification.count_for_target,
+          custom_data: @notification.params,
+        }
+      }
+    end
+
+    def send_notifications
+      return unless device_tokens.any?
+      response = client.send(device_tokens, @push_options)
+      # should be checking for errors in the response here
+      return true
+    end
+  end
+end

data/app/models/notify_user/push.rb

@@ -0,0 +1,37 @@
+module NotifyUser
+  class Push
+    SYMBOL_NAMES_SIZE = 10
+    PAYLOAD_LIMIT = 255
+
+    def initialize(notifications, devices, options)
+      @notifications = notifications
+      @notification = notifications.first
+
+      @devices = devices
+      @options = options
+    end
+
+    # Sends push notification:
+    def push
+      raise "Base APNS class should not be used."
+    end
+
+    private
+
+    attr_accessor :device_tokens
+
+    def device_tokens
+      @device_tokens = @devices.map(&:token)
+    end
+
+    # 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
+
+      used_space += @notification.params[:action_id].size if @notification.params[:action_id]
+
+      used_space
+    end
+  end
+end

data/app/models/notify_user/unsubscribe.rb

@@ -12,7 +12,7 @@ module NotifyUser
     self.inheritance_column = :_type_disabled
 
     if Rails.version.to_i < 4
-      attr_accessible :target, :type
+      attr_accessible :target, :type, :group_id
     end
 
     def self.for_target(target)
@@ -21,24 +21,41 @@ module NotifyUser
     end
 
     def self.toggle_status(target, type)
-      if NotifyUser::Unsubscribe.has_unsubscribed_from(target, type).empty?
-        NotifyUser::Unsubscribe.create(target: target, type: type)
+      if NotifyUser::Unsubscribe.has_unsubscribed_from?(target, type)
+        NotifyUser::Unsubscribe.subscribe(target, type)
       else
         NotifyUser::Unsubscribe.unsubscribe(target,type)
-      end 
+      end
     end
 
-    def self.unsubscribe(target, type)
+    def self.unsubscribe(target, type, group_id=nil)
+      ## creates unsubscribe object if it doesn't already exist
+      unless exists?(target_id: target.id, target_type: target.class.base_class,
+        type: type, group_id: group_id)
+        create(target: target, type: type, group_id: group_id)
+      end
+    end
+
+    def self.subscribe(target, type, group_id=nil)
       #deletes unsubscribe object in essence subscribing a user
       where(target_id: target.id)
       .where(target_type: target.class.base_class)
-      .where(type: type).destroy_all
-    end    
+      .where(type: type, group_id: group_id).destroy_all
+    end
+
+    ## checks to see if you've unsubscribed from the overall notification type
+    ## before checking you've unsubscribed from the specific group_id
+    def self.has_unsubscribed_from?(target, type, group_id=nil, channel_name=nil)
+      return true if where(target_id: target.id, target_type: target.class.base_class).where(type: type).any?
+      return true if where(target_id: target.id, target_type: target.class.base_class, type: type, group_id: group_id).any? if group_id
+      return true if where(target_id: target.id, target_type: target.class.base_class, type: channel_name).any? if channel_name
+      false
+    end
 
-    def self.has_unsubscribed_from(target, type)
+    def self.has_unsubscribed_from(target, type, group_id=nil)
       where(target_id: target.id)
       .where(target_type: target.class.base_class)
-      .where(type: type)
+      .where(type: type, group_id: group_id)
     end
 
   end

data/app/models/notify_user/urban_airship.rb

@@ -1,5 +1,5 @@
 module NotifyUser
-  class UrbanAirship < Apns
+  class UrbanAirship < Push
 
     def push
       space_allowance = PAYLOAD_LIMIT - used_space

data/app/serializers/notify_user/notification_serializer.rb

@@ -5,10 +5,7 @@ class NotifyUser::NotificationSerializer < ActiveModel::Serializer
   attributes :id, :type, :message, :read, :params, :created_at
 
   def message
-    string = options[:template_renderer].render_to_string(:template => object.class.views[:mobile_sdk][:template_path].call(object),
-                                                 :locals => {params: object.params},
-                                                 :layout => false, :formats => [:html])
-    return ::CGI.unescapeHTML("#{string}")
+    object.message
   end
 
   def read

data/config/routes.rb

@@ -4,13 +4,13 @@ Rails.application.routes.draw do
     put 'notifications/mark_read' => 'notifications#mark_read'
     get 'notifications/notifications_count' => 'notifications#notifications_count'
     get 'notifications/:id/read' => 'notifications#read'
-    get 'notifications/mark_all' => 'notifications#mark_all'
+    put 'notifications/mark_all' => 'notifications#mark_all'
     get 'notifications/unsubscribe' => 'notifications#unsubscribe'
     get 'notifications/subscribe' => 'notifications#subscribe'
     get 'notifications/unauth_unsubscribe' => 'notifications#unauth_unsubscribe'
     get 'notifications/subscriptions' => 'notifications#subscriptions'
     put 'notifications/subscriptions' => 'notifications#subscriptions'
     put 'notifications/mass_subscriptions' => 'notifications#mass_subscriptions'
-
+    put 'notification/unsubscribe_from_object' => 'notifications#unsubscribe_from_object'
   end
 end

data/lib/generators/notify_user/aggr_interval_update/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Add sent_time column to notifications
+
+Example:
+    rails generate notify_user:aggr_interval_update

data/lib/generators/notify_user/aggr_interval_update/aggr_interval_update_generator.rb

@@ -0,0 +1,36 @@
+require 'rails/generators/active_record'
+
+class NotifyUser::AggrIntervalUpdateGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_migrations
+    copy_migration "add_sent_time_to_notifications"
+    copy_migration "update_unsubscribes"
+
+    puts "Update successful. You can now run:"
+    puts "  rake db:migrate"
+  end
+
+  # This is defined in ActiveRecord::Generators::Base, but that inherits from NamedBase, so it expects a name argument
+  # which we don't want here. So we redefine it here. Yuck.
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(dirname) + 1)
+    end
+  end
+
+  protected
+
+    def copy_migration(filename)
+      if self.class.migration_exists?("db/migrate", "#{filename}")
+        say_status("skipped", "Migration #{filename}.rb already exists")
+      else
+        migration_template "#{filename}.rb", "db/migrate/#{filename}.rb"
+      end
+    end
+
+end

data/lib/generators/notify_user/aggr_interval_update/templates/add_sent_time_to_notifications.rb

@@ -0,0 +1,10 @@
+class AddSentTimeToNotifications < ActiveRecord::Migration
+  def change
+    add_column :notify_user_notifications, :sent_time, :datetime
+    add_column :notify_user_notifications, :group_id, :integer
+    add_column :notify_user_notifications, :parent_id, :integer
+
+    add_index :notify_user_notifications, :group_id
+    add_index :notify_user_notifications, :parent_id
+  end
+end

data/lib/generators/notify_user/aggr_interval_update/templates/update_unsubscribe.rb

@@ -0,0 +1,6 @@
+class UpdateUnsubscribe < ActiveRecord::Migration
+  def change
+    add_column :notify_user_unsubscribes, :group_id, :integer
+    add_index :notify_user_unsubscribes, :group_id
+  end
+end

data/lib/generators/notify_user/install/install_generator.rb

@@ -25,11 +25,8 @@ class NotifyUser::InstallGenerator < Rails::Generators::Base
   # This is defined in ActiveRecord::Generators::Base, but that inherits from NamedBase, so it expects a name argument
   # which we don't want here. So we redefine it here. Yuck.
   def self.next_migration_number(dirname)
-    if ActiveRecord::Base.timestamped_migrations
-      Time.now.utc.strftime("%Y%m%d%H%M%S%L%N")
-    else
-      "%.3d" % (current_migration_number(dirname) + 1)
-    end
+    next_migration_number = current_migration_number(dirname) + 1
+    ActiveRecord::Migration.next_migration_number(next_migration_number)
   end
 
   protected

data/lib/generators/notify_user/install/templates/create_notify_user_notifications.rb

@@ -6,8 +6,16 @@ class CreateNotifyUserNotifications < ActiveRecord::Migration
       t.string :target_type
       t.json :params
       t.string :state
+      t.datetime :sent_time
+
+      t.integer :group_id
+      t.integer :parent_id
 
       t.timestamps
     end
+
+    add_index :notify_user_notifications, :group_id
+    add_index :notify_user_notifications, :parent_id
+    add_index :notify_user_notifications, :target_id
   end
 end

data/lib/generators/notify_user/install/templates/create_notify_user_unsubscribes.rb

@@ -4,7 +4,12 @@ class CreateNotifyUserUnsubscribes < ActiveRecord::Migration
       t.string :type
       t.integer :target_id
       t.string :target_type
+
+      t.integer :group_id
       t.timestamps
     end
+
+    add_index :notify_user_unsubscribes, :group_id
+    add_index :notify_user_unsubscribes, :target_id
   end
 end

data/lib/generators/notify_user/notification/notification_generator.rb

@@ -12,6 +12,7 @@ module NotifyUser
     def generate_view_scaffolds
       template "email_template.html.erb.erb", "app/views/notify_user/#{name.underscore}/action_mailer/notification.html.erb"
       template "mobile_sdk_template.html.erb.erb", "app/views/notify_user/#{name.underscore}/mobile_sdk/notification.html.erb"
+      template "mobile_sdk_template.html.erb.erb", "app/views/notify_user/#{name.underscore}/mobile_sdk/aggregate_notifications.html.erb"
       template "email_layout_template.html.erb.erb", "app/views/notify_user/layouts/action_mailer.html.erb"
     end
   end

data/lib/notify_user/channels/action_mailer/action_mailer_channel.rb

@@ -11,7 +11,7 @@ class ActionMailerChannel
         description: "Email Notifications"
       }
     end
-    
+
     def deliver(notification, options={})
       NotifyUser::NotificationMailer.notification_email(notification, default_options.deep_merge(options)).deliver
     end

data/lib/notify_user/channels/apns/apns_channel.rb

@@ -1,5 +1,4 @@
 class ApnsChannel
-
   class << self
 
   	def default_options
@@ -9,28 +8,29 @@ class ApnsChannel
   	end
 
     def deliver(notification, options={})
-      case NotifyUser.apns_provider
-      when :houston
-        NotifyUser::Houston.new(notification, options).push
-      when :urban_airship
-        # Check for the existence of development api keys and resend for development:
-        if !ENV['DEV_UA_APPLICATION_KEY'].nil? && !ENV['DEV_UA_APPLICATION_SECRET'].nil? && !ENV['DEV_UA_MASTER_SECRET'].nil?
-
-          Urbanairship.application_key = ENV['DEV_UA_APPLICATION_KEY']
-          Urbanairship.application_secret = ENV['DEV_UA_APPLICATION_SECRET']
-          Urbanairship.master_secret = ENV['DEV_UA_MASTER_SECRET']
-
-          NotifyUser::UrbanAirship.new(notification).push
-
-          # Sets the api keys back to their original state:
-
-          Urbanairship.application_key = ENV['UA_APPLICATION_KEY']
-          Urbanairship.application_secret = ENV['UA_APPLICATION_SECRET']
-          Urbanairship.master_secret = ENV['UA_MASTER_SECRET']
-        end
-      end
+      devices = fetch_devices(notification, options[:device_method])
+
+      NotifyUser::Apns.new([notification], devices[:ios], options).push if devices[:ios].any?
+      NotifyUser::Gcm.new([notification], devices[:android], options).push if devices[:android].any?
     end
 
-  end
+    def deliver_aggregated(notifications, options={})
+      devices = fetch_devices(notifications.first, options[:device_method])
+
+      NotifyUser::Apns.new(notifications, devices[:ios], options).push if devices[:ios].any?
+      NotifyUser::Gcm.new(notifications, devices[:android], options).push if devices[:android].any?
+    end
 
-end
+    private
+
+    def fetch_devices(notification, device_method = nil)
+      device_method ||= :devices
+      devices = notification.target.send(device_method)
+
+      { ios: devices.ios.to_a, android: devices.android.to_a }
+    rescue
+      Rails.logger.info "Notification target, #{notification.target.class}, does not respond to the method, #{device_method}."
+      { ios: [], android: [] }
+    end
+  end
+end

data/lib/notify_user/engine.rb

@@ -1,7 +1,6 @@
 module NotifyUser
   class Engine < ::Rails::Engine
   	require 'active_model_serializers'
-    require 'urbanairship'
 
     config.generators do |g|
       g.test_framework      :rspec,        :fixture => false

data/lib/notify_user/version.rb

@@ -1,3 +1,3 @@
 module NotifyUser
-  VERSION = "0.1.4"
+  VERSION = "0.3.1"
 end

data/spec/controllers/notify_user/notifications_controller_spec.rb

@@ -1,142 +1,164 @@
 require 'spec_helper'
 
+module NotifyUser
+  describe NotificationsController, type: :controller do
+    let(:user) { create(:user) }
 
-describe NotifyUser::NotificationsController do
+    before :each do
+      allow_any_instance_of(NotificationsController).to receive(:current_user).and_return(user)
+      allow_any_instance_of(NotificationsController).to receive(:authenticate_user!).and_return(true)
+    end
 
-  let(:user) { User.create({email: "user@example.com" })}
+    it 'delegates authentication to Devise' do
+      expect(subject).to receive(:authenticate_user!).and_return(true)
+      get :index
+    end
 
-  before :each do
-    NotifyUser::NotificationsController.any_instance.stub(:current_user).and_return(user)
-    NotifyUser::NotificationsController.any_instance.stub(:authenticate_user!).and_return(true)
-  end
+    describe 'GET notifications.json' do
+      render_views
 
-  it "delegates authentication to Devise" do
-    subject.should_receive(:authenticate_user!).and_return(true)
-    subject.stub(:current_user).and_return(user)
-    get :index
-  end
+      let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mr. Blobby') }
 
-  describe "GET notifications.json" do
-    render_views
+      before :each do
+        notification.save
+      end
 
-    let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mr. Blobby") }
+      it 'returns a message from a rendered template' do
+        get :index, format: :json
+        expect(json[:notifications][0][:message]).to include 'New Post Notification happened with'
+        expect(json[:notifications][0][:message]).to include notification.params[:name]
+      end
 
-    before :each do
-      notification.save
-    end
+      it 'returns notification without parent_id set' do
+        get :index, format: :json
+        expect(json[:notifications].count).to eq 1
+      end
 
-    it "returns a message from a rendered template" do
-      get :index, :format => :json
-      json[:notifications][0][:message].should include "New Post Notification happened with"
-      json[:notifications][0][:message].should include notification.params[:name]
-    end
-  end
-
-  describe "GET web Index notifications" do 
-    render_views
+      it "doesn't return notifications with a parent_id set" do
+        NewPostNotification.create(target: user, parent_id: 1)
 
-    let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mr. Blobby") }
-    let(:notification1) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mr. Adams") }
-    let(:notification2) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mrs. James") }
-
-    before :each do
-      notification.save
-      notification1.save
-      notification2.save
+        get :index, format: :json
+        expect(json[:notifications].count).to eq 1
+      end
     end
 
-    it "returns a list of notifications" do
-      NotifyUser::BaseNotification.any_instance.stub(:message).and_return("Mr. Blobby")
-      get :index
-      response.body.should have_content("Mr. Blobby")
-    end
+    describe 'GET web Index notifications' do
+      render_views
 
-    it "reading a notification marks it as read and takes to redirect action" do
-      get :read, :id => notification.id
-      @notification = NotifyUser::BaseNotification.where(id: notification.id).first
-      @notification.state.should eq "read"
-      response.body.should have_content("set redirect logic")
-    end
+      let(:notification)  { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mr. Blobby') }
+      let(:notification1) { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mr. Addams') }
+      let(:notification2) { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mrs. James') }
 
-    it "reading a notification twice doesn't throw an exception" do
-      get :read, :id => notification.id
-      get :read, :id => notification.id
-      
-    end
+      before :each do
+        notification.save
+        notification1.save
+        notification2.save
+      end
 
-    it "marks all unread messages as read" do
-      get :mark_all
-      notifications = NotifyUser::BaseNotification.for_target(user).where('state IN (?)', '["pending","sent"]')
-      notifications.length.should eq 0
-    end
+      it 'returns a list of notifications' do
+        allow_any_instance_of(BaseNotification).to receive(:message).and_return('Mr. Blobby')
+        get :index
+        expect(response.body).to have_content('Mr. Blobby')
+      end
 
-  end
+      it 'reading a notification marks it as read and takes to redirect action' do
+        get :read, id: notification.id
+        @notification = BaseNotification.where(id: notification.id).first
+        expect(@notification.state).to eq 'read'
+        expect(response.body).to have_content('set redirect logic')
+      end
 
-  describe "PUT notifications/mark_read.json" do
-    let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mr. Blobby") }
+      it "reading a notification twice doesn't throw an exception" do
+        expect do
+          get :read, id: notification.id
+          get :read, id: notification.id
+        end.not_to raise_error
+      end
 
-    before :each do
-      notification.save
+      it 'marks all unread messages as read' do
+        get :mark_all
+        notifications = BaseNotification.for_target(user).where('state IN (?)', '["pending","sent"]')
+        expect(notifications.length).to eq 0
+      end
     end
 
-    it "marks notifications as read" do
-      put :mark_read, ids: [notification.id]
-      notification.reload
-      notification.read?.should eq true
-    end
+    describe 'PUT notifications/unsubscribe_from_object' do
+      it 'unsubscribe returns 201' do
+        expect(Unsubscribe).to receive(:unsubscribe)
+        put :unsubscribe_from_object, format: :json, subscription: { type: 'NewPostNotification', group_id: 1, unsubscribe: true }
+        expect(response.response_code).to eq 201
+      end
 
-    it "returns updated notifications" do
-      put :mark_read, ids: [notification.id]
-      json[:notifications][0].should_not be_nil
+      it 'subscribe returns 201' do
+        expect(Unsubscribe).to receive(:subscribe)
+        put :unsubscribe_from_object, format: :json, subscription: { type: 'NewPostNotification', group_id: 1, unsubscribe: false }
+        expect(response.response_code).to eq 201
+      end
     end
-  end
 
-  describe "unsubscribing and subscribing" do
-    let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: "Mr. Blobby") }
+    describe 'PUT notifications/mark_read.json' do
+      let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mr. Blobby') }
 
-    before :each do
-      notification.save
-    end
+      before :each do
+        notification.save
+      end
 
-    it "endpoint for updating notification subscription statuses" do
-      NotifyUser::Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification').should eq []
-      put :subscriptions, :types => [{
-        type: 'NewPostNotification',
-        status: '0'
-        }]
-      NotifyUser::Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification').should_not eq []        
-    end
+      it 'marks notifications as read' do
+        put :mark_read, ids: [notification.id]
+        notification.reload
+        expect(notification.read?).to eq true
+      end
 
-    it "endpoint for updating notification subscription statuses passing 1 does nothing" do
-      NotifyUser::Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification').should eq []
-      put :subscriptions, :types => [{
-        type: 'NewPostNotification',
-        status: '1'
+      it 'returns updated notifications' do
+        put :mark_read, ids: [notification.id]
+        expect(json[:notifications][0]).not_to be_nil
+      end
+    end
+
+    describe 'unsubscribing and subscribing' do
+      let(:notification) { NotifyUser.send_notification('new_post_notification').to(user).with(name: 'Mr. Blobby') }
+
+      before :each do
+        notification.save
+      end
+
+      it 'endpoint for updating notification subscription statuses' do
+        expect(Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification')).to eq []
+        put :subscriptions, types: [{
+          type: 'NewPostNotification',
+          status: '0'
         }]
-      NotifyUser::Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification').should eq []        
-    end
-
-    it "unsubscribing from notification type" do
-      get :unsubscribe, :type => "NewPostNotification"
-      NotifyUser::Unsubscribe.last.type.should eq "NewPostNotification"
-    end
+        expect(Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification')).not_to eq []
+      end
+
+      it 'endpoint for updating notification subscription statuses passing 1 does nothing' do
+        expect(Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification')).to eq []
+        put :subscriptions, types: [{
+          type: 'NewPostNotification',
+          status: '1'
+        }]
+        expect(Unsubscribe.has_unsubscribed_from(user, 'NewPostNotification')).to eq []
+      end
 
-    it "subscribing deletes the unsubscribe object" do
-      #lack of unsubscribe object implies the user is subscribed
-      NotifyUser::Unsubscribe.create(target: user, type: "NewPostNotification")
-      get :subscribe, :type => "NewPostNotification"
-      NotifyUser::Unsubscribe.all.should eq []
+      it 'unsubscribing from notification type' do
+        get :unsubscribe, type: 'NewPostNotification'
+        expect(Unsubscribe.last.type).to eq 'NewPostNotification'
+      end
 
-    end
+      it 'subscribing deletes the unsubscribe object' do
+        # lack of unsubscribe object implies the user is subscribed
+        Unsubscribe.create(target: user, type: 'NewPostNotification')
+        get :subscribe, type: 'NewPostNotification'
+        expect(Unsubscribe.all).to eq []
+      end
 
-    it "verifies user token before unsubscribe then deactivates that token" do
-      user_hash = notification.generate_unsubscribe_hash
-      get :unauth_unsubscribe, :type => "NewPostNotification", :token => user_hash.token
+      it 'verifies user token before unsubscribe then deactivates that token' do
+        user_hash = notification.generate_unsubscribe_hash
+        get :unauth_unsubscribe, type: 'NewPostNotification', token: user_hash.token
 
-      user_hash = NotifyUser::UserHash.last
-      user_hash.active.should eq false
+        user_hash = UserHash.last
+        expect(user_hash.active).to eq false
+      end
     end
-
   end
-
-end
+end