apn_on_rails 0.3.1 → 0.4.0

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

@@ -10,9 +10,11 @@
 #   Device.create(:token => '5gxadhy6 6zmtxfl6 5zpbcxmw ez3w7ksf qscpr55t trknkzap 7yyt45sc g6jrw7qz')
 class APN::Device < APN::Base
   
+  belongs_to :app, :class_name => 'APN::App'
   has_many :notifications, :class_name => 'APN::Notification'
+  has_many :unsent_notifications, :class_name => 'APN::Notification', :conditions => 'sent_at is null'
   
-  validates_uniqueness_of :token
+  validates_uniqueness_of :token, :scope => :app_id
   validates_format_of :token, :with => /^[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}\s[a-z0-9]{8}$/
   
   before_save :set_last_registered_at

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

@@ -0,0 +1,16 @@
+class APN::DeviceGrouping < APN::Base
+  
+  belongs_to :group, :class_name => 'APN::Group'
+  belongs_to :device, :class_name => 'APN::Device'
+  
+  validates_presence_of :device_id, :group_id
+  validate :same_app_id
+  validates_uniqueness_of :device_id, :scope => :group_id
+  
+  def same_app_id
+    unless self.group and self.device and self.group.app_id == self.device.app_id
+       errors.add_to_base("device and group must belong to the same app")
+    end
+  end
+  
+end

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

@@ -0,0 +1,12 @@
+class APN::Group < APN::Base
+  
+  belongs_to :app, :class_name => 'APN::App'
+  has_many   :device_groupings, :class_name => "APN::DeviceGrouping", :dependent => :destroy
+  has_many   :devices, :class_name => 'APN::Device', :through => :device_groupings
+  has_many   :group_notifications, :class_name => 'APN::GroupNotification'
+  has_many   :unsent_group_notifications, :class_name => 'APN::GroupNotification', :conditions => 'sent_at is null'
+  
+  validates_presence_of :app_id
+  validates_uniqueness_of :name, :scope => :app_id
+    
+end

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

@@ -0,0 +1,79 @@
+class APN::GroupNotification < APN::Base
+  include ::ActionView::Helpers::TextHelper
+  extend ::ActionView::Helpers::TextHelper
+  serialize :custom_properties
+  
+  belongs_to :group, :class_name => 'APN::Group'
+  has_one    :app, :class_name => 'APN::App', :through => :group
+  has_many   :device_groupings, :through => :group
+  
+  validates_presence_of :group_id
+  
+  def devices
+    self.group.devices
+  end
+  
+  # Stores the text alert message you want to send to the device.
+  # 
+  # If the message is over 150 characters long it will get truncated
+  # to 150 characters with a <tt>...</tt>
+  def alert=(message)
+    if !message.blank? && message.size > 150
+      message = truncate(message, :length => 150)
+    end
+    write_attribute('alert', message)
+  end
+  
+  # Creates a Hash that will be the payload of an APN.
+  # 
+  # Example:
+  #   apn = APN::GroupNotification.new
+  #   apn.badge = 5
+  #   apn.sound = 'my_sound.aiff'
+  #   apn.alert = 'Hello!'
+  #   apn.apple_hash # => {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"}}
+  #
+  # Example 2: 
+  #   apn = APN::GroupNotification.new
+  #   apn.badge = 0
+  #   apn.sound = true
+  #   apn.custom_properties = {"typ" => 1}
+  #   apn.apple_hash # => {"aps" => {"badge" => 0, "sound" => 1.aiff},"typ" => "1"}
+  def apple_hash
+    result = {}
+    result['aps'] = {}
+    result['aps']['alert'] = self.alert if self.alert
+    result['aps']['badge'] = self.badge.to_i if self.badge
+    if self.sound
+      result['aps']['sound'] = self.sound if self.sound.is_a? String
+      result['aps']['sound'] = "1.aiff" if self.sound.is_a?(TrueClass)
+    end
+    if self.custom_properties
+      self.custom_properties.each do |key,value|
+        result["#{key}"] = "#{value}"
+      end
+    end
+    result
+  end
+  
+  # Creates the JSON string required for an APN message.
+  # 
+  # Example:
+  #   apn = APN::Notification.new
+  #   apn.badge = 5
+  #   apn.sound = 'my_sound.aiff'
+  #   apn.alert = 'Hello!'
+  #   apn.to_apple_json # => '{"aps":{"badge":5,"sound":"my_sound.aiff","alert":"Hello!"}}'
+  def to_apple_json
+    self.apple_hash.to_json
+  end
+  
+  # Creates the binary message needed to send to Apple.
+  def message_for_sending(device)
+    json = self.to_apple_json
+    message = "\0\0 #{device.to_hexa}\0#{json.length.chr}#{json}"
+    raise APN::Errors::ExceededMessageSizeError.new(message) if message.size.to_i > 256
+    message
+  end
+  
+end # APN::Notification

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

