gwong-apn_on_rails 0.4.2

data/lib/apn_on_rails/app/models/apn/pull_notification.rb

@@ -0,0 +1,28 @@
+class APN::PullNotification < APN::Base
+  belongs_to :app, :class_name => 'APN::App'
+  
+  validates_presence_of :app_id
+
+  def self.latest_since(app_id, since_date=nil)
+    if since_date
+      res = first(:order => "created_at DESC", 
+                  :conditions => ["app_id = ? AND created_at > ? AND launch_notification = ?", app_id, since_date, false])
+    else
+      res = first(:order => "created_at DESC", 
+                  :conditions => ["app_id = ? AND launch_notification = ?", app_id, true])
+      res = first(:order => "created_at DESC", 
+                  :conditions => ["app_id = ? AND launch_notification = ?", app_id, false]) unless res
+    end
+    res
+  end
+  
+  def self.all_since(app_id, since_date=nil)
+    if since_date
+      res = all(:order => "created_at DESC", 
+                :conditions => ["app_id = ? AND created_at > ? AND launch_notification = ?", app_id, since_date, false])
+    else 
+      res = all(:order => "created_at DESC", 
+                :conditions => ["app_id = ? AND launch_notification = ?", app_id, false])
+    end
+  end
+end

data/lib/apn_on_rails/libs/connection.rb

@@ -0,0 +1,70 @@
+module APN
+  module Connection
+    
+    class << self
+      
+      # Yields up an SSL socket to write notifications to.
+      # The connections are close automatically.
+      # 
+      #  Example:
+      #   APN::Configuration.open_for_delivery do |conn|
+      #     conn.write('my cool notification')
+      #   end
+      # 
+      # Configuration parameters are:
+      # 
+      #   configatron.apn.passphrase = ''
+      #   configatron.apn.port = 2195
+      #   configatron.apn.host = 'gateway.sandbox.push.apple.com' # Development
+      #   configatron.apn.host = 'gateway.push.apple.com' # Production
+      #   configatron.apn.cert = File.join(rails_root, 'config', 'apple_push_notification_development.pem')) # Development
+      #   configatron.apn.cert = File.join(rails_root, 'config', 'apple_push_notification_production.pem')) # Production
+      def open_for_delivery(options = {}, &block)
+        open(options, &block)
+      end
+      
+      # Yields up an SSL socket to receive feedback from.
+      # The connections are close automatically.
+      # Configuration parameters are:
+      # 
+      #   configatron.apn.feedback.passphrase = ''
+      #   configatron.apn.feedback.port = 2196
+      #   configatron.apn.feedback.host = 'feedback.sandbox.push.apple.com' # Development
+      #   configatron.apn.feedback.host = 'feedback.push.apple.com' # Production
+      #   configatron.apn.feedback.cert = File.join(rails_root, 'config', 'apple_push_notification_development.pem')) # Development
+      #   configatron.apn.feedback.cert = File.join(rails_root, 'config', 'apple_push_notification_production.pem')) # Production
+      def open_for_feedback(options = {}, &block)
+        options = {:cert => configatron.apn.feedback.cert,
+                   :passphrase => configatron.apn.feedback.passphrase,
+                   :host => configatron.apn.feedback.host,
+                   :port => configatron.apn.feedback.port}.merge(options)
+        open(options, &block)
+      end
+      
+      private
+      def open(options = {}, &block) # :nodoc:
+        options = {:cert => configatron.apn.cert,
+                   :passphrase => configatron.apn.passphrase,
+                   :host => configatron.apn.host,
+                   :port => configatron.apn.port}.merge(options)
+        #cert = File.read(options[:cert])
+        cert = options[:cert]
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.key = OpenSSL::PKey::RSA.new(cert, options[:passphrase])
+        ctx.cert = OpenSSL::X509::Certificate.new(cert)
+  
+        sock = TCPSocket.new(options[:host], options[:port])
+        ssl = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+        ssl.sync = true
+        ssl.connect
+  
+        yield ssl, sock if block_given?
+  
+        ssl.close
+        sock.close
+      end
+      
+    end
+    
+  end # Connection
+end # APN

