riq 0.8.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34a510c0f7cad37904ababa9279e498c71e0bb9c
+  data.tar.gz: 661d369470ad7fa0be4588036ab57206f41a4e55
+SHA512:
+  metadata.gz: 71590ee05218590ebb4adc49aebeb462958bf843448d025c466f0b8a53b20ce4b0893d8bf85509790321e8deafc996eda3700ad9a5ad5aa1d8025625d956f386
+  data.tar.gz: c3c788129202330ad448cff886a0981b1a594d4808e806f4f444815aefd5929d990aee56936c4b03b143c7f955b03779f49aace5f6645544ce9a6f2e1aec5e48

data/.gitignore

@@ -0,0 +1,41 @@
+# Created by https://www.gitignore.io
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# test file
+t.rb

data/.yardopts

@@ -0,0 +1,2 @@
+lib/**/*.rb
+--title RelateIQ

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'pry'
+end
+
+gem 'httparty'

data/lib/relateiq.rb

@@ -0,0 +1,3 @@
+# Base file from which everything else is included
+
+Dir[__dir__ + '/relateiq/*.rb'].each {|file| require file }

data/lib/relateiq/account.rb

@@ -0,0 +1,79 @@
+require_relative 'riq_obj'
+
+module RIQ
+  class Account < RIQObject
+    attr_accessor :name
+    attr_accessor :field_values
+
+    # (see RIQObject#node)
+    def node
+      "accounts/#{@id}"
+    end
+
+    # (see #node)
+    def self.node(arg = nil)
+      "accounts"
+    end
+
+    # (see RIQObject#data)
+    def data
+      {
+        id: @id,
+        name: @name,
+        field_values: @field_values
+      }
+    end
+
+    # (see RIQObject#payload)
+    def payload
+      # TODO: find more elegant way to do this
+      pld = data
+      pld['fieldValues'] = to_raw(@field_values)
+      pld.delete(:field_values)
+      pld.to_json
+    end
+
+    # @overload field_value(key)
+    #   @param key [String, Integer] 
+    #   @return [Array] Value of key
+    # @overload field_value(key, value)
+    #   Sets key to value
+    #   @param key [String, Integer] Key to set
+    #   @param value [#to_s] Sets key to value
+    def field_value(key, value = nil)
+      # TODO: double check that this works with arrays of stuff
+      # or, have a format function that casts ints to string on save
+      if value.nil?
+        @field_values.fetch(key.to_s, nil)
+      else
+        @field_values[key.to_s] = value.to_s
+        {key.to_s => value.to_s}
+      end
+    end
+
+    private
+    def init(obj = nil)
+      unless obj.nil?
+        @id = obj['id']
+        @name = obj['name']
+        @field_values = from_raw(obj['fieldValues'])
+      else
+        @id = nil
+        @name = nil
+        @field_values = {}
+      end
+      self
+    end
+
+  end
+
+  class << self
+    # Convenince method to create new Accounts
+    # @param id [String, nil] create a blank Account object or 
+    #   fetch an existing one by id.
+    # @return [RIQ::Account]
+    def account(id = nil)
+      Account.new(id)
+    end
+  end
+end

data/lib/relateiq/batch_manager.rb