@@ -20,6 +20,7 @@ class APN::Notification < APN::Base
   serialize :custom_properties
   
   belongs_to :device, :class_name => 'APN::Device'
+  has_one    :app,    :class_name => 'APN::App', :through => :device
   
   # Stores the text alert message you want to send to the device.
   # 
@@ -46,7 +47,7 @@ class APN::Notification < APN::Base
   #   apn.badge = 0
   #   apn.sound = true
   #   apn.custom_properties = {"typ" => 1}
-  #   apn.apple_hast # => {"aps" => {"badge" => 0}}
+  #   apn.apple_hash # => {"aps" => {"badge" => 0, "sound" => "1.aiff"}, "typ" => "1"}
   def apple_hash
     result = {}
     result['aps'] = {}
@@ -84,34 +85,9 @@ class APN::Notification < APN::Base
     message
   end
   
-  class << self
-    
-    # Opens a connection to the Apple APN server and attempts to batch deliver
-    # an Array of notifications.
-    # 
-    # This method expects an Array of APN::Notifications. If no parameter is passed
-    # in then it will use the following:
-    #   APN::Notification.all(:conditions => {:sent_at => nil})
-    # 
-    # As each APN::Notification is sent the <tt>sent_at</tt> column will be timestamped,
-    # so as to not be sent again.
-    # 
-    # This can be run from the following Rake task:
-    #   $ rake apn:notifications:deliver
-    def send_notifications(notifications = APN::Notification.all(:conditions => {:sent_at => nil}))
-      unless notifications.nil? || notifications.empty?
-
-        APN::Connection.open_for_delivery do |conn, sock|
-          notifications.each do |noty|
-            conn.write(noty.message_for_sending)
-            noty.sent_at = Time.now
-            noty.save
-          end
-        end
-
-      end
-    end
-    
-  end # class << self
+  def self.send_notifications
+    ActiveSupport::Deprecation.warn("The method APN::Notification.send_notifications is deprecated.  Use APN::App.send_notifications instead.")
+    APN::App.send_notifications
+  end
   
 end # APN::Notification

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

@@ -0,0 +1,15 @@
+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)
+    conditions = if since_date
+                   ["app_id = ? AND created_at > ?", app_id, since_date]
+                 else
+                   ["app_id = ?", app_id]
+                 end
+
+    first(:order => "created_at DESC", :conditions => conditions)
+  end
+end

data/lib/apn_on_rails/libs/connection.rb

@@ -47,7 +47,8 @@ module APN
                    :passphrase => configatron.apn.passphrase,
                    :host => configatron.apn.host,
                    :port => configatron.apn.port}.merge(options)
-        cert = File.read(options[:cert])
+        #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)

data/lib/apn_on_rails/libs/feedback.rb

@@ -10,9 +10,10 @@ module APN
       # 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(&block)
+      def devices(cert, &block)
         devices = []
-        APN::Connection.open_for_feedback do |conn, sock|
+        return if cert.nil? 
+        APN::Connection.open_for_feedback({:cert => cert}) do |conn, sock|
           while line = sock.gets   # Read lines from the socket
             line.strip!
             feedback = line.unpack('N1n1H140')
@@ -28,23 +29,10 @@ module APN
         return devices
       end # devices
       
-      # Retrieves a list of APN::Device instnces from Apple using
-      # the <tt>devices</tt> method. It then checks to see if the
-      # <tt>last_registered_at</tt> date of each APN::Device is
-      # before the date that Apple says the device is no longer
-      # accepting notifications then the device is deleted. Otherwise
-      # it is assumed that the application has been re-installed
-      # and is available for notifications.
-      # 
-      # This can be run from the following Rake task:
-      #   $ rake apn:feedback:process
       def process_devices
-        APN::Feedback.devices.each do |device|
-          if device.last_registered_at < device.feedback_at
-            device.destroy
-          end
-        end
-      end # 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
     

data/lib/apn_on_rails/tasks/apn.rake

@@ -4,18 +4,27 @@ namespace :apn do
     
     desc "Deliver all unsent APN notifications."
     task :deliver => [:environment] do
-      APN::Notification.send_notifications
+      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::Feedback.process_devices
+      APN::App.process_devices
     end
     
   end
   
-end # apn
+end # apn

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,178 @@
+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).and_return([app])
+      app.should_receive(:unsent_notifications).at_least(:once).and_return(notifications)
+      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_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)]
+      APN::Feedback.should_receive(:devices).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 '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