urbanairship 2.4.1 → 3.0.1

data/lib/urbanairship/client.rb

@@ -0,0 +1,84 @@
+require 'unirest'
+require 'urbanairship/common'
+require 'urbanairship/loggable'
+
+module Urbanairship
+    class Client
+      attr_accessor :key, :secret
+      include Urbanairship::Common
+      include Urbanairship::Loggable
+
+      # set default client timeout to 5 seconds
+      Unirest.timeout(5)
+
+      # Initialize the Client
+      #
+      # @param [Object] key Application Key
+      # @param [Object] secret Application Secret
+      # @return [Object] Client
+      def initialize(key: required('key'), secret: required('secret'))
+        @key = key
+        @secret = secret
+      end
+
+      # Send a request to Urban Airship's API
+      #
+      # @param [Object] method HTTP Method
+      # @param [Object] body Request Body
+      # @param [Object] url Request URL
+      # @param [Object] content_type Content-Type
+      # @param [Object] version API Version
+      # @param [Object] params Parameters
+      # @return [Object] Push Response
+      def send_request(method: required('method'), body: required('body'), url: required('url'),
+                       content_type: nil, version: nil, params: nil)
+        req_type = case method
+          when 'GET'
+            :get
+          when 'POST'
+            :post
+          when 'PUT'
+            :put
+          when 'DELETE'
+            :delete
+          else
+            fail 'Method was not "GET" "POST" "PUT" or "DELETE"'
+        end
+
+        logger.debug("Making #{method} request to #{url}. \n\tHeaders:\n\tcontent-type: #{content_type}\n\tversion=#{version.to_s}\nBody:\n\t#{body}")
+
+        response = Unirest.method(req_type).call(
+            url,
+            headers:{
+                "Content-type" => content_type,
+                "Accept" => "application/vnd.urbanairship+json; version=" + version.to_s
+            },
+            auth:{
+                :user=>@key,
+                :password=>@secret
+            },
+            parameters: body
+        )
+
+        logger.debug("Received #{response.code} response. Headers:\n\t#{response.headers}\nBody:\n\t#{response.body}")
+
+        Response.check_code(response.code, response)
+
+        {'body'=>response.body, 'code'=>response.code}
+      end
+
+      # Create a Push Object
+      #
+      # @return [Object] Push Object
+      def create_push
+        Push::Push.new(self)
+      end
+
+      # Create a Scheduled Push Object
+      #
+      # @return [Object] Scheduled Push Object
+      def create_scheduled_push
+        Push::ScheduledPush.new(self)
+      end
+    end
+  end

data/lib/urbanairship/common.rb

