fcm-ruby-push-notifications 1.2.0

data/lib/ruby-push-notifications/mpns/mpns_pusher.rb

@@ -0,0 +1,33 @@
+
+module RubyPushNotifications
+  module MPNS
+
+    # This class is responsible for sending notifications to the MPNS service.
+    #
+    class MPNSPusher
+
+      # Initializes the MPNSPusher
+      #
+      # @param certificate [String]. The PEM encoded MPNS certificate.
+      # @param options [Hash] optional. Options for GCMPusher. Currently supports:
+      #   * open_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      #   * read_timeout [Integer]: Number of seconds to wait for one block to be read. Defaults to 30.
+      # (http://msdn.microsoft.com/pt-br/library/windows/apps/ff941099)
+      def initialize(certificate = nil, options = {})
+        @certificate = certificate
+        @options = options
+      end
+
+      # Actually pushes the given notifications.
+      # Assigns every notification an array with the result of each
+      # individual notification.
+      #
+      # @param notifications [Array]. Array of MPNSNotification to send.
+      def push(notifications)
+        notifications.each do |notif|
+          notif.results = MPNSConnection.post notif, @certificate, @options
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/mpns/mpns_response.rb

@@ -0,0 +1,82 @@
+
+module RubyPushNotifications
+  module MPNS
+
+    # This class encapsulates a response received from the MPNS service
+    # and helps parsing and understanding the received messages/codes.
+    #
+    class MPNSResponse
+
+      # @return [Integer] the number of successfully sent notifications
+      attr_reader :success
+
+      # @return [Integer] the number of failed notifications
+      attr_reader :failed
+
+      # @return [Array] Array of a MPNSResult for every receiver of the notification
+      #   sent indicating the result of the operation.
+      attr_reader :results
+      alias_method :individual_results, :results
+
+      # Initializes the MPNSResponse and runs response parsing
+      #
+      # @param responses [Array]. Array with device_urls and http responses
+      def initialize(responses)
+        parse_response responses
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSResponse) &&
+          success == other.success &&
+          failed == other.failed &&
+          results == other.results) || super(other)
+      end
+
+      private
+
+      # Parses the response extracting counts for successful, failed messages.
+      # Also creates the results array assigning a MPNSResult subclass for each
+      # device URL the notification was sent to.
+      #
+      # @param responses [Array]. Array of hash responses
+      def parse_response(responses)
+        @success = responses.count { |response| response[:code] == 200 }
+        @failed = responses.count { |response| response[:code] != 200 }
+        @results = responses.map do |response|
+          mpns_result_for response[:code],
+                          response[:device_url],
+                          response[:headers]
+        end
+      end
+
+      # Factory method that, for each MPNS result object assigns a MPNSResult
+      # subclass.
+      #
+      # @param code [Integer]. The HTTP status code received
+      # @param device_url [String]. The receiver's MPNS device url.
+      # @param headers [Hash]. The HTTP headers received.
+      # @return [MPNSResult]. Corresponding MPNSResult subclass
+      def mpns_result_for(code, device_url, headers)
+        case code
+        when 200
+          MPNSResultOK.new device_url, headers
+        when 400
+          MalformedMPNSResultError.new device_url
+        when 401
+          MPNSAuthError.new device_url
+        when 404
+          MPNSInvalidError.new device_url, headers
+        when 406
+          MPNSLimitError.new device_url, headers
+        when 412
+          MPNSPreConditionError.new device_url, headers
+        when 500..599
+          MPNSInternalError.new device_url
+        else
+          MPNSResultError.new device_url
+        end
+      end
+
+    end
+  end
+end

data/lib/ruby-push-notifications/mpns/mpns_result.rb

