riq 0.9.1 → 1.0.1

data/lib/riq/client.rb

@@ -1,148 +0,0 @@
-require 'httparty'
-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
-
-    # I'm not sure why this would return an empty object instead of raising a notfound
-    # or really, why it exists at all
-    # def fetch(endpoint = nil, 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}"
-      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  
-    # @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
-
-    # Always use RIQ.client to retrieve the client object.
-    # @return [Client] The client object
-    def client
-      raise RIQError, 'Client not initialized' unless @@client
-      @@client
-    end
-  end
-end

data/lib/riq/contact.rb

@@ -1,158 +0,0 @@
-require_relative 'riq_obj'
-using RIQExtensions
-
-module RIQ
-  # Contacts represent people in an Organization’s address book.
-  class Contact < RIQObject
-    attr_accessor :properties
-
-    # (see RIQObject#node)
-    def node
-      self.class.node(@id)
-    end
-
-    # (see RIQObject.node)
-    def self.node(id = nil)
-      "contacts/#{id}"
-    end
-    
-    # (see RIQObject#data)
-    def data
-      {
-        id: @id,
-        properties: @properties
-        # modified_date: @modified_date
-      }
-    end
-
-    # @!macro [new] prop
-    #   @return [Array] all of the values for $0
-    def name
-      get_prop(:name)
-    end
-
-    # @macro prop
-    def phone
-      get_prop(:phone)
-    end
-
-    # @macro prop
-    def email
-      get_prop(:email)
-    end
-
-    # @macro prop
-    def address
-      get_prop(:address)
-    end
-
-    # Adds property with correct scaffolding
-    # @param prop [Symbol] Type Property to add, such as :name or :email
-    # @param val [String, Array] Value(s) to add
-    # @return [Array] Values for that property after the add
-    def add(prop, val)
-      # validate(prop)
-      prop = prop.to_sym
-      @properties[prop] = [] unless @properties.include? prop
-
-      if val.is_a? Array
-        val.each do |i|
-          add(prop, i)
-        end
-        return
-      end
-
-      raise RIQError, 'Values must be strings' unless val.is_a? String
-
-      # don't add duplicate 
-      if @properties[prop].select{|p| p[:value] == val}.empty?
-        @properties[prop] << {value: val, metadata: {}}
-      end
-      send(prop)
-    end
-
-    # Removes property from hash
-    # @param prop [Symbol] Type Property to remove, such as :name or :email
-    # @param val [String, Array] Value(s) to remove
-    # @return [Array] Values for that property after the remove
-    def remove(prop, val)
-      # validate(prop)
-      prop = prop.to_sym
-
-      if val.is_a? Array
-        val.each do |i|
-          remove(prop, i)
-        end
-      end
-
-      if @properties.include? prop
-        @properties[prop] = @properties[prop].reject{|p| p[:value] == val}
-      end
-      send(prop)
-    end
-
-    # Edits an existing object based on matching email(s) or saves a new object
-    # @see RIQObject#save
-    def upsert
-      save({_upsert: 'email'})
-    end
-
-    # @param prop [Symbol] The property to fetch. One of [:name, :phone, :email, :address]
-    # @param val [String] The value to get info on, such as 'name@domain.com'
-    # @return [Hash] metadata and other info about a given property
-    def info(prop, val)
-      # validate(prop)
-
-      @properties[prop].select{|p| p[:value] == val}.first
-    end
-
-    private
-
-    def init(obj = nil)
-      unless obj.nil?
-        @id = obj[:id]
-        @modified_date = obj[:modified_date].cut_milis if obj[:modified_date]
-        @properties = {}
-        obj[:properties].each do |k,v|
-          raise RIQError, "Properties must be arrays, #{k} wasn't" if !v.is_a?(Array)
-
-          v.each do |i|
-            unless i.is_a?(Hash)
-              add(k, i)
-            else
-              @properties[k] = [] unless @properties.include?(k)
-              @properties[k] << i
-            end
-          end
-        end
-      else
-        @id = nil
-        @properties = {}
-      end
-      self
-    end
-
-    # unused because we actually put all sorts of stuff in there
-    def validate(prop)
-      raise RIQError, %q(Invalid property. Use [:name | :phone | :email | :address] instead) unless [:name, :phone, :email, :address].include? prop
-    end
-
-    def get_prop(prop)
-      if @properties.include? prop
-        @properties[prop].map{|p| p[:value]}
-      else
-        []
-      end
-    end
-  end
-
-  class << self
-    # Convenince method to create new Contacts
-    # @param id [String, nil] create a blank Contact object or 
-    #   fetch an existing one by id.
-    # @return [Contact]
-    def contact(id = nil)
-      Contact.new(id)
-    end
-  end
-end

data/lib/riq/error.rb