@@ -0,0 +1,187 @@
+module RIQ
+  # Manages caching and fetching for a certain type of child
+  class BatchManager
+    attr_reader :fetch_options
+
+    # @param klass [RIQObject] The child class that's being fetched, such as {Account} or {ListItem}
+    # @param page_length [Integer] The number of items per page
+    # @!macro [new] krass
+    #   is a $1
+    def initialize(klass, page_length = 200, fetch_options: {})
+      @klass = klass
+      begin
+        raise unless @klass.ancestors.include? RIQ::RIQObject
+      rescue
+        raise RIQError, 'Must pass a RIQ Class'
+      end
+
+      reset_cache
+      # ruby says that nil is an argument and page_size was getting set to 0
+      @page_length = page_length.nil? ? 200 : page_length
+      @fetch_options = fetch_options
+      @client = RIQ.client
+    end
+
+    # Iterator for each item in the manager. Pass a block to it!
+    def each(&blok)
+      reset_cache
+      loop do
+        x = next_item
+        if x
+          blok.call(x)
+        else
+          return
+        end
+      end
+    end
+
+    # @return [@macro klass]
+    def first
+      reset_cache
+      fetch_page(0, 1).first
+    end
+
+    def fetch_options=(opts = {})
+      reset_cache
+      options = {}
+      opts.each do |k, v|
+        # some args are comma-separated arrays, some are just args
+        if v.is_a? Array
+          options[k] = v.join(',')
+        else
+          options[k] = v
+        end
+      end
+      @fetch_options = options
+    end
+
+    private
+
+    def next_item
+      if @cache_index == @cache.size
+        return nil if ![0, @page_length].include? @cache.size
+        # puts "\n=== fetching page! (#{@page_index}) (#{@page_length})"
+        @cache = fetch_page(@page_index, @page_length)
+        @page_index += @cache.size
+        @cache_index = 0
+      end
+
+      if @cache_index < @cache.size
+        obj = @cache[@cache_index]
+        @cache_index += 1
+        obj
+      else
+        nil
+      end
+    end
+
+    # def fetch_batch(param, values, max_size)
+    #   objects = []
+    #   chunks = []
+    #   (0...values.size).step(max_size) do |i|
+    #     chunks << values[i...i+max_size]
+    #   end
+    #   chunks.each_with_index do |obj, i|
+    #     begin
+    #       set_fetch_options({param: chunk.join(',')})
+    #       objects << fetch_page
+    #     rescue HTTPError => e
+    #       # max url length is 8192 (2^13). If longer, will give a 414 error.
+    #       if [413, 414].include? e.code
+    #         objects << fetch_batch(param, chunk, (max_size/2.0).ceil)
+    #       else
+    #         # raise a certain error?
+    #         raise e
+    #       end
+    #     end
+    #   end
+    #   objects
+    # end
+
+    def fetch_page(index = 0, limit = nil)
+      limit = @page_length if limit.nil?
+
+      @fetch_options[:_start] = index
+      @fetch_options[:_limit] = limit
+
+      # all class#node functions can take an arg, so far, only list items need it. 
+      # having list_id usually be nil (that is, undefined) is fine. probably.
+      data = @client.get(@klass.node(@list_id), options: @fetch_options)
+
+      objects = []
+      data.fetch('objects', []).each do |obj|
+        objects << @klass.new(obj)
+      end
+      objects
+    end
+
+    def reset_cache
+      # shouldn't reset options, that's silly
+      # @fetch_options = {}
+      @cache = []
+      @cache_index = 0
+      @page_index = 0
+    end
+
+    # these used to be 2 methods, now they're one
+    def batch(objs, mode)
+      return_objs = {}
+      while objs.size > 0
+        chunk_size = objs.size > @page_length ? @page_length : objs.size
+        chunk = objs[0...chunk_size]
+        objs = chunk_size < objs.size ? objs[chunk_size..-1] : []
+
+        batch_objs = batch_helper(mode, chunk)
+        return_objs['success_objects'] = batch_objs.fetch('success_objects', [])
+        return_objs['error_objects'] = batch_objs.fetch('error_objects', [])
+      end
+      return_objs
+    end
+
+    def batch_helper(mode, objs)
+      payloads = []
+      objs.each {|o| payloads << o.payload}
+
+      if mode == :create
+        batch_results = @client.post('/createBatch', {objects: payloads})
+      elsif mode == :update
+        batch_results = @client.put('/updateBatch', {objects: payloads})
+      else
+        raise RIQError, 'Invalid Batch Mode'
+      end
+      
+      batch_results['success_objects'] = []
+      batch_results['successObjects'].each do |o| 
+        batch_results['success_objects'] << self.class(o)
+      end
+      
+      batch_results['error_objects'] = []
+      batch_results['errorObjects'].each do |o| 
+        batch_results['error_objects'] << self.class(o)
+      end
+
+      batch_results
+    end
+  end
+
+  class << self
+    # @!macro [new] conv
+    #   Returns an iterator for all $0
+    #   @return [BatchManager] 
+
+    # @macro conv
+    def lists(page_size = nil)
+      BatchManager.new(RIQ::List, page_size)
+    end
+
+    # @macro conv
+    def contacts(page_size = nil)
+      BatchManager.new(RIQ::Contact, page_size)
+    end
+
+    # @macro conv
+    def accounts(page_size = nil)
+      BatchManager.new(RIQ::Account, page_size)
+    end
+  end
+end

data/lib/relateiq/client.rb