@@ -0,0 +1,182 @@
+
+module RubyPushNotifications
+  module MPNS
+    # Class that encapsulates the result of a single sent notification to a single
+    # Device URL
+    # (https://msdn.microsoft.com/en-us/library/windows/apps/ff941100%28v=vs.105%29.aspx)
+    class MPNSResult
+      # @return [String]. Receiver MPNS device URL.
+      attr_accessor :device_url
+
+      # @private X-NotificationStatus HTTP Header string
+      X_NOTIFICATION_STATUS  = 'x-notificationstatus'
+
+      # @private X-DeviceConnectionStatus HTTP Header string
+      X_DEVICE_CONNECTION_STATUS  = 'x-deviceconnectionstatus'
+
+      # @private X-SubscriptionStatus HTTP Header string
+      X_SUBSCRIPTION_STATUS  = 'x-subscriptionstatus'
+
+    end
+
+    # Indicates that the notification was successfully sent to the corresponding
+    # device URL
+    class MPNSResultOK < MPNSResult
+      # @return [String]. The status of the notification received
+      # by the Microsoft Push Notification Service.
+      attr_accessor :notification_status
+
+      # @return [String]. The connection status of the device.
+      attr_accessor :device_connection_status
+
+      # @return [String]. The subscription status.
+      attr_accessor :subscription_status
+
+      def initialize(device_url, headers)
+        @device_url = device_url
+        @notification_status = headers[X_NOTIFICATION_STATUS]
+        @device_connection_status = headers[X_DEVICE_CONNECTION_STATUS]
+        @subscription_status = headers[X_SUBSCRIPTION_STATUS]
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSResultOK) &&
+          device_url == other.device_url &&
+          notification_status == other.notification_status &&
+          device_connection_status == other.device_connection_status &&
+          subscription_status == other.subscription_status) || super(other)
+      end
+    end
+
+    # This error occurs when the cloud service sends a notification
+    # request with a bad XML document or malformed notification URI.
+    class MalformedMPNSResultError < MPNSResult
+      def initialize(device_url)
+        @device_url = device_url
+      end
+
+      def ==(other)
+        (other.is_a?(MalformedMPNSResultError) &&
+          device_url == other.device_url) || super(other)
+      end
+    end
+
+    # Sending this notification is unauthorized.
+    class MPNSAuthError < MPNSResult
+      def initialize(device_url)
+        @device_url = device_url
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSAuthError) &&
+          device_url == other.device_url) || super(other)
+      end
+    end
+
+    # The subscription is invalid and is not present on the Push Notification Service.
+    class MPNSInvalidError < MPNSResult
+      # @return [String]. The status of the notification received
+      # by the Microsoft Push Notification Service.
+      attr_accessor :notification_status
+
+      # @return [String]. The connection status of the device.
+      attr_accessor :device_connection_status
+
+      # @return [String]. The subscription status.
+      attr_accessor :subscription_status
+
+      def initialize(device_url, headers)
+        @device_url = device_url
+        @notification_status = headers[X_NOTIFICATION_STATUS]
+        @device_connection_status = headers[X_DEVICE_CONNECTION_STATUS]
+        @subscription_status = headers[X_SUBSCRIPTION_STATUS]
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSInvalidError) &&
+          device_url == other.device_url &&
+          notification_status == other.notification_status &&
+          device_connection_status == other.device_connection_status &&
+          subscription_status == other.subscription_status) || super(other)
+      end
+    end
+
+    # This error occurs when an unauthenticated cloud service has reached
+    # the per-day throttling limit for a subscription,
+    # or when a cloud service (authenticated or unauthenticated)
+    # has sent too many notifications per second.
+    class MPNSLimitError < MPNSResult
+      # @return [String]. The status of the notification received
+      # by the Microsoft Push Notification Service.
+      attr_accessor :notification_status
+
+      # @return [String]. The connection status of the device.
+      attr_accessor :device_connection_status
+
+      # @return [String]. The subscription status.
+      attr_accessor :subscription_status
+
+      def initialize(device_url, headers)
+        @device_url = device_url
+        @notification_status = headers[X_NOTIFICATION_STATUS]
+        @device_connection_status = headers[X_DEVICE_CONNECTION_STATUS]
+        @subscription_status = headers[X_SUBSCRIPTION_STATUS]
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSLimitError) &&
+          device_url == other.device_url &&
+          notification_status == other.notification_status &&
+          device_connection_status == other.device_connection_status &&
+          subscription_status == other.subscription_status) || super(other)
+      end
+    end
+
+    # The device is in a disconnected state.
+    class MPNSPreConditionError < MPNSResult
+      # @return [String]. The status of the notification received
+      # by the Microsoft Push Notification Service.
+      attr_accessor :notification_status
+
+      # @return [String]. The connection status of the device.
+      attr_accessor :device_connection_status
+
+      def initialize(device_url, headers)
+        @device_url = device_url
+        @notification_status = headers[X_NOTIFICATION_STATUS]
+        @device_connection_status = headers[X_DEVICE_CONNECTION_STATUS]
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSPreConditionError) &&
+          device_url == other.device_url &&
+          notification_status == other.notification_status &&
+          device_connection_status == other.device_connection_status) || super(other)
+      end
+    end
+
+    # The Push Notification Service is unable to process the request.
+    class MPNSInternalError < MPNSResult
+      def initialize(device_url)
+        @device_url = device_url
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSInternalError) &&
+          device_url == other.device_url) || super(other)
+      end
+    end
+
+    # Unknow Error
+    class MPNSResultError < MPNSResult
+      def initialize(device_url)
+        @device_url = device_url
+      end
+
+      def ==(other)
+        (other.is_a?(MPNSResultError) &&
+          device_url == other.device_url) || super(other)
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/notification_results_manager.rb

