survey-gizmo-ruby 4.1.0 → 5.0.2

data/lib/survey_gizmo/api/question.rb

@@ -1,3 +1,5 @@
+require 'survey_gizmo/api/option'
+
 module SurveyGizmo; module API
   # @see SurveyGizmo::Resource::ClassMethods
   class Question
@@ -10,6 +12,7 @@ module SurveyGizmo; module API
     attribute :shortname,          String
     attribute :properties,         Hash
     attribute :after,              Integer
+    attribute :options,            Array[Option]
     attribute :survey_id,          Integer
     attribute :page_id,            Integer, default: 1
     attribute :sub_question_skus,  Array
@@ -17,30 +20,39 @@ module SurveyGizmo; module API
 
     alias_attribute :_subtype, :type
 
-    route '/survey/:survey_id/surveyquestion/:id', via: :get
-    route '/survey/:survey_id/surveypage/:page_id/surveyquestion', via: :create
-    route '/survey/:survey_id/surveypage/:page_id/surveyquestion/:id', via: [:update, :delete]
+    @route = {
+      get:    '/survey/:survey_id/surveyquestion/:id',
+      create: '/survey/:survey_id/surveypage/:page_id/surveyquestion',
+      update: '/survey/:survey_id/surveypage/:page_id/surveyquestion/:id'
+    }
+    @route[:delete] = @route[:update]
 
     def survey
       @survey ||= Survey.first(id: survey_id)
     end
 
     def options
-      @options ||= Option.all(survey_id: survey_id, page_id: page_id, question_id: id, all_pages: true)
+      return parent_question.options.dup.each { |o| o.question_id = id } if parent_question
+
+      @options ||= Option.all(children_params.merge(all_pages: true)).to_a
+      @options.each { |o| o.attributes = children_params }
     end
 
     def parent_question
-      @parent_question ||= parent_question_id ? Question.first(survey_id: survey_id, id: parent_question_id) : nil
+      return nil unless parent_question_id
+      @parent_question ||= Question.first(survey_id: survey_id, id: parent_question_id)
     end
 
     def sub_questions
-      @sub_questions ||= sub_question_skus.map { |subquestion_id| Question.first(survey_id: survey_id, id: subquestion_id) }
-                                          .each { |subquestion| subquestion.parent_question_id = id  }
-    end
-
-    # @see SurveyGizmo::Resource#to_param_options
-    def to_param_options
-      { id: self.id, survey_id: self.survey_id, page_id: self.page_id }
+      @sub_questions ||= sub_question_skus.map do |sku|
+        # As of 2015-12-23, the sub_question_skus attribute can either contain an array of integers if no shortname (alias)
+        # was set for any question, or an array of [String, Integer] with the String corresponding to the subquestion
+        # shortname and the integer corresponding to the subquestion id if at least one shortname was set.
+        sku = sku[1] if sku.is_a?(Array)
+        subquestion = Question.first(survey_id: survey_id, id: sku)
+        subquestion.parent_question_id = id
+        subquestion
+      end
     end
   end
 end; end

data/lib/survey_gizmo/api/response.rb

@@ -20,7 +20,6 @@ module SurveyGizmo; module API
     attribute :contact_id,           Integer
     attribute :data,                 String
     attribute :status,               String
-    attribute :datesubmitted,        DateTime
     attribute :is_test_data,         Boolean
     attribute :sResponseComment,     String
     attribute :variable,             Hash       # READ-ONLY
@@ -28,16 +27,26 @@ module SurveyGizmo; module API
     attribute :shown,                Hash       # READ-ONLY
     attribute :url,                  Hash       # READ-ONLY
     attribute :answers,              Hash       # READ-ONLY
+    attribute :datesubmitted,        DateTime
+    alias_attribute :submitted_at, :datesubmitted
 
-    route '/survey/:survey_id/surveyresponse',     via: :create
-    route '/survey/:survey_id/surveyresponse/:id', via: [:get, :update, :delete]
+    @route = '/survey/:survey_id/surveyresponse'
 
     def survey
       @survey ||= Survey.first(id: survey_id)
     end
 