@@ -1,56 +0,0 @@
-module RIQ
-  # Base exception class for our errors.
-  class RIQError < StandardError
-  end
-
-  # Hasn't been implemented yet. Doesn't get used often.
-  class NotImplementedError < RIQError
-  end
-
-  # Raised when an objectid fetch doesn't return anything.
-  class NotFoundError < RIQError
-  end
-
-  # Main error that includes info about the request and what went wrong. 
-  class HTTPError < RIQError
-    attr_accessor :code
-    attr_accessor :message
-    attr_accessor :response
-
-    def initialize(resp)
-      # build response message
-      message = "\n[#{resp.code}] #{resp.message} : "        
-      unless resp.parsed_response.nil?
-        begin
-          m = resp.parsed_response.fetch('errorMessage', 'no message')
-        rescue
-          # parse returned html
-          reg = resp.parsed_response.match(/<pre>(.*)<\/pre>/)
-          unless reg.nil?
-            m = reg[1].strip
-          else
-            m = 'no message'
-          end
-        end
-        message += "<#{m}>"
-      end
-
-      # pull out request info
-      req = resp.request
-      unless req.nil?
-        message += "\n    Request: #{req.http_method} #{req.last_uri.to_s}"
-        unless req.raw_body.nil?
-          message += "\n    #{req.raw_body}"
-        end
-      end
-
-      @message = message
-      @response = resp
-    end
-
-    # used to print the error nicely
-    def to_s
-      @message || super
-    end
-  end
-end

data/lib/riq/event.rb

@@ -1,165 +0,0 @@
-require_relative 'riq_obj'
-using RIQExtensions
-
-module RIQ
-  # Events represent interactions involving a Contact associated with a List Item. 
-  class Event < RIQObject
-    attr_accessor :subject
-    attr_accessor :body
-    # attr_reader :participant_ids
-
-    # (see RIQObject#node)
-    def node
-      self.class.node
-    end
-
-    # (see RIQObject#node)
-    def self.node
-      "events"
-    end
-    
-    # (see RIQObject#data)
-    def data
-      {
-        subject: @subject,
-        body: @body,
-        participant_ids: @participant_ids
-      }
-    end
-
-    # @param type [Symbol] One of :email or :phone
-    # @param value [String] An email or phone number for the contact
-    def add_participant(type, value)
-      raise RIQError, 'Type must be :email or :phone' unless [:email, :phone].include?(type)
-      @participant_ids << {type: type, value: value}
-    end
-
-    # @return [Array] Immutable copy of participant_ids
-    def participant_ids
-      @participant_ids.dup
-    end
-
-    # @return [Hash] Success message, if successul. 
-    def save
-      # there are no options to pass for event save
-      @client.put(node, payload, options: nil)
-      {status: 204, message: 'No Content'}
-    end
-
-    private
-    def init(obj = nil)
-      unless obj.nil?
-        @subject = obj[:subject]
-        @body = obj[:body]
-        @participant_ids = []
-        obj[:participant_ids].each{|o| add_participant(o[:type], o[:value])}
-      else
-        @subject = nil
-        @body = nil
-        @participant_ids = []
-      end
-      self
-    end
-  end
-
-  class << self
-    # Convenience method to create new Events
-    # @param obj [Hash] Info to parse into event
-    # @return [Event]
-    def event(obj = nil)
-      Event.new(obj)
-    end
-  end
-end
-
-#   @id = nil
-#   @modifiedDate = nil
-#   @participantIds = nil
-#   @subject = nil
-#   @body = nil
-
-#   def initialize(
-#       _id=nil,
-#       subject=nil,
-#       body=nil,
-#       participantIds=nil,
-#       data:nil,
-#       hash:nil
-#     )
-#     if !data.nil?
-#       parse(data)
-#     elsif !hash.nil?
-#       process_hash(hash)
-#     elsif !id(_id).nil?
-#       Event::get(self)
-#     end
-#     participantIds(participantIds)
-#     subject(subject)
-#     body(body)
-#   end
-
-#   class << self
-#     def node
-#       'events'
-#     end
-
-#     def factory(data = nil, hash = nil)
-#       return Event.new(data, hash)
-#     end
-
-#     def update(instance, options = {})
-#       response = Client::put(self.endpoint(), instance.payload(), options)
-#       return instance
-#     end
-#   end
-
-#   def parse(data)
-#     obj = JSON.parse(data.body)
-#     id(obj['id'])
-#     modifiedDate(obj['modifiedDate'])
-#   end
-
-#   def process_hash(hash)
-#     id(hash['id'])
-#     modifiedDate(hash['modifiedDate'])
-#   end
-
-#   # Data Payload
-#   def payload()
-#     payload = {:participantIds => @participantIds,
-#       :subject => subject(),
-#       :body => body()
-#     }
-#     if modifiedDate() then
-#       payload['modifiedDate'] = modifiedDate()
-#     end
-#     payload['id'] = id() if id()
-#     return payload
-#   end
-
-#   # Hybrid
-#   def id(value = nil)
-#     @id = value unless value.nil?
-#   end
-
-#   def modifiedDate(value = nil)
-#     @modifiedDate = value unless value.nil?
-#   end
-
-#   def subject(value = nil)
-#     @subject = value unless value.nil?
-#   end
-
-#   # value should either be a string or a list of strings
-#   # returns: if multiple values exist for key, a list of strings of values
-#   #          if a single value exists, return the single string value (not in a list)
-#   #          if no values exist, return nil
-#   def participantIds(value = nil)
-#     # set value if passed in
-#     @participantIds = value unless value.nil?
-#   end
-
-#   def body(value=nil)
-#     @body = value unless value.nil?
-#   end
-# end