data/lib/apn_on_rails/libs/feedback.rb

@@ -0,0 +1,39 @@
+module APN
+  # Module for talking to the Apple Feedback Service.
+  # The service is meant to let you know when a device is no longer
+  # registered to receive notifications for your application.
+  module Feedback
+    
+    class << self
+      
+      # Returns an Array of APN::Device objects that
+      # has received feedback from Apple. Each APN::Device will
+      # have it's <tt>feedback_at</tt> accessor marked with the time
+      # that Apple believes the device de-registered itself.
+      def devices(cert, &block)
+        devices = []
+        return if cert.nil? 
+        APN::Connection.open_for_feedback({:cert => cert}) do |conn, sock|          
+          while line = conn.read(38)   # Read 38 bytes from the SSL socket
+            feedback = line.unpack('N1n1H140')            
+            token = feedback[2].scan(/.{0,8}/).join(' ').strip
+            device = APN::Device.find(:first, :conditions => {:token => token})
+            if device
+              device.feedback_at = Time.at(feedback[0])
+              devices << device
+            end
+          end
+        end
+        devices.each(&block) if block_given?
+        return devices
+      end # devices
+      
+      def process_devices
+        ActiveSupport::Deprecation.warn("The method APN::Feedback.process_devices is deprecated.  Use APN::App.process_devices instead.")
+        APN::App.process_devices
+      end
+      
+    end # class << self
+    
+  end # Feedback
+end # APN

data/lib/apn_on_rails/tasks/apn.rake

@@ -0,0 +1,30 @@
+namespace :apn do
+  
+  namespace :notifications do
+    
+    desc "Deliver all unsent APN notifications."
+    task :deliver => [:environment] do
+      APN::App.send_notifications
+    end
+
+  end # notifications
+
+  namespace :group_notifications do 
+    
+    desc "Deliver all unsent APN Group notifications."
+    task :deliver => [:environment] do
+      APN::App.send_group_notifications
+    end
+    
+  end # group_notifications
+  
+  namespace :feedback do
+    
+    desc "Process all devices that have feedback from APN."
+    task :process => [:environment] do
+      APN::App.process_devices
+    end
+    
+  end
+  
+end # apn

data/lib/apn_on_rails/tasks/db.rake

@@ -0,0 +1,19 @@
+namespace :apn do
+  
+  namespace :db do
+
+    task :migrate do
+      puts %{
+This task no longer exists. Please generate the migrations like this:
+
+$ ruby script/generate apn_migrations
+
+Then just run the migrations like you would normally:
+
+$ rake db:migrate
+      }.strip
+    end
+    
+  end # db
+  
+end # apn

data/lib/apn_on_rails_tasks.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'apn_on_rails', 'tasks', '**/*.rake')).each do |f|
+  load File.expand_path(f)
+end

data/spec/active_record/setup_ar.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'active_record'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::INFO
+ActiveRecord::Base.logger = logger
+
+db_file = File.join(File.dirname(__FILE__), 'test.db')
+FileUtils.rm(db_file) if File.exists?(db_file)
+# File.open(db_file, 'w')
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3',
+  :database => db_file
+})
+
+ActiveRecord::Migrator.up(File.join(File.dirname(__FILE__), '..', '..', 'generators', 'templates', 'apn_migrations'))
+
+# raise hell

data/spec/apn_on_rails/app/models/apn/app_spec.rb