@@ -0,0 +1,152 @@
+require 'httparty'
+require 'pry'
+require 'json'
+
+require_relative 'error'
+
+module RIQ
+  # HTTP client responsible for actually handling the HTTP requests.
+  # @note Utility class to perform http requests. This shouldn't be
+  #   instantiated directy but used by children of RIQObject instead.
+  class Client
+    attr_accessor :cache
+
+    def initialize(key, secret)
+      raise 'Missing credentials' if key.nil? || secret.nil?
+
+      @root_url = 'https://api.relateiq.com/v2'
+
+      @auth = {username: key, password: secret}
+      @headers = {
+        'Content-type' => 'application/json', 
+        'Accept' => 'application/json'
+      }
+      @cache = {}
+    end
+      
+    # for caching, used with #next ? 
+    # def store(endpoint, objects)
+      # @cache[endpoint] = objects unless objects.nil?
+    # end
+
+    # Makes a GET request, used for fetching existing objects.
+    # @return (see #request)
+    def get(endpoint, options: nil)
+      request(endpoint, :get, nil, options)
+    end
+
+    # Makes a POST request, used for creating new objects.
+    # @return (see #request)
+    def post(endpoint, body, options: nil)
+      request(endpoint, :post, body, options)
+    end
+
+    # Makes a PUT request, used for updating existing objects.
+    # @return (see #request)
+    def put(endpoint, body, options: nil)
+      request(endpoint, :put, body, options)
+    end
+
+    # Makes a DELETE request, used for deleting existing objects.
+    # @return (see #request)
+    def delete(endpoint, options: nil)
+      request(endpoint, :delete, nil, options)
+    end
+
+    def fetch(endpoint = nil, options: {})
+      # i'm not sure why this would return an empty object instead of raising a notfound
+      # or really, why it exists at all
+      # puts "fetching #{endpoint} with options #{options}"
+      # begin
+      get(endpoint, options: options)
+      # rescue NotFoundError
+        # {}
+      # end
+    end
+
+    private
+
+    # actually does the requesting
+    # @return (see #process_response)
+    def request(endpoint, method = :get, body = nil, options = nil)
+      # there may be a better way to do this, but this is close
+      url = "#{@root_url}/#{endpoint}"
+      # pp "#{method} request to #{url} with body: #{body} and options: #{options}"
+      if [:get, :delete].include? method
+        resp = HTTParty.method(method).call(
+          url, 
+          headers: @headers, 
+          basic_auth: @auth, 
+          query: options
+        )
+      elsif [:post, :put].include? method
+        resp = HTTParty.method(method).call(
+          url, 
+          headers: @headers, 
+          basic_auth: @auth, 
+          query: options, 
+          body: body
+        )
+      else
+        # this shouldn't ever get hit?
+        raise RIQError, 'Invalid method'
+      end
+      
+      # HTTParty response object
+      process_response(resp)
+      # resp
+    end
+
+    # Checks for errors and returns the parsed object
+    # @return [RIQObject] The result of the request
+    def process_response(resp)
+      # pp "processing #{resp}, code: #{resp.code}"
+      # binding.pry
+      if resp.code == 503
+        raise NotImplementedError, 'This function is not currently supported by RelateIQ'
+      elsif resp.code == 404 
+        raise NotFoundError, 'Object Not Found'
+      elsif resp.code >= 400 
+        # Record Response Data
+        raise HTTPError, resp 
+      end
+      # 404 Object not found
+      #    if List, have them check if it is shared
+      # 500
+      # 422
+      # 400 Bad Request - pass on internal message
+      # 502 Bad Gateway - Reattempt
+      
+      # if resp.include? 'objects'
+      #   resp['objects']
+      # else
+      resp.parsed_response
+      # end
+    end
+
+    # Configuration Methods
+    # def fetchConfig
+    #   return get('configs')
+    # end
+  end
+
+  class << self
+    # A singleton client for use by methods in Object.
+    # Always use RIQ.client to retrieve the client object.
+    # @param key [String] RelateIQ API key
+    # @param secret [String] RelateIQ API secret
+    # @return [RIQ] The module, in case you want it.
+    def init(key = nil, secret = nil)
+      key ||= ENV['RIQ_TEST_API_KEY']
+      secret ||= ENV['RIQ_TEST_API_SECRET']
+
+      @@client = Client.new(key, secret)
+      self
+    end
+
+    def client
+      raise RIQError, 'Client not initialized' unless @@client
+      @@client
+    end
+  end
+end