-    def to_param_options
-      { id: self.id, survey_id: self.survey_id }
+    def parsed_answers
+      answers.select do |k,v|
+        next false unless v.is_a?(FalseClass) || v.present?
+
+        # Strip out "Other" answers that don't actually have the "other" text.
+        if k =~ /\[question\((\d+)\),\s*option\((\d+)\)\]/
+          !answers.keys.any? { |key| key =~ /\[question\((#{$1})\),\s*option\("(#{$2})-other"\)\]/ }
+        else
+          true
+        end
+      end.map { |k,v| Answer.new(children_params.merge(key: k, value: v, answer_text: v, submitted_at: submitted_at)) }
     end
   end
 end; end

data/lib/survey_gizmo/api/survey.rb

@@ -1,3 +1,5 @@
+require 'survey_gizmo/api/page'
+
 module SurveyGizmo; module API
   # @see SurveyGizmo::Resource::ClassMethods
   class Survey
@@ -20,23 +22,33 @@ module SurveyGizmo; module API
     attribute :created_on,     DateTime
     attribute :modified_on,    DateTime
     attribute :copy,           Boolean
+    # Unfortunately if pages is an attribute, then save and update requests will collide with the differing response
+    # types to Survey.all and Survey.first and cause an incorrect reload
+    # attribute :pages,          Array[Page]
 
-    route '/survey/:id', via: [:get, :update, :delete]
-    route '/survey',     via: :create
-
-    def to_param_options
-      { id: id }
-    end
+    @route = '/survey'
 
     def pages
-      @pages ||= Page.all(survey_id: id, all_pages: true)
+      # SurveyGizmo sends down the page info to .first requests but NOT to .all requests, so we must load pages manually
+      # We should be able to just .reload this Survey BUT we can't make :pages a Virtus attribute without requiring a
+      # call to this method during Survey.save
+      @pages ||= Page.all(children_params.merge(all_pages: true)).to_a
+      @pages.each { |p| p.attributes = children_params }
     end
 
-    # Sub question handling is in resource.rb.  It should probably be here instead but if it gets moved here
-    # and people try to request all the questions for a specific page directly from a ::API::Question request,
-    # sub questions will not be included!  So I left it there for least astonishment.
+    # Sub question handling is in resource.rb and page.rb.  It should probably be here instead but if it gets moved
+    # here and people try to request all the questions for a specific page directly from a ::API::Question request or
+    # from Page.questions, sub questions will not be included!  So I left it there for least astonishment.
     def questions
-      @questions ||= pages.map { |p| Question.all(survey_id: id, page_id: p.id, all_pages: true) }.flatten
+      @questions ||= pages.flat_map { |p| p.questions }
+    end
+
+    def actual_questions
+      questions.reject { |q| q.type =~ /^(instructions|urlredirect|logic|media|script|javascript)$/ }
+    end
+
+    def responses(conditions = {})
+      Response.all(conditions.merge(children_params).merge(all_pages: !conditions[:page]))
     end
 
     # Statistics array of arrays looks like:
@@ -50,13 +62,13 @@ module SurveyGizmo; module API
     end
 
     def server_has_new_results_since?(time)
-      Response.all(survey_id: id, filters: [Response.submitted_since_filter(time)]).size > 0
+      Response.all(children_params.merge(page: 1, resultsperpage: 1, filters: Response.submitted_since_filter(time))).to_a.size > 0
     end
 
     # As of 2015-12-18, when you request data on multiple surveys from /survey, the team variable comes
     # back as "0".  If you request one survey at a time from /survey/{id}, it is populated correctly.
     def teams
-      @individual_survey ||= Survey.first(id: id)
+      @individual_survey ||= self.reload
       @individual_survey.team
     end
 
@@ -67,5 +79,9 @@ module SurveyGizmo; module API
     def belongs_to?(team)
       team_names.any? { |t| t == team }
     end
+
+    def campaigns
+      @campaigns ||= Campaign.all(children_params.merge(all_pages: true)).to_a
+    end
   end
 end; end

data/lib/survey_gizmo/configuration.rb

@@ -1,30 +1,79 @@
 module SurveyGizmo
   class << self
-    attr_accessor :configuration
-  end
+    attr_writer :configuration
 
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield(configuration) if block_given?
-    SurveyGizmo.setup
-  end
+    def configuration
+      fail 'Not configured!' unless @configuration
+      @configuration
+    end
+
+    def configure
+      @configuration ||= Configuration.new
+      yield(configuration) if block_given?
+      configure_pester
+    end
+
+    def reset!
+      self.configuration = Configuration.new
+      Pester.configure { |c| c.environments[:survey_gizmo_ruby] = nil }
+      configure_pester
+      Connection.reset!
+    end
+
+    private
+
+    def configure_pester
+      default_config = {
+        on_retry: Pester::Behaviors::Sleep::Constant,
+        logger: configuration.logger,
+        max_attempts: 2,
+        delay_interval: 60,
+        retry_error_classes: retryables
+      }
+
+      Pester.configure do |c|
+        if c.environments[:survey_gizmo_ruby].nil?
+          c.environments[:survey_gizmo_ruby] = default_config
+        else
+          default_config.each { |k,v| c.environments[:survey_gizmo_ruby][k] ||= v unless k == :retry_error_classes }
 
-  def self.reset!
-    self.configuration = Configuration.new
+          # Don't set :retry_error_classes to something when user has configured nothing
+          if c.environments[:survey_gizmo_ruby][:retry_error_classes].nil? && !c.environments[:survey_gizmo_ruby].has_key?(:retry_error_classes)
+            c.environments[:survey_gizmo_ruby][:retry_error_classes] = retryables
+          end
+        end
+      end
+    end
+
+    def retryables
+      [
+        Net::ReadTimeout,
+        Faraday::Error::TimeoutError,
+        SurveyGizmo::RateLimitExceededError
+      ]
+    end
   end
 
   class Configuration
-    DEFAULT_RESULTS_PER_PAGE = 50
+    DEFAULT_REST_API_URL = 'https://restapi.surveygizmo.com'
     DEFAULT_API_VERSION = 'v4'
+    DEFAULT_RESULTS_PER_PAGE = 50
 
-    attr_accessor :api_version
     attr_accessor :user
     attr_accessor :password
+
+    attr_accessor :api_debug
+    attr_accessor :api_url
+    attr_accessor :api_version
+    attr_accessor :logger
     attr_accessor :results_per_page
 
     def initialize
-      @results_per_page = DEFAULT_RESULTS_PER_PAGE
+      @api_url = DEFAULT_REST_API_URL
       @api_version = DEFAULT_API_VERSION
+      @results_per_page = DEFAULT_RESULTS_PER_PAGE
+      @logger = ::Logger.new(STDOUT)
+      @api_debug = ENV['GIZMO_DEBUG'].to_s =~ /^(true|t|yes|y|1)$/i
     end
   end
 end

data/lib/survey_gizmo/connection.rb

@@ -0,0 +1,39 @@
+require 'active_support/core_ext/module/delegation'
+
+module SurveyGizmo
+  class Connection
+    TIMEOUT_SECONDS = 300
+
+    class << self
+      delegate :put, :get, :delete, :post, to: :connection
+
+      def reset!
+        @connection = nil
+      end
+
+      private
+
+      def connection
+        options = {
+          url: SurveyGizmo.configuration.api_url,
+          params: { 'user:md5' => "#{SurveyGizmo.configuration.user}:#{Digest::MD5.hexdigest(SurveyGizmo.configuration.password)}" },
+          request: {
+            timeout: TIMEOUT_SECONDS,
+            open_timeout: TIMEOUT_SECONDS
+          }
+        }
+
+        @connection ||= Faraday.new(options) do |connection|
+          connection.request :url_encoded
+
+          connection.response :parse_survey_gizmo_data
+          connection.response :pester_survey_gizmo
+          connection.response :logger, @logger, bodies: true if SurveyGizmo.configuration.api_debug
+          connection.response :json, content_type: /\bjson$/
+
+          connection.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/survey_gizmo/faraday_middleware/parse_survey_gizmo.rb

@@ -0,0 +1,75 @@
+require 'faraday_middleware/response_middleware'
+
+module SurveyGizmo
+  class ParseSurveyGizmo < FaradayMiddleware::ResponseMiddleware
+    Faraday::Response.register_middleware(parse_survey_gizmo_data: self)
+
+    PAGINATION_FIELDS = ['total_count', 'page', 'total_pages', 'results_per_page']
+    TIME_FIELDS = ['datesubmitted', 'created_on', 'modified_on', 'datecreated', 'datemodified']
+
+    def parse_response?(env)
+      true
+    end
+
+    define_parser do |body|
+      PAGINATION_FIELDS.each { |n| body[n] = body[n].to_i if body[n] }
+
+      next body unless body['data']
+
+      # Handle really crappy [] notation in SG API, so far just in SurveyResponse
+      Array.wrap(body['data']).compact.each do |datum|
+        # SurveyGizmo returns date information in EST but does not provide time zone information.
+        # See https://surveygizmov4.helpgizmo.com/help/article/link/date-and-time-submitted
+        TIME_FIELDS.each do |time_key|
+          datum[time_key] = datum[time_key] + ' EST' unless datum[time_key].blank?
+        end
+
+        datum.keys.grep(/^\[/).each do |key|
+          next if datum[key].nil? || datum[key].length == 0
+
+          parent = find_attribute_parent(key)
+          datum[parent] ||= {}
+
+          case key.downcase
+          when /(url|variable.*standard)/
+            datum[parent][cleanup_attribute_name(key).to_sym] = datum[key]
+          when /variable.*shown/
+            datum[parent][cleanup_attribute_name(key).to_i] = datum[key].include?('1')
+          when /variable/
+            datum[parent][cleanup_attribute_name(key).to_i] = datum[key].to_i
+          when /question/
+            datum[parent][key] = datum[key]
+          end
+
+          datum.delete(key)
+        end
+      end
+
+      body
+    end
+
+    private
+
+    def self.cleanup_attribute_name(attr)
+      attr.downcase.gsub(/[^[:alnum:]]+/, '_')
+                   .gsub(/(url|variable|standard|shown)/, '')
+                   .gsub(/_+/, '_')
+                   .gsub(/^_|_$/, '')
+    end
+
+    def self.find_attribute_parent(attr)
+      case attr.downcase
+      when /url/
+        'url'
+      when /variable.*standard/
+        'meta'
+      when /variable.*shown/
+        'shown'
+      when /variable/
+        'variable'
+      when /question/
+        'answers'
+      end
+    end
+  end
+end

data/lib/survey_gizmo/faraday_middleware/pester_survey_gizmo.rb

@@ -0,0 +1,18 @@
+module SurveyGizmo
+  class RateLimitExceededError < RuntimeError; end
+  class BadResponseError < RuntimeError; end
+
+  class PesterSurveyGizmoMiddleware < Faraday::Middleware
+    Faraday::Response.register_middleware(pester_survey_gizmo: self)
+
+    def call(environment)
+      Pester.survey_gizmo_ruby.retry do
+        @app.call(environment).on_complete do |response|
+          fail RateLimitExceededError if response.status == 429
+          fail BadResponseError, "Bad response code #{response.status} in #{response.inspect}" unless response.status == 200
+          fail BadResponseError, response.body['message'] unless response.body['result_ok'] && response.body['result_ok'].to_s =~ /^true$/i
+        end
+      end
+    end
+  end
+end

data/lib/survey_gizmo/multilingual_title.rb

@@ -1,6 +1,4 @@
-# SurveyGizmo has a bad habit of returning titles in different formats when one is
-# requesting all surveys vs. an individual survey.
-
+# SurveyGizmo has a bad habit of returning titles in different formats when one is requesting via .all vs .first
 module SurveyGizmo
   module MultilingualTitle
     extend ActiveSupport::Concern

data/lib/survey_gizmo/resource.rb

@@ -2,197 +2,193 @@ require 'set'
 require 'addressable/uri'
 
 module SurveyGizmo
+  class URLError < RuntimeError; end
+
   module Resource
     extend ActiveSupport::Concern
 
     included do
       include Virtus.model
-      instance_variable_set('@paths', {})
+      instance_variable_set('@route', nil)
       SurveyGizmo::Resource.descendants << self
     end
 
-    # @return [Set] Every class that includes SurveyGizmo::Resource
     def self.descendants
       @descendants ||= Set.new
     end
 
     # These are methods that every API resource can use to access resources in SurveyGizmo
     module ClassMethods
-      # Get an array of resources.
-      # @param [Hash] options - simple URL params at the top level, and SurveyGizmo "filters" at the :filters key
+      attr_accessor :route
+
+      # Get an enumerator of resources.
+      # @param [Hash] conditions - URL and pagination params with SurveyGizmo "filters" at the :filters key
       #
-      # example: { page: 2, filters: [{ field: "istestdata", operator: "<>", value: 1 }] }
+      # Set all_pages: true if you want the gem to page through all the available responses
       #
-      # The top level keys (e.g. page, resultsperpage) get encoded in the url, while the
-      # contents of the array of hashes passed at the :filters key get turned into the format
-      # SurveyGizmo expects for its internal filtering, for example:
+      # example: { page: 2, filters: { field: "istestdata", operator: "<>", value: 1 } }
       #
-      # filter[field][0]=istestdata&filter[operator][0]=<>&filter[value][0]=1
+      # The top level keys (e.g. :page, :resultsperpage) get encoded in the url, while the
+      # contents of the array of hashes passed at the :filters key get turned into the format
+      # SurveyGizmo expects for its internal filtering.
       #
-      # Set all_pages: true if you want the gem to page through all the available responses
-      def all(conditions = {}, _deprecated_filters = {})
-        conditions = merge_params(conditions, _deprecated_filters)
+      # Properties from the conditions hash (e.g. survey_id) will be added to the returned objects
+      def all(conditions = {})
         fail ':all_pages and :page are mutually exclusive' if conditions[:page] && conditions[:all_pages]
+        logger.warn('WARNING: Only retrieving first page of results!') if conditions[:page].nil? && conditions[:all_pages].nil?
 
         all_pages = conditions.delete(:all_pages)
-        properties = conditions.dup
         conditions[:resultsperpage] = SurveyGizmo.configuration.results_per_page unless conditions[:resultsperpage]
 
-        request_route = handle_route!(:create, conditions)
-        response = RestResponse.new(SurveyGizmo.get(request_route + filters_to_query_string(conditions)))
-        collection = response.data.map { |datum| datum.is_a?(Hash) ? new(datum) : datum }
+        Enumerator.new do |yielder|
+          response = nil
 
-        while all_pages && response.current_page < response.total_pages
-          paged_filter = filters_to_query_string(conditions.merge(page: response.current_page + 1))
-          response = RestResponse.new(SurveyGizmo.get(request_route + paged_filter))
-          collection += response.data.map { |datum| datum.is_a?(Hash) ? new(datum) : datum }
-        end
+          while !response || (all_pages && response['page'] < response['total_pages'])
+            conditions[:page] = response ? response['page'] + 1 : 1
+            logger.debug("Fetching #{name} page #{conditions} - #{conditions[:page]}#{response ? "/#{response['total_pages']}" : ''}...")
+            response = Connection.get(create_route(:create, conditions)).body
+            collection = response['data'].map { |datum| datum.is_a?(Hash) ? new(conditions.merge(datum)) : datum }
 
-        # Add in the properties from the conditions hash because many of the important ones (like survey_id) are
-        # not often part of the SurveyGizmo returned data
-        properties.each do |k,v|
-          if v && instance_methods.include?(k)
-            collection.each { |c| c[k] ||= v }
-          end
-        end
+            # Sub questions are not pulled by default so we have to retrieve them manually.  SurveyGizmo
+            # claims they will fix this bug and eventually all questions will be returned in one request.
+            if self == SurveyGizmo::API::Question
+              collection += collection.flat_map { |question| question.sub_questions }
+            end
 
-        # Sub questions are not pulled by default so we have to retrieve them manually
-        # SurveyGizmo claims they will fix this bug and eventually all questions will be
-        # returned in one request.
-        if self == SurveyGizmo::API::Question
-          collection += collection.map { |question| question.sub_questions }.flatten
+            collection.each { |e| yielder.yield(e) }
+          end
         end
-
-        collection
       end
 
       # Retrieve a single resource.  See usage comment on .all
-      def first(conditions, _deprecated_filters = {})
-        conditions = merge_params(conditions, _deprecated_filters)
-        properties = conditions.dup
-
-        response = RestResponse.new(SurveyGizmo.get(handle_route!(:get, conditions) + filters_to_query_string(conditions)))
-        # Add in the properties from the conditions hash because many of the important ones (like survey_id) are
-        # not often part of the SurveyGizmo's returned data
-        new(properties.merge(response.data))
+      def first(conditions = {})
+        new(conditions.merge(Connection.get(create_route(:get, conditions)).body['data']))
       end
 
-      # Create a new resource.  Returns the newly created Resource instance.
+      # Create a new resource object locally and save to SurveyGizmo.  Returns the newly created Resource instance.
       def create(attributes = {})
-        resource = new(attributes)
-        resource.create_record_in_surveygizmo
-        resource
+        new(attributes).save
       end
 
       # Delete resources
       def destroy(conditions)
-        RestResponse.new(SurveyGizmo.delete(handle_route!(:delete, conditions)))
+        Connection.delete(create_route(:delete, conditions))
       end
 
-      # Define the path where a resource is located
-      def route(path, options)
-        methods = options[:via]
-        methods = [:get, :create, :update, :delete] if methods == :any
-        methods.is_a?(Array) ? methods.each { |m| @paths[m] = path } : (@paths[methods] = path)
+      # @route is either a hash to be used directly or a string from which standard routes will be built
+      def routes
+        fail "route not set in #{name}" unless @route
+
+        return @route if @route.is_a?(Hash)
+        routes = { create: @route }
+        [:get, :update, :delete].each { |k| routes[k] = @route + '/:id' }
+        routes
       end
 
-      # Replaces the :page_id, :survey_id, etc strings defined in each model's URI routes with the
-      # values being passed in interpolation hash with the same keys.
-      #
-      # This method has the SIDE EFFECT of deleting REST path related keys from interpolation_hash!
-      def handle_route!(key, interpolation_hash)
-        path = @paths[key]
-        fail "No routes defined for `#{key}` in #{name}" unless path
-        fail "User/password hash not setup!" if SurveyGizmo.default_params.empty?
-
-        path.gsub(/:(\w+)/) do |m|
-          raise(SurveyGizmo::URLError, "Missing RESTful parameters in request: `#{m}`") unless interpolation_hash[$1.to_sym]
-          interpolation_hash.delete($1.to_sym)
+      # Replaces the :page_id, :survey_id, etc strings defined in each model's routes with the
+      # values in the params hash
+      def create_route(method, params)
+        fail "No route defined for #{method} on #{name}" unless routes[method]
+
+        url_params = params.dup
+        rest_path = routes[method].gsub(/:(\w+)/) do |m|
+          fail SurveyGizmo::URLError, "Missing RESTful parameters in request: `#{m}`" unless url_params[$1.to_sym]
+          url_params.delete($1.to_sym)
         end
+
+        SurveyGizmo.configuration.api_version + rest_path + filters_to_query_string(url_params)
       end
 
       private
 
       # Convert a [Hash] of params and internal surveygizmo style filters into a query string
-      def filters_to_query_string(filters = {})
-        return '' unless filters && filters.size > 0
+      #
+      # The hashes at the :filters key get turned into URL params like:
+      # # filter[field][0]=istestdata&filter[operator][0]=<>&filter[value][0]=1
+      def filters_to_query_string(params = {})
+        return '' unless params && params.size > 0
 
-        params = {}
-        (filters.delete(:filters) || []).each_with_index do |filter, i|
+        params = params.dup
+        url_params = {}
+
+        Array.wrap(params.delete(:filters)).each_with_index do |filter, i|
           fail "Bad filter params: #{filter}" unless filter.is_a?(Hash) && [:field, :operator, :value].all? { |k| filter[k] }
 
-          params["filter[field][#{i}]".to_sym]    = "#{filter[:field]}"
-          params["filter[operator][#{i}]".to_sym] = "#{filter[:operator]}"
-          params["filter[value][#{i}]".to_sym]    = "#{filter[:value]}"
+          url_params["filter[field][#{i}]".to_sym]    = "#{filter[:field]}"
+          url_params["filter[operator][#{i}]".to_sym] = "#{filter[:operator]}"
+          url_params["filter[value][#{i}]".to_sym]    = "#{filter[:value]}"
         end
 
-        uri = Addressable::URI.new
-        uri.query_values = params.merge(filters)
+        uri = Addressable::URI.new(query_values: url_params.merge(params))
         "?#{uri.query}"
       end
 
-      def merge_params(conditions, _deprecated_filters)
-        $stderr.puts('Use of the 2nd hash parameter is deprecated.') unless _deprecated_filters.empty?
-        conditions.merge(_deprecated_filters || {})
+      def logger
+        SurveyGizmo.configuration.logger
       end
     end
 
-    # Save the resource to SurveyGizmo
+    ### BELOW HERE ARE INSTANCE METHODS ###
+
+    # If we have an id, it's an update, because we already know the surveygizmo assigned id
+    # Returns itself if successfully saved, but with attributes (like id) added by SurveyGizmo
     def save
-      if id
-        # Then it's an update, because we already know the surveygizmo assigned id
-        RestResponse.new(SurveyGizmo.post(handle_route(:update), query: attributes_without_blanks))
-      else
-        create_record_in_surveygizmo
-      end
+      method, path = id ? [:post, :update] : [:put, :create]
+      self.attributes = Connection.send(method, create_route(path), attributes_without_blanks).body['data']
+      self
     end
 
     # Repopulate the attributes based on what is on SurveyGizmo's servers
     def reload
-      self.attributes = RestResponse.new(SurveyGizmo.get(handle_route(:get))).data
+      self.attributes = Connection.get(create_route(:get)).body['data']
       self
     end
 
     # Delete the Resource from Survey Gizmo
     def destroy
       fail "No id; can't delete #{self.inspect}!" unless id
-      RestResponse.new(SurveyGizmo.delete(handle_route(:delete)))
-    end
-
-    # Sets the hash that will be used to interpolate values in routes. It needs to be defined per model.
-    # @return [Hash] a hash of the values needed in routing
-    def to_param_options
-      fail "Define #to_param_options in #{self.class.name}"
-    end
-
-    # Returns itself if successfully saved, but with attributes added by SurveyGizmo
-    def create_record_in_surveygizmo(attributes = {})
-      rest_response = RestResponse.new(SurveyGizmo.put(handle_route(:create), query: attributes_without_blanks))
-      self.attributes = rest_response.data
-      self
+      Connection.delete(create_route(:delete))
     end
 
     def inspect
       attribute_strings = self.class.attribute_set.map do |attrib|
         value = self.send(attrib.name)
         value = value.is_a?(Hash) ? value.inspect : value.to_s
-
         "  \"#{attrib.name}\" => \"#{value}\"\n" unless value.strip.blank?
       end.compact
 
       "#<#{self.class.name}:#{self.object_id}>\n#{attribute_strings.join}"
     end
 
-    protected
+    private
 
     def attributes_without_blanks
       attributes.reject { |k,v| v.blank? }
     end
 
-    private
+    # Extract attributes required for API calls about this object
+    def route_params
+      params = { id: id }
+
+      self.class.routes.values.each do |route|
+        route.gsub(/:(\w+)/) do |m|
+          m = m.delete(':').to_sym
+          params[m] = self.send(m)
+        end
+      end
+
+      params
+    end
+
+    # Attributes that should be passed down the object hierarchy - e.g. a Question should have a survey_id
+    # Also used for loading member objects, e.g. loading Options for a given Question.
+    def children_params
+      klass_id = self.class.name.split('::').last.downcase + '_id'
+      route_params.merge(klass_id.to_sym => id).reject { |k,v| k == :id }
+    end
 
-    def handle_route(key)
-      self.class.handle_route!(key, to_param_options)
+    def create_route(method)
+      self.class.create_route(method, route_params)
     end
   end
 end