notify_user 0.0.28 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d4645847e57a969014f6204305bc9200ea3d241
-  data.tar.gz: 76db4f9e709b85a4b9e9b6d6f0a4abd23565236c
+  metadata.gz: 0a577a48ef571d2031ff5df80e68446265b7c4f1
+  data.tar.gz: 007bc887cd900949443af637df989638d61b46ae
 SHA512:
-  metadata.gz: 0392478ef4fe31df0bfbbaa0b2152145c5cef77d1a27c67e5ee01f781d7a479658b270894647c894e950bf5a96094e35c5afae95a14df9ff3cf5d0d5c1f12062
-  data.tar.gz: ee37e8bc234d00045eb7b75a49d575280dfd7d8ee8a28cd95bf8fa6e8eb6ffe972529182cac71b2e463eb10d539cfa7c76abb6f4b19f8356ceed75eccee43340
+  metadata.gz: 1e8be63dd0b8d2fa14de7ccbfbe7a927b521b3d086ff9ef344116b48170c6e68e37d9bfae0fbe95d01061d9f698c5e88fb06f6d1543ce9e2a0b2ecefb8777058
+  data.tar.gz: 0e98eb7957dd725d95d8750429cd06bf38f01a4d558adcdbcab02265768124b8cfe93028b581de64e551e2c13c9dedde4772f1f19bce19c0e04f8ec662fbfd12

data/README.md

@@ -22,6 +22,15 @@ Then send:
 ```
 NotifyUser.send_notification('new_my_property').to(user).with("listing_address" => "123 Main St").notify
 ```