@@ -0,0 +1,226 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::App do
+
+  describe 'send_notifications' do
+  
+    it 'should send the unsent notifications' do
+    
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      notifications = [NotificationFactory.create({:device_id => device.id}), 
+                       NotificationFactory.create({:device_id => device.id})]
+                       
+     notifications.each_with_index do |notify, i|
+       notify.stub(:message_for_sending).and_return("message-#{i}")
+       notify.should_receive(:sent_at=).with(instance_of(Time))
+       notify.should_receive(:save)
+     end
+      
+      APN::App.should_receive(:all).once.and_return([app])                 
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      
+      APN::Notification.should_receive(:find).and_return(notifications, [])
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      ssl_mock.should_receive(:write).with('message-1')
+      APN::Connection.should_receive(:open_for_delivery).twice.and_yield(ssl_mock, nil)
+      APN::App.send_notifications
+    
+    end
+  
+  end
+  
+  describe 'send_notifications_not_associated_with_an_app' do 
+    
+    it 'should send unsent notifications that are associated with devices that are not with any app' do 
+      RAILS_ENV = 'staging'
+      device = DeviceFactory.create
+      device.app_id = nil
+      device.save
+      APN::App.all.each { |a| a.destroy }
+      notifications = [NotificationFactory.create({:device_id => device.id}), 
+                       NotificationFactory.create({:device_id => device.id})]
+                   
+       notifications.each_with_index do |notify, i|
+         notify.stub(:message_for_sending).and_return("message-#{i}")
+         notify.should_receive(:sent_at=).with(instance_of(Time))
+         notify.should_receive(:save)
+       end  
+   
+       APN::Notification.should_receive(:find).and_return(notifications)
+  
+       ssl_mock = mock('ssl_mock')
+       ssl_mock.should_receive(:write).with('message-0')
+       ssl_mock.should_receive(:write).with('message-1')
+       APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+       APN::App.send_notifications
+    end
+  end               
+  
+  describe 'send_group_notifications' do
+  
+    it 'should send the unsent group notifications' do
+    
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnotys = [GroupNotificationFactory.create({:group_id => group.id}), 
+                GroupNotificationFactory.create({:group_id => group.id})]
+      gnotys.each_with_index do |gnoty, i|
+        gnoty.stub!(:message_for_sending).and_return("message-#{i}")
+        gnoty.should_receive(:sent_at=).with(instance_of(Time))
+        gnoty.should_receive(:save)
+      end
+    
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:unsent_group_notifications).at_least(:once).and_return(gnotys)
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      ssl_mock.should_receive(:write).with('message-1')
+      APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+    
+      APN::App.send_group_notifications
+    
+    end
+  
+  end
+  
+  describe 'send single group notification' do 
+    
+    it 'should send the argument group notification' do 
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnoty = GroupNotificationFactory.create({:group_id => group.id})
+      gnoty.stub!(:message_for_sending).and_return("message-0")
+      gnoty.should_receive(:sent_at=).with(instance_of(Time))
+      gnoty.should_receive(:save)
+    
+      app.should_receive(:cert).at_least(:once).and_return(app.apn_dev_cert)
+      
+      ssl_mock = mock('ssl_mock')
+      ssl_mock.should_receive(:write).with('message-0')
+      APN::Connection.should_receive(:open_for_delivery).and_yield(ssl_mock, nil)
+    
+      app.send_group_notification(gnoty)   
+    end
+    
+  end
+  
+  describe 'nil cert when sending notifications' do 
+    
+    it 'should raise an exception for sending notifications for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.send_notifications
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'nil cert when sending group notifications' do 
+    
+    it 'should raise an exception for sending group notifications for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.send_group_notifications
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'nil cert when sending single group notification' do 
+    
+    it 'should raise an exception for sending group notifications for an app with no cert' do
+      app = AppFactory.create
+      device = DeviceFactory.create({:app_id => app.id})
+      group =   GroupFactory.create({:app_id => app.id})
+      device_grouping = DeviceGroupingFactory.create({:group_id => group.id,:device_id => device.id})
+      gnoty = GroupNotificationFactory.create({:group_id => group.id})
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        app.send_group_notification(gnoty)
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'process_devices' do
+    
+    it 'should destroy devices that have a last_registered_at date that is before the feedback_at date' do
+      app = AppFactory.create
+      devices = [DeviceFactory.create(:app_id => app.id, :last_registered_at => 1.week.ago, :feedback_at => Time.now),
+                 DeviceFactory.create(:app_id => app.id, :last_registered_at => 1.week.from_now, :feedback_at => Time.now)]
+      puts "device ids are #{devices[0].id} and #{devices[1].id}"
+      devices[0].last_registered_at = 1.week.ago
+      devices[0].save
+      devices[1].last_registered_at = 1.week.from_now
+      devices[1].save
+      APN::Feedback.should_receive(:devices).twice.and_return(devices)
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).twice.and_return(app.apn_dev_cert)
+      lambda {
+        APN::App.process_devices
+      }.should change(APN::Device, :count).by(-1)
+    end
+    
+  end
+  
+  describe 'process_devices for global app' do 
+    
+    it 'should destroy devices that have a last_registered_at date that is before the feedback_at date that have no app' do 
+      device = DeviceFactory.create(:app_id => nil, :last_registered_at => 1.week.ago, :feedback_at => Time.now)
+      device.app_id = nil
+      device.last_registered_at = 1.week.ago
+      device.save
+      APN::Feedback.should_receive(:devices).and_return([device])
+      APN::App.should_receive(:all).and_return([])
+      lambda { 
+        APN::App.process_devices
+      }.should change(APN::Device, :count).by(-1)
+    end
+  end
+  
+  describe 'nil cert when processing devices' do 
+    
+    it 'should raise an exception for processing devices for an app with no cert' do
+      app = AppFactory.create
+      APN::App.should_receive(:all).and_return([app])
+      app.should_receive(:cert).and_return(nil)
+      lambda { 
+        APN::App.process_devices
+      }.should raise_error(APN::Errors::MissingCertificateError)
+    end
+    
+  end
+  
+  describe 'cert for production environment' do 
+    
+    it 'should return the production cert for the app' do 
+      app = AppFactory.create
+      RAILS_ENV = 'production'
+      app.cert.should == app.apn_prod_cert
+    end
+    
+  end
+  
+  describe 'cert for development and staging environment' do 
+    
+    it 'should return the development cert for the app' do 
+      app = AppFactory.create
+      RAILS_ENV = 'staging'
+      app.cert.should == app.apn_dev_cert
+    end
+  end
+
+end