@@ -0,0 +1,85 @@
+require 'urbanairship/loggable'
+
+module Urbanairship
+  # Features mixed in to all classes
+  module Common
+    SERVER = 'go.urbanairship.com'
+    BASE_URL = 'https://go.urbanairship.com/api'
+    CHANNEL_URL = BASE_URL + '/channels/'
+    DEVICE_TOKEN_URL = BASE_URL + '/device_tokens/'
+    APID_URL = BASE_URL + '/apids/'
+    DEVICE_PIN_URL = BASE_URL + '/device_pins/'
+    PUSH_URL = BASE_URL + '/push/'
+    DT_FEEDBACK_URL = BASE_URL + '/device_tokens/feedback/'
+    APID_FEEDBACK_URL = BASE_URL + '/apids/feedback/'
+    SCHEDULES_URL = BASE_URL + '/schedules/'
+    TAGS_URL = BASE_URL + '/tags/'
+    SEGMENTS_URL = BASE_URL + '/segments/'
+
+    # Helper method for required keyword args in 2.0 that is compatible with 2.1+
+    # @example
+    #   def say(greeting: required('greeting'))
+    #     puts greeting
+    #   end
+    #
+    #   >> say
+    #   >> test.rb:3:in `required': required parameter :greeting not passed to method say (ArgumentError)
+    #   >>       from test.rb:6:in `say'
+    #   >>       from test.rb:18:in `<main>'
+    # @param [Object] arg optional argument name
+    def required(arg=nil)
+      method = caller_locations(1,1)[0].label
+      raise ArgumentError.new("required parameter #{arg.to_sym.inspect + ' ' if arg}not passed to method #{method}")
+    end
+
+    class Unauthorized < StandardError
+      # raised when we get a 401 from server
+    end
+
+    class Forbidden < StandardError
+      # raised when we get a 403 from server
+    end
+
+    class AirshipFailure < StandardError
+      include Urbanairship::Loggable
+      # Raised when we get an error response from the server.
+      attr_accessor :error, :error_code, :details, :response
+
+      def initialize
+        @error = nil
+        @error_code = nil
+        @details = nil
+        @response = nil
+      end
+
+      # Instantiate a ValidationFailure from a Response object
+      def from_response(response)
+
+        payload = response.body
+        @error = payload['error']
+        @error_code = payload['error_code']
+        @details = payload['details']
+        @response = response
+
+        logger.error("Request failed with status #{response.code.to_s}: '#{@error_code} #{@error}': #{response.body}")
+
+        self
+      end
+
+    end
+
+    class Response
+      # Parse Response Codes and trigger appropriate actions.
+      def self.check_code(response_code, response)
+        if response_code == 401
+          raise Unauthorized, "Client is not authorized to make this request. The authorization credentials are incorrect or missing."
+        elsif response_code == 403
+          raise Forbidden, "Client is not forbidden from making this request. The application does not have the proper entitlement to access this feature."
+        elsif !((200...300).include?(response_code))
+          raise AirshipFailure.new.from_response(response)
+        end
+      end
+    end
+
+  end
+end

data/lib/urbanairship/loggable.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module Urbanairship
+  module Loggable
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    def create_logger
+      logger = Logger.new('urbanairship.log')
+      logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+      logger.progname = 'Urbanairship'
+      logger
+    end
+
+  end
+end

data/lib/urbanairship/push/audience.rb