+Dynamic email titles use %{tags} that correspond to your params hash (Will throw an exception if key is missing)
+```
+channel :action_mailer,
+      subject: "%{name} sent you a message",
+      aggregate: {
+        subject: "%{name} sent you %{count} messages"
+      }
+```
+
 
 To enable APNS add this line to your app/notification/notification_type.rb
 ```

data/app/mailers/notify_user/notification_mailer.rb

@@ -8,7 +8,7 @@ module NotifyUser
       @notification = notification
 
       mail to: notification.target.email,
-           subject: options[:subject],
+           subject: subject(notification, options[:subject]),
            template_name: "notification",
            template_path: "notify_user/action_mailer",
            from: NotifyUser.mailer_sender
@@ -21,10 +21,14 @@ module NotifyUser
       mail to: @notifications.first.target.email,
            template_name: "aggregate_notification",
            template_path: ["notify_user/#{notifications.first.class.name.underscore}/action_mailer", "notify_user/action_mailer"],
-           subject: options[:aggregate][:subject],
+           subject: subject(@notification, options[:aggregate][:subject]),
            from: NotifyUser.mailer_sender
     end
 
+    def subject(notification, subject)
+      subject % notification.params.symbolize_keys
+    end
+
     protected
   end
 end

data/app/models/notify_user/apn_connection.rb

@@ -0,0 +1,41 @@
+module NotifyUser
+  class APNConnection
+
+    attr_accessor :connection
+
+    def initialize
+      setup
+    end
+
+    def setup
+      @uri, @certificate = if Rails.env.production? || apn_environment == :production
+        [
+          ::Houston::APPLE_PRODUCTION_GATEWAY_URI,
+          File.read("#{Rails.root}/config/keys/production_push.pem")
+        ]
+      else
+        [
+          ::Houston::APPLE_DEVELOPMENT_GATEWAY_URI,
+          File.read("#{Rails.root}/config/keys/development_push.pem")
+        ]
+      end
+
+      @connection = ::Houston::Connection.new(@uri, @certificate, nil)
+      @connection.open
+    end
+
+    def write(data)
+      raise "Connection is closed" unless @connection.open?
+      @connection.write(data)
+    end
+
+    private
+
+    def apn_environment
+      return nil unless ENV['APN_ENVIRONMENT']
+
+      ENV['APN_ENVIRONMENT'].downcase.to_sym
+    end
+
+  end
+end

data/app/models/notify_user/apns.rb

@@ -1,37 +1,28 @@
 module NotifyUser
   class Apns
-    SYMBOL_NAMES_SIZE = 10 
+    SYMBOL_NAMES_SIZE = 10
     PAYLOAD_LIMIT = 255
 
-    #sends push notification
-    def self.push_notification(notification)
-      #calculates the bytes already used 
-      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]               
+    def initialize(notification, options)
+      @notification = notification
+      @options = options
+    end
+
+    # Sends push notification:
+    def push
+      raise "Base APNS class should not be used."
+    end
+
+    private
 
-      space_allowance = PAYLOAD_LIMIT - used_space   
+    # 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
 
-      payload = {
-        :alias => notification.target_id,
-        :aps => {alert: notification.mobile_message(space_allowance), badge: notification.count_for_target},
-        :n_data => {
-          '#' => notification.id,     
-          t: notification.created_at.to_time.to_i, 
-          '?' => notification.type
-        }
-      }
-      payload[:n_data]['!'] = notification.params[:action_id] if notification.params[:action_id]
+      used_space += @notification.params[:action_id].size if @notification.params[:action_id]
 
-      response = Urbanairship.push(payload)
-        if response.success?
-          Rails.logger.info "Push notification sent successfully."
-          return true
-        else
-          Rails.logger.info "Push notification failed."
-          return false
-        end    
+      used_space
     end
   end
 end

data/app/models/notify_user/base_notification.rb

@@ -7,6 +7,9 @@ module NotifyUser
     include ActionView::Helpers::TextHelper
     include AASM
 
+    after_commit :deliver!, on: :create
+    after_commit :deliver, on: :create
+
     if ActiveRecord::VERSION::MAJOR < 4
       attr_accessible :params, :target, :type, :state
     end
@@ -32,6 +35,9 @@ module NotifyUser
       # Created, not sent yet. Possibly waiting for aggregation.
       state :pending, initial: true
 
+      # Delivers without aggregation
+      state :pending_no_aggregation
+
       # Email/SMS/APNS has been sent.
       state :sent
 
@@ -40,7 +46,11 @@ module NotifyUser
 
       # Record that we have sent message(s) to the user about this notification.
       event :mark_as_sent do
-        transitions from: :pending, to: :sent
+        transitions from: [:pending, :pending_no_aggregation], to: :sent
+      end
+
+      event :dont_aggregate do
+        transitions from: :pending, to: :pending_no_aggregation
       end
 
       # Record that the user has seen this notification, usually on a page or in the app.
@@ -59,6 +69,7 @@ module NotifyUser
       end
     end
 
+    # returns the global unread notification count for a user
     def count_for_target
       NotifyUser::BaseNotification.for_target(target).where('state IN (?)', ["sent", "pending"]).count
     end
@@ -92,30 +103,14 @@ module NotifyUser
     end
 
     def notify!
-      save
-
       # Bang version of 'notify' ignores aggregation
-      self.deliver!
+      dont_aggregate!
     end
 
     # Send any Emails/SMS/APNS
     def notify
-
-      if save
-
-        #if aggregation is false bypass aggregation completely
-        self.channels.each do |channel_name, options|
-          if(options[:aggregate_per] == false)
-            self.class.delay.deliver_notification_channel(self.id, channel_name)    
-          else
-            if not aggregation_pending?
-              self.class.delay_for(options[:aggregate_per] || self.aggregate_per).notify_aggregated_channel(self.id, channel_name)
-            end
-          end
-        end
-
-      end
-
+      # Sends with aggregation if enabled
+      save
     end
 
     def generate_unsubscribe_hash
@@ -172,32 +167,37 @@ module NotifyUser
       return (self.class.pending_aggregation_with(self).where('id != ?', id).count > 0)
     end
 
-    # def deliver
-    #   unless user_has_unsubscribed?
-    #     self.mark_as_sent
-    #     self.save
+    # Aggregates appropriately
+    def deliver
+      if pending? and not user_has_unsubscribed?
+        self.mark_as_sent!
 
-    #     self.class.delay.deliver_channels(self.id)
-    #   end
-    # end
+        # if aggregation is false bypass aggregation completely
+        self.channels.each do |channel_name, options|
+          if(options[:aggregate_per] == false)
+            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)
+            end
+          end
+        end
+      end
+    end
 
+    # Sends immediately and without aggregation 
     def deliver!
-      unless user_has_unsubscribed?
-        self.mark_as_sent
-        self.save
+      if pending_no_aggregation? and not user_has_unsubscribed?
+        self.mark_as_sent!
         self.class.deliver_channels(self.id)
       end
     end
 
     # Deliver a single notification across each channel.
     def self.deliver_channels(notification_id)
-      notification = self.where(id: notification_id).first
-      return unless notification
       self.channels.each do |channel_name, options|
-        unless unsubscribed_from_channel?(notification.target, channel_name)
-          channel = (channel_name.to_s + "_channel").camelize.constantize
-          channel.deliver(notification, options)
-        end
+        self.deliver_notification_channel(notification_id, channel_name)
       end
     end
 
@@ -215,11 +215,11 @@ module NotifyUser
 
     # Deliver a single notification to a specific channel.
     def self.deliver_notification_channel(notification_id, channel_name)
-      notification = self.where(id: notification_id).first
-      return unless notification
-      channel_options = channels[channel_name.to_sym]
+      notification = self.find(notification_id) # Raise an exception if not found.
 
+      channel_options = channels[channel_name.to_sym]
       channel = (channel_name.to_s + "_channel").camelize.constantize
+
       unless self.unsubscribed_from_channel?(notification.target, channel_name)
         channel.deliver(notification, channel_options)
       end
@@ -236,7 +236,7 @@ module NotifyUser
       end
     end
 
-    #notifies a single channel for aggregation
+    # Prepares a single channel for aggregation
     def self.notify_aggregated_channel(notification_id, channel_name)
       notification = self.find(notification_id) # Raise an exception if not found.
 
@@ -247,7 +247,6 @@ module NotifyUser
       notifications.map(&:save)
 
       return if 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,27 +256,8 @@ module NotifyUser
       end
     end
 
-    def self.notify_aggregated(notification_id)
-      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)
-      
-      notifications.map(&:mark_as_sent)
-      notifications.map(&:save)
-
-      return if notifications.empty?
-
-      if notifications.length == 1
-        # Despite waiting for more to aggregate, we only got one in the end.
-        self.deliver_channels(notifications.first.id)
-      else
-        # We got several notifications while waiting, send them aggregated.
-        self.deliver_channels_aggregated(notifications)
-      end
-    end
-
     private
+    
     def unsubscribed_validation
       errors.add(:target, (" has unsubscribed from this type")) if user_has_unsubscribed?   
     end
@@ -291,9 +271,7 @@ module NotifyUser
  
     def self.unsubscribed_from_channel?(user, type)
       #return true if user has unsubscribed 
-      return true unless NotifyUser::Unsubscribe.has_unsubscribed_from(user, type).empty?  
-
-      return false 
+      return !NotifyUser::Unsubscribe.has_unsubscribed_from(user, type).empty?   
     end
 
 

data/app/models/notify_user/houston.rb

@@ -0,0 +1,98 @@
+require_relative 'apn_connection'
+require 'houston'
+
+module NotifyUser
+  class Houston < Apns
+
+    NO_ERROR = -42
+    INVALID_TOKEN_ERROR = 8
+    APN_POOL = ConnectionPool.new(
+      size: NotifyUser.connection_pool_size,
+      timeout: NotifyUser.connection_pool_timeout) do
+      APNConnection.new
+    end
+
+    attr_accessor :push_options
+
+    def initialize(notification, options)
+      super(notification, options)
+
+      @push_options = setup_options
+
+      device_method = @options[:device_method] || :devices
+      begin
+        @devices = @notification.target.send(device_method)
+      rescue
+        Rails.logger.info "Notification target, #{@notification.target.class}, does not respond to the method, #{device_method}."
+      end
+    end
+
+    def push
+      send_notifications
+    end
+
+    private
+
+    def setup_options
+      space_allowance = PAYLOAD_LIMIT - used_space
+
+      push_options = {
+        alert: @notification.mobile_message(space_allowance),
+        badge: @notification.count_for_target,
+        category: @notification.params[:category] || @notification.type,
+        custom_data: @notification.params,
+        sound: 'default'
+      }
+
+      if @options[:silent]
+        push_options.merge!({
+          sound: '',
+          content_available: true
+        })
+      end
+
+      push_options
+    end
+
+    def send_notifications
+      APN_POOL.with do |connection|
+        if !connection.connection.open?
+          connection = APNConnection.new
+        end
+
+        ssl = connection.connection.ssl
+        error_index = NO_ERROR
+
+        @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
+
+        read_socket, write_socket = IO.select([ssl], [], [ssl], 1)
+        if (read_socket && read_socket[0])
+          if error = connection.connection.read(6)
+            command, status, error_index = error.unpack("ccN")
+
+            # 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)
+              Rails.logger.info "Error: #{status} with id: #{error_index}. Token: #{device.token}."
+
+              # If we encounter the Invalid Token error from APNS, just remove the device:
+              if status == ERROR_INVALID_TOKEN
+                Rails.logger.info "Invalid token encountered, removing device. Token: #{device.token}."
+                device.destroy
+              end
+
+              @devices.slice!(0..error_index)
+              connection.connection.close
+            end
+          end
+        end
+
+        # Resend all notifications after the once that produced the error:
+        send_notifications if error_index != NO_ERROR
+      end
+    end
+  end
+end

data/app/models/notify_user/urban_airship.rb

@@ -0,0 +1,33 @@
+module NotifyUser
+  class UrbanAirship < Apns
+
+    def push
+      space_allowance = PAYLOAD_LIMIT - used_space
+
+      payload = {
+        :alias  => notification.target_id,
+        :aps    => {
+          :alert => notification.mobile_message(space_allowance),
+          :badge => notification.count_for_target
+        },
+        :n_data => {
+          '#' => notification.id,
+          :t  => notification.created_at.to_time.to_i,
+          '?' => notification.type
+        }
+      }
+
+      payload[:n_data]['!'] = notification.params[:action_id] if notification.params[:action_id]
+
+      response = Urbanairship.push(payload)
+      if response.success?
+        Rails.logger.info "Push notification sent successfully."
+        return true
+      else
+        Rails.logger.info "Push notification failed."
+        return false
+      end
+    end
+
+  end
+end