data/spec/apn_on_rails/app/models/apn/device_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'spec_helper.rb')
+
+describe APN::Device do
+  
+  describe 'token' do
+    
+    it 'should be unique' do
+      device = DeviceFactory.new(:token => APN::Device.first.token)
+      device.should_not be_valid
+      device.errors['token'].should include('has already been taken')
+      
+      device = DeviceFactory.new(:token => device.token.succ)
+      device.should be_valid
+    end
+    
+    it 'should get cleansed if it contains brackets' do
+      token = DeviceFactory.random_token
+      device = DeviceFactory.new(:token => "<#{token}>")
+      device.token.should == token
+      device.token.should_not == "<#{token}>"
+    end
+    
+    it 'should be in the correct pattern' do
+      device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      device.should be_valid
+      device.token = '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6'
+      device.should_not be_valid
+      device.token = '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7!!'
+      device.should_not be_valid
+    end
+    
+  end
+  
+  describe 'to_hexa' do
+    
+    it 'should convert the text string to hexadecimal' do
+      device = DeviceFactory.new(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
+      device.to_hexa.should == fixture_value('hexa.bin')
+    end
+    
+  end
+  
+  describe 'before_create' do
+    
+    it 'should set the last_registered_at date to Time.now' do
+      time = Time.now
+      Time.stub(:now).and_return(time)
+      device = DeviceFactory.create
+      device.last_registered_at.should_not be_nil
+      device.last_registered_at.to_s.should == time.to_s
+      
+      # ago = 1.week.ago
+      # device = DeviceFactory.create(:last_registered_at => ago)
+      # device.last_registered_at.should_not be_nil
+      # device.last_registered_at.to_s.should == ago.to_s
+    end
+    
+  end
+  
+end