@@ -0,0 +1,150 @@
+require 'urbanairship/util'
+require 'urbanairship/common'
+
+module Urbanairship
+  module Push
+    module Audience
+      include Urbanairship::Common
+      UUID_PATTERN = /^\h{8}-\h{4}-\h{4}-\h{4}-\h{12}$/
+      DEVICE_TOKEN_PATTERN = /^\h{64}$/
+      DEVICE_PIN_PATTERN = /^\h{8}$/
+      DATE_TERMS = %i(minutes hours days weeks months years)
+
+
+      # Methods to select a single iOS Channel, Android Channel, Amazon Channel,
+      # Android APID, Windows 8 APID, or Windows Phone 8 APID respectively.
+      #
+      # @example
+      #   ios_channel(<channel>) # ==>
+      #     {:ios_channel=>"<channel>"}
+      %w(ios_channel android_channel amazon_channel apid wns mpns).each do |name|
+        define_method(name) do |uuid|
+          { name.to_sym => cleanup(uuid) }
+        end
+      end
+
+      # Select a single iOS device token
+      def device_token(token)
+        Util.validate(token, 'device_token', DEVICE_TOKEN_PATTERN)
+        { device_token: token.upcase.strip }
+      end
+
+      # Select a single BlackBerry PIN
+      def device_pin(pin)
+        Util.validate(pin, 'pin', DEVICE_PIN_PATTERN)
+        { device_pin: pin.downcase.strip }
+      end
+
+      # Select a single tag
+      def tag(tag)
+        { tag: tag }
+      end
+
+      # Select a single alias
+      def alias(an_alias)
+        { alias: an_alias }
+      end
+
+      # Select a single segment using segment_id
+      def segment(segment)
+        { segment: segment }
+      end
+
+      # Select devices that match at least one of the given selectors.
+      #
+      # @example
+      #   or(tag('sports'), tag('business')) # ==>
+      #     {or: [{tag: 'sports'}, {tag: 'business'}]}
+      def or(*children)
+        { or: children }
+      end
+
+      # Select devices that match all of the given selectors.
+      #
+      # @example
+      #   and(tag('sports'), tag('business')) # ==>
+      #     {and: [{tag: 'sports'}, {tag: 'business'}]}
+      def and(*children)
+        { and: children }
+      end
+
+      # Select devices that do not match the given selectors.
+      #
+      # @example
+      #   not(and_(tag('sports'), tag('business'))) # ==>
+      #     {not: {and: [{tag: 'sports'}, {tag: 'business'}]}}
+      def not(child)
+        { not: child }
+      end
+
+      # Select a recent date range for a location selector.
+      # Valid selectors are:
+      #   :minutes :hours :days :weeks :months :years
+      #
+      # @example
+      #   recent_date(months: 6)  # => { recent: { months: 6 }}
+      #   recent_date(weeks: 3)  # => { recent: { weeks: 3 }}
+      def recent_date(**params)
+        fail ArgumentError, 'Only one range allowed' if params.size != 1
+        k, v = params.first
+        unless DATE_TERMS.include?(k)
+          fail ArgumentError, "#{k} not in #{DATE_TERMS}"
+        end
+        { recent: { k => v } }
+      end
+
+      # Select an absolute date range for a location selector.
+      #
+      # @param resolution [Symbol] Time resolution specifier, one of
+      #                            :minutes :hours :days :weeks :months :years
+      # @param start [String] UTC start time in ISO 8601 format.
+      # @param the_end [String] UTC end time in ISO 8601 format.
+      #
+      # @example
+      #   absolute_date(resolution: :months, start: '2013-01', the_end: '2013-06')
+      #   #=> {months: {end: '2013-06', start: '2013-01'}}
+      #
+      #   absolute_date(resolution: :minutes, start: '2012-01-01 12:00',
+      #                 the_end: '2012-01-01 12:45')
+      #   #=> {minutes: {end: '2012-01-01 12:45', start: '2012-01-01 12:00'}}
+      def absolute_date(resolution: required('resolution'), start: required('start'), the_end: required('the_end'))
+        unless DATE_TERMS.include?(resolution)
+          fail ArgumentError, "#{resolution} not in #{DATE_TERMS}"
+        end
+        { resolution => { start: start, end: the_end } }
+      end
+
+      # Select a location expression.
+      #
+      # Location selectors are made up of either an id or an alias and a date
+      # period specifier. Use a date specification function to generate the time
+      # period specifier.
+      #
+      # @example ID location
+      #   location(id: '4oFkxX7RcUdirjtaenEQIV', date: recent_date(days: 4))
+      #   #=> {location: {date: {recent: {days: 4}},
+      #       id: '4oFkxX7RcUdirjtaenEQIV'}}
+      #
+      # @example Alias location
+      #   location(us_zip: '94103', date: absolute_date(
+      #            resolution: 'days', start: '2012-01-01', end: '2012-01-15'))
+      #   #=> {location: {date: {days: {end: '2012-01-15',
+      #       start: '2012-01-01'}}, us_zip: '94103'}}
+      def location(date: required('date'), **params)
+        unless params.size == 1
+          fail ArgumentError, 'One location specifier required'
+        end
+        params[:date] = date
+        { location: params }
+      end
+
+      private
+
+      # Clean up a UUID for use in the library
+      def cleanup(uuid)
+        Util.validate(uuid, 'UUID', UUID_PATTERN)
+        uuid.downcase.strip
+      end
+    end
+  end
+end

data/lib/urbanairship/push/payload.rb