@@ -0,0 +1,14 @@
+module RubyPushNotifications
+  # This module contains the required behavior expected by particular notifications
+  #
+  # @author Carlos Alonso
+  module NotificationResultsManager
+    extend Forwardable
+
+    def_delegators :@results, :success, :failed, :individual_results
+
+    # The corresponding object with the results from sending this notification
+    # that also will respond to #success, #failed and #individual_results
+    attr_accessor :results
+  end
+end

data/lib/ruby-push-notifications/wns.rb

@@ -0,0 +1,6 @@
+require 'ruby-push-notifications/wns/wns_access'
+require 'ruby-push-notifications/wns/wns_connection'
+require 'ruby-push-notifications/wns/wns_notification'
+require 'ruby-push-notifications/wns/wns_pusher'
+require 'ruby-push-notifications/wns/wns_result'
+require 'ruby-push-notifications/wns/wns_response'

data/lib/ruby-push-notifications/wns/wns_access.rb

@@ -0,0 +1,82 @@
+require 'uri'
+require 'net/https'
+require 'json'
+require 'ostruct'
+
+module RubyPushNotifications
+  module WNS
+    # This class is responsible for get access auth token for sending pushes
+    #
+    class WNSAccess
+
+      # This class is responsible for structurize response from login WNS service
+      #
+      class Response
+        # @return [OpenStruct]. Return structurized response
+        attr_reader :response
+
+        def initialize(response)
+          @response = structurize(response)
+        end
+
+        private
+
+        def structurize(response)
+          body = response.body.to_s.empty? ? {} : JSON.parse(response.body)
+          OpenStruct.new(
+            status_code: response.code.to_i,
+            status: response.message,
+            error: body['error'],
+            error_description: body['error_description'],
+            access_token: body['access_token'],
+            token_ttl: body['expires_in']
+          )
+        end
+      end
+
+      # @private Grant type for getting access token
+      GRANT_TYPE = 'client_credentials'.freeze
+
+      # @private Scope for getting access token
+      SCOPE = 'notify.windows.com'.freeze
+
+      # @private Url for getting access token
+      ACCESS_TOKEN_URL = 'https://login.live.com/accesstoken.srf'.freeze
+
+      # @return [String]. Sid
+      attr_reader :sid
+
+      # @return [String]. Secret token
+      attr_reader :secret
+
+      # @param type [String]. Sid
+      # @param type [String]. Secret
+      #
+      # You can get it on https://account.live.com/developers/applications/index
+      def initialize(sid, secret)
+        @sid = sid
+        @secret = secret
+      end
+
+      # Get access auth token for sending pushes
+      #
+      # https://docs.microsoft.com/en-us/windows/uwp/controls-and-patterns/tiles-and-notifications-windows-push-notification-services--wns--overview
+      def get_token
+        body = {
+          grant_type: GRANT_TYPE,
+          client_id: sid,
+          client_secret: secret,
+          scope: SCOPE
+        }
+
+        url = URI.parse ACCESS_TOKEN_URL
+        http = Net::HTTP.new url.host, url.port
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        response = http.post url.request_uri, URI.encode_www_form(body)
+
+        Response.new response
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/wns/wns_connection.rb

