spark_api 1.1.2 → 1.2.0

data/lib/spark_api/models/concerns.rb

@@ -0,0 +1,7 @@
+require 'spark_api/models/concerns/savable'
+require 'spark_api/models/concerns/destroyable'
+
+module SparkApi
+  module Models
+  end
+end

data/lib/spark_api/models/concerns/destroyable.rb

@@ -0,0 +1,32 @@
+module SparkApi
+  module Models
+    module Concerns
+
+      module Destroyable
+
+        def destroy(arguments = {})
+          self.errors = []
+          begin
+            return destroy!(arguments)
+          rescue BadResourceRequest => e
+            self.errors << {:code => e.code, :message => e.message}
+            SparkApi.logger.error("Failed to destroy resource #{self}: #{e.message}")
+          rescue NotFound => e
+            SparkApi.logger.error("Failed to destroy resource #{self}: #{e.message}")
+          end
+          false
+        end
+        def destroy!(arguments = {})
+          connection.delete("#{self.class.path}/#{self.Id}", arguments)
+          @destroyed = true
+          true
+        end
+        alias_method :delete, :destroy # backwards compatibility
+
+        def destroyed?; @destroyed ? @destroyed : false end
+
+      end
+
+    end
+  end
+end

data/lib/spark_api/models/concerns/savable.rb

@@ -0,0 +1,66 @@
+module SparkApi
+  module Models
+    module Concerns
+
+      module Savable
+
+        def save(arguments = {})
+          self.errors = [] # clear the errors hash
+          begin
+            return save!(arguments)
+          rescue BadResourceRequest => e
+            self.errors << {:code => e.code, :message => e.message}
+            SparkApi.logger.error("Failed to save resource #{self}: #{e.message}")
+          rescue NotFound => e
+            SparkApi.logger.error("Failed to save resource #{self}: #{e.message}")
+          end
+          false
+        end
+        def save!(arguments = {})
+          persisted? ? update!(arguments) : create!(arguments)
+        end
+
+        def create!(arguments = {})
+          results = connection.post self.class.path, {
+            resource_pluralized => [ attributes ]
+          }.merge(params_for_save), arguments
+
+          update_resource_identifiers(results.first)
+          reset_dirty
+          params_for_save.clear
+          true
+        end
+
+        def update!(arguments = {})
+          return true unless changed?
+          connection.put "#{self.class.path}/#{self.Id}", dirty_attributes, arguments
+          reset_dirty
+          params_for_save.clear
+          true
+        end
+
+        def params_for_save
+          @params_for_save ||= {}
+        end
+
+        private 
+
+        def update_resource_identifiers(result)
+          attributes['ResourceUri'] = result['ResourceUri']
+          attributes['Id'] = result['Id'] ? result['Id'] : parse_id(result['ResourceUri'])
+        end
+
+        # can be overridden
+        def resource_pluralized
+          resource = self.class.name.split('::').last
+          unless resource.split('').last == "s"
+            resource = resource + "s"
+          end
+          resource
+        end
+
+      end
+
+    end
+  end
+end

data/lib/spark_api/models/contact.rb

@@ -2,28 +2,11 @@ module SparkApi
   module Models
     class Contact < Base
       extend Finders
+      include Concerns::Savable,
+              Concerns::Destroyable
+
       self.element_name="contacts"
       
-      def save(arguments={})
-        self.errors = [] # clear the errors hash
-        begin
-          return save!(arguments)
-        rescue BadResourceRequest => e
-          self.errors << {:code => e.code, :message => e.message}
-          SparkApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        rescue NotFound => e
-          SparkApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        end
-        false
-      end
-      def save!(arguments={})
-        results = connection.post self.class.path, {"Contacts" => [ attributes ], "Notify" => notify? }, arguments
-        result = results.first
-        attributes['ResourceUri'] = result['ResourceUri']
-        attributes['Id'] = parse_id(result['ResourceUri'])
-        true
-      end
-      
       def self.by_tag(tag_name, arguments={})
         collect(connection.get("#{path}/tags/#{tag_name}", arguments))
       end
@@ -37,11 +20,9 @@ module SparkApi
       end
             
       # Notify the agent of contact creation via a Spark notification.
-      def notify?
-        @notify == true
-      end
-      def notify=(notify_me=true)
-        @notify = notify_me
+      def notify?; params_for_save[:Notify] == true end
+      def notify=(notify_me)
+        params_for_save[:Notify] = notify_me
       end
       
     end

data/lib/spark_api/models/dirty.rb