@@ -0,0 +1,144 @@
+module Urbanairship
+  module Push
+    module Payload
+      require 'ext/hash'
+      include Urbanairship::Common
+
+      # Notification Object for a Push Payload
+      def notification(alert: nil, ios: nil, android: nil, amazon: nil,
+                       blackberry: nil, wns: nil, mpns: nil, actions: nil,
+                       interactive: nil)
+        payload = {
+          alert: alert,
+          actions: actions,
+          ios: ios,
+          android: android,
+          amazon: amazon,
+          blackberry: blackberry,
+          wns: wns,
+          mpns: mpns,
+          interactive: interactive
+        }.compact
+        fail ArgumentError, 'Notification body is empty' if payload.empty?
+        payload
+      end
+
+      # iOS specific portion of Push Notification Object
+      def ios(alert: nil, badge: nil, sound: nil, extra: nil, expiry: nil,
+              category: nil, interactive: nil, content_available: nil)
+        {
+          alert: alert,
+          badge: badge,
+          sound: sound,
+          extra: extra,
+          expiry: expiry,
+          category: category,
+          interactive: interactive,
+          'content-available' => content_available
+        }.compact
+      end
+
+      # Amazon specific portion of Push Notification Object
+      def amazon(alert: nil, consolidation_key: nil, expires_after: nil,
+                 extra: nil, title: nil, summary: nil, interactive: nil)
+        {
+          alert: alert,
+          consolidation_key: consolidation_key,
+          expires_after: expires_after,
+          extra: extra,
+          title: title,
+          summary: summary,
+          interactive: interactive
+        }.compact
+      end
+
+      # Android specific portion of Push Notification Object
+      def android(alert: nil, collapse_key: nil, time_to_live: nil,
+                  extra: nil, delay_while_idle: nil, interactive: nil)
+        {
+          alert: alert,
+          collapse_key: collapse_key,
+          time_to_live: time_to_live,
+          extra: extra,
+          delay_while_idle: delay_while_idle,
+          interactive: interactive
+        }.compact
+      end
+
+      # BlackBerry specific portion of Push Notification Object
+      def blackberry(alert: nil, body: nil, content_type: 'text/plain')
+        { body: alert || body, content_type: content_type }
+      end
+
+      # WNS specific portion of Push Notification Object
+      def wns_payload(alert: nil, toast: nil, tile: nil, badge: nil)
+        payload = {
+          alert: alert,
+          toast: toast,
+          tile: tile,
+          badge: badge
+        }.compact
+        fail ArgumentError, 'Must specify one message type' if payload.size != 1
+        payload
+      end
+
+      # MPNS specific portion of Push Notification Object
+      def mpns_payload(alert: nil, toast: nil, tile: nil)
+        payload = {
+          alert: alert,
+          toast: toast,
+          tile: tile
+        }.compact
+        fail ArgumentError, 'Must specify one message type' if payload.size != 1
+        payload
+      end
+
+      # Rich Message specific portion of Push Notification Object
+      def message(title: required('title'), body: required('body'), content_type: nil, content_encoding: nil,
+                  extra: nil, expiry: nil, icons: nil, options: nil)
+        {
+          title: title,
+          body: body,
+          content_type: content_type,
+          content_encoding: content_encoding,
+          extra: extra,
+          expiry: expiry,
+          icons: icons,
+          options: options
+        }.compact
+      end
+
+      # Interactive Notification portion of Push Notification Object
+      def interactive(type: required('type'), button_actions: nil)
+        fail ArgumentError, 'type must not be nil' if type.nil?
+        { type: type, button_actions: button_actions }.compact
+      end
+
+      def all
+        'all'
+      end
+
+      # Target specified device types
+      def device_types(types)
+        types
+      end
+
+      # Expiry for a Rich Message
+      def options(expiry: required('expiry'))
+        { expiry: expiry }
+      end
+
+      # Actions for a Push Notification Object
+      def actions(add_tag: nil, remove_tag: nil, open_: nil, share: nil,
+                  app_defined: nil)
+        {
+          add_tag: add_tag,
+          remove_tag: remove_tag,
+          open: open_,
+          share: share,
+          app_defined: app_defined
+        }.compact
+      end
+    end
+  end
+end