@@ -0,0 +1,97 @@
+require 'uri'
+require 'net/https'
+
+module RubyPushNotifications
+  module WNS
+    # Encapsulates a connection to the WNS service
+    # Responsible for final connection with the service.
+    #
+    class WNSConnection
+      # @private Content-Type HTTP Header type string
+      CONTENT_TYPE_HEADER  = 'Content-Type'.freeze
+
+      # @private Content-Length HTTP Header type string
+      CONTENT_LENGTH_HEADER  = 'Content-Length'.freeze
+
+      # @private WNS type string
+      X_WNS_TYPE_HEADER = 'X-WNS-Type'.freeze
+
+      # @private Authorization string
+      AUTHORIZATION_HEADER = 'Authorization'.freeze
+
+      # @private Request for status type boolean
+      REQUEST_FOR_STATUS_HEADER = 'X-WNS-RequestForStatus'.freeze
+
+      # @private Content-Type type string
+      CONTENT_TYPE = {
+        badge: 'text/xml',
+        toast: 'text/xml',
+        tile: 'text/xml',
+        raw: 'application/octet-stream'
+      }.freeze
+
+      # @private Windows Phone Target Types
+      WP_TARGETS = {
+        badge: 'wns/badge',
+        toast: 'wns/toast',
+        tile: 'wns/tile',
+        raw: 'wns/raw'
+      }.freeze
+
+      # Issues a POST request to the WNS send endpoint to
+      # submit the given notifications.
+      #
+      # @param notifications [WNSNotification]. The notifications object to POST
+      # @param access_token [String] required. Access token for send push
+      # @param options [Hash] optional. Options for GCMPusher. Currently supports:
+      #   * open_timeout [Integer]: Number of seconds to wait for the connection to open. Defaults to 30.
+      #   * read_timeout [Integer]: Number of seconds to wait for one block to be read. Defaults to 30.
+      # @return [Array]. The response of post
+      # (http://msdn.microsoft.com/pt-br/library/windows/apps/ff941099)
+      def self.post(notifications, access_token, options = {})
+        body = notifications.as_wns_xml
+        headers = build_headers(access_token, notifications.data[:type], body.length.to_s)
+        responses = []
+        notifications.each_device do |url|
+          http = Net::HTTP.new url.host, url.port
+          http.open_timeout = options.fetch(:open_timeout, 30)
+          http.read_timeout = options.fetch(:read_timeout, 30)
+          if url.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          end
+          response = http.post url.request_uri, body, headers
+          responses << { device_url: url.to_s, headers: capitalize_headers(response), code: response.code.to_i }
+        end
+        WNSResponse.new responses
+      end
+
+      # Build Header based on type and delay
+      #
+      # @param type [String]. Access token
+      # @param type [Symbol]. The type of notification
+      # @param type [String]. Content length of body
+      # @return [Hash]. Correct delay based on notification type
+      # https://msdn.microsoft.com/en-us/library/windows/apps/hh465435.aspx#send_notification_request
+      def self.build_headers(access_token, type, body_length)
+        {
+          CONTENT_TYPE_HEADER => CONTENT_TYPE[type],
+          X_WNS_TYPE_HEADER => WP_TARGETS[type],
+          CONTENT_LENGTH_HEADER => body_length,
+          AUTHORIZATION_HEADER => "Bearer #{access_token}",
+          REQUEST_FOR_STATUS_HEADER => 'true'
+        }
+      end
+
+      # Extract headers from response
+      # @param response [Net::HTTPResponse]. HTTP response for request
+      #
+      # @return [Hash]. Hash with headers with case-insensitive keys and capitalized string values
+      def self.capitalize_headers(response)
+        headers = {}
+        response.each_header { |k, v| headers[k] = v.capitalize }
+        headers
+      end
+    end
+  end
+end