@@ -0,0 +1,57 @@
+module SparkApi
+  module Models
+    module Dirty
+
+      def changed?
+        changed.any?
+      end
+
+      def changed
+        changed_attributes.keys
+      end
+
+      def changes
+        Hash[changed.map { |attr| [attr, attribute_change(attr)] }]
+      end
+
+      def previous_changes
+        @previously_changed
+      end
+
+      # hash with changed attributes and their original values
+      def changed_attributes
+        @changed_attributes ||= {}
+      end
+
+      # hash with changed attributes and their new values
+      def dirty_attributes
+        changed.inject({}) { |h, k| h[k] = attributes[k]; h }
+      end
+
+      private
+
+      def reset_dirty
+        @previously_changed = changed_attributes
+        @changed_attributes.clear
+      end
+
+      def attribute_changed?(attr)
+        changed.include?(attr)
+      end
+
+      def attribute_change(attr)
+        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      end
+
+      def attribute_will_change!(attr)
+        begin
+          value = __send__(attr)
+          value = value.duplicable? ? value.clone : value
+        rescue TypeError, NoMethodError; end
+
+        changed_attributes[attr] = value unless changed.include?(attr)
+      end
+
+    end
+  end
+end

data/lib/spark_api/models/finders.rb

@@ -15,10 +15,6 @@ module SparkApi
           else             find_single(scope, options)
         end
       end
-
-      def all(*arguments)
-        find(:all, *arguments)
-      end
       
       def first(*arguments)
         find(:first, *arguments)

data/lib/spark_api/models/saved_search.rb

@@ -1,7 +1,11 @@
 module SparkApi
   module Models
+
     class SavedSearch < Base 
       extend Finders
+      include Concerns::Savable,
+              Concerns::Destroyable
+
       self.element_name="savedsearches"
 
       def self.provided()
@@ -11,6 +15,12 @@ module SparkApi
           SparkApi.logger.info("#{self.name}.path: #{provided.path}")
         end
       end
+
+      private
+
+      def resource_pluralized; "SavedSearches" end
+
     end
+
   end
 end

data/lib/spark_api/models/subresource.rb

@@ -25,6 +25,7 @@ module SparkApi
 
             begin
               datetime = DateTime.strptime(formatted_date, '%m/%d/%YT%l:%M %P')
+              dst_offset = 0
             rescue => ex
               ; # Do nothing; doesn't matter
             end
@@ -35,6 +36,7 @@ module SparkApi
                 begin
                   datetime = DateTime.strptime(formatted_date, format)
                   datetime = datetime.new_offset DateTime.now.offset
+                  dst_offset = Time.now.dst? ? 0 : 1
                   break
                 rescue => ex
                   next
@@ -46,9 +48,11 @@ module SparkApi
             unless datetime
               raise ArgumentError.new('invalid date')
             end
+            
+            
 
             attributes[time] = Time.local(datetime.year, datetime.month, datetime.day,
-                                          datetime.hour, datetime.min, datetime.sec)
+                                          datetime.hour + dst_offset, datetime.min, datetime.sec)
           end
           attributes['Date'] = date
         end

data/lib/spark_api/models/subscription.rb

@@ -0,0 +1,52 @@
+module SparkApi
+  module Models
+
+    class Subscription < Base
+      extend Finders
+      include Concerns::Savable,
+              Concerns::Destroyable
+
+      self.element_name = "subscriptions"
+
+      # list subscribers (private role)
+      def subscribers
+        return {} unless persisted?
+        results = connection.get("#{self.class.path}/#{@attributes["Id"]}/subscribers")
+        @attributes['RecipientIds'] = results.first['RecipientIds']
+        results
+      end
+
+      # subscribe/unsubscribe contact (private role)
+      [:subscribe, :unsubscribe].each do |action|
+        method = (action == :subscribe ? :put : :delete)
+        define_method(action) do |contact|
+          return false unless persisted?
+          self.errors = []
+          contact_id = contact.is_a?(Contact) ? contact.Id : contact
+          begin
+            connection.send(method, "#{self.class.path}/#{@attributes["Id"]}/subscribers/#{contact_id}")
+          rescue BadResourceRequest, NotFound => e
+            self.errors << { :code => e.code, :message => e.message }
+            SparkApi.logger.error("Failed to #{action} contact #{contact}: #{e.message}")
+            return false
+          end
+          update_recipients(action, contact_id)
+          true
+        end
+      end
+
+      private
+
+      def update_recipients(method, contact_id)
+        @attributes['RecipientIds'] = [] if @attributes['RecipientIds'].nil?
+        if method == :subscribe
+          @attributes['RecipientIds'] << contact_id
+        else
+          @attributes['RecipientIds'].delete contact_id
+        end
+      end
+
+    end
+
+  end
+end

data/lib/spark_api/request.rb

@@ -24,7 +24,7 @@ module SparkApi
     #   Hash of the json results as documented in the api.
     # :raises:
     #   SparkApi::ClientError or subclass if the request failed.
-    def post(path, body={}, options={})
+    def post(path, body = nil, options={})
       request(:post, path, body, options)
     end
 
@@ -37,7 +37,7 @@ module SparkApi
     #   Hash of the json results as documented in the api.
     # :raises:
     #   SparkApi::ClientError or subclass if the request failed.
-    def put(path, body={}, options={})
+    def put(path, body = nil, options={})
       request(:put, path, body, options)
     end
 
@@ -64,13 +64,13 @@ module SparkApi
       begin
         request_opts = {}
         request_opts.merge!(options)
-        post_data = body.nil? ? nil : {"D" => body }.to_json
         request_path = "/#{version}#{path}"
         start_time = Time.now
         SparkApi.logger.debug("#{method.to_s.upcase} Request:  #{request_path}")
-        if post_data.nil?
+        if [:get, :delete, :head].include?(method.to_sym)
           response = authenticator.request(method, request_path, nil, request_opts)
         else
+          post_data = process_request_body(body)
           SparkApi.logger.debug("#{method.to_s.upcase} Data:   #{post_data}")
           response = authenticator.request(method, request_path, post_data, request_opts)
         end
@@ -89,6 +89,19 @@ module SparkApi
         raise
       end
       response.body
+    rescue Faraday::Error::ConnectionFailed => e
+      if self.ssl_verify && e.message =~ /certificate verify failed/
+        SparkApi.logger.error(SparkApi::Errors.ssl_verification_error)
+      end
+      raise e
+    end
+    
+    def process_request_body(body)
+      if body.is_a?(Hash)
+        body.empty? ? "{}" : {"D" => body }.to_json
+      else
+        body
+      end
     end
     
   end

data/lib/spark_api/response.rb

@@ -8,43 +8,6 @@ module SparkApi
     end
   end
   
-  # All known response codes listed in the API
-  module ResponseCodes
-    NOT_FOUND = 404
-    METHOD_NOT_ALLOWED = 405
-    INVALID_KEY = 1000
-    DISABLED_KEY = 1010
-    API_USER_REQUIRED = 1015
-    SESSION_TOKEN_EXPIRED = 1020
-    SSL_REQUIRED = 1030
-    INVALID_JSON = 1035
-    INVALID_FIELD = 1040
-    MISSING_PARAMETER = 1050
-    INVALID_PARAMETER = 1053
-    CONFLICTING_DATA = 1055
-    NOT_AVAILABLE= 1500
-    RATE_LIMIT_EXCEEDED = 1550
-  end
-  
-  # Errors built from API responses
-  class InvalidResponse < StandardError; end
-  class ClientError < StandardError
-    attr_reader :code, :status, :details
-    def initialize (options = {})
-      # Support the standard initializer for errors
-      opts = options.is_a?(Hash) ? options : {:message => options.to_s}
-      @code = opts[:code]
-      @status = opts[:status]
-      @details = opts[:details]
-      super(opts[:message])
-    end
-    
-  end
-  class NotFound < ClientError; end
-  class PermissionDenied < ClientError; end
-  class NotAllowed < ClientError; end
-  class BadResourceRequest < ClientError; end
-  
   # Nice and handy class wrapper for the api response hash
   class ApiResponse < ::Array
     include SparkApi::Response

data/script/combined_flow_example.rb

@@ -14,8 +14,8 @@ SparkApi.configure do |config|
   config.api_key      = "YOUR_CLIENT_ID"
   config.api_secret   = "YOUR_CLIENT_SECRET"
   config.callback     = "YOUR_REDIRECT_URI"
-  config.auth_endpoint = "https://developers.sparkplatform.com/openid"
-  config.endpoint   = 'https://developers.sparkapi.com'
+  config.auth_endpoint = "https://sparkplatform.com/openid"
+  config.endpoint   = 'https://sparkapi.com'
 end
 
 client = SparkApi.client
@@ -24,7 +24,7 @@ client = SparkApi.client
 # Step 1:
 # To get your code to post to /v1/oauth2/grant, send the end user to this URI, replacing the all-capped strings with
 # the CGI-escaped credentials for your key:
-# https://developers.sparkplatform.com/oauth2?response_type=code&client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI
+# https://sparkplatform.com/oauth2?response_type=code&client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI
 # When the user has finished, they will land at:
 # YOUR_REDIRECT_URI?code=CODE.
 puts "Go here and log in to get your code: #{client.authenticator.authorization_url}"