riq 1.0.1 → 1.0.2

data/lib/riq/contact.rb

@@ -0,0 +1,158 @@
+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
+    # Convenience 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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,73 @@
+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 successful. 
+    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

data/lib/riq/list.rb

@@ -0,0 +1,89 @@
+require_relative 'riq_obj'
+
+module RIQ
+  # A List is an object that can be created and customized by a User to represent 
+  # Accounts (companies) or Contacts (people) in a process (such as a sales pipeline).
+  class List < RIQObject
+    # can't create a list through API, so these don't need to write
+    attr_reader :title
+    attr_reader :type
+    attr_reader :list_items
+    # for consistency
+    alias_method :name, :title
+
+    # (see RIQObject#initialize)
+    def initialize(id = nil)
+      super
+      @list_items = ListItemManager.new(@id)
+    end
+
+    # (see RIQObject#node)
+    def node
+      self.class.node(@id)
+    end
+
+    # (see RIQObject.node)
+    def self.node(id = nil)
+      "lists/#{id}"
+    end
+
+    # (see RIQObject#data)
+    def data
+      {
+        id: @id,
+        title: @title,
+        type: @type,
+        fields: @fields
+      }
+    end
+
+    # Overwriting parent because lists can't be saved through the API
+    def save
+      raise NotImplementedError, "Lists can't be edited through the API"
+    end
+
+    # Gets field if it exists
+    # @param id [String, Integer] field ID
+    # @return [Hash, nil] info on the field specified
+    def fields(id = nil)
+      unless id.nil?
+        @fields.select{|f| f['id'] == id.to_s}.first
+      else
+        @fields
+      end
+    end
+
+    # Convenience method for fetching or creating a listitem from the given list
+    # @param oid [String, nil] ObjectId
+    def list_item(oid = nil)
+      RIQ::ListItem.new(oid, lid: @id)
+    end
+
+    private
+    
+    def init(obj = nil)
+      unless obj.nil?
+        @id = obj[:id]
+        @title = obj[:title]
+        @type = obj[:listType]
+        @fields = obj[:fields]
+      else
+        @id = nil
+        @title = nil
+        @type = nil
+        @fields = nil
+      end
+      self
+    end
+  end
+
+  class << self
+    # Convenience method to create new Lists
+    # @param id [String, nil] create a blank List object or 
+    #   fetch an existing one by id.
+    # @return [List]
+    def list(id = nil)
+      List.new(id)
+    end
+  end
+end

data/lib/riq/list_item.rb

@@ -0,0 +1,119 @@
+require_relative 'riq_obj'
+using RIQExtensions
+
+module RIQ
+  # A List Item is a row in a List.
+  class ListItem < RIQObject
+    attr_accessor :name
+    attr_accessor :field_values
+    attr_accessor :account_id
+    attr_accessor :contact_ids
+    attr_accessor :list_id
+
+    attr_reader :modified_date
+    attr_reader :created_date
+
+    def initialize(id = nil, lid: nil)
+      if id.is_a? Hash
+        super(id)
+      elsif id.nil? && lid.nil?
+        super(nil)
+      elsif id.nil? && !lid.nil?
+        super(nil)
+        @list_id = lid
+      elsif id.nil? || lid.nil?
+        raise RIQError, 'ObjectID and List ID are required'
+      else
+        super("#{lid}/listitems/#{id}")
+      end
+    end
+
+    # (see RIQObject#node)
+    def node
+      self.class.node(@list_id, @id)
+    end
+
+    # @note this is the only object for which you have to include two params
+    # @param lid [String] ListId that the lit item belongs to
+    # @param oid [String] ObjectId for the object
+    def self.node(lid = nil, oid = nil)
+      # weird workaround for fetching node on init
+      if lid.nil? && !oid.nil?
+        "lists/#{oid}"
+      else  
+        "lists/#{lid || @list_id}/listitems/#{oid}"
+      end
+    end
+
+    # (see RIQObject#data)
+    def data
+      {
+        name: @name,
+        account_id: @account_id,
+        contact_ids: @contact_ids.flatten,
+        id: @id,
+        list_id: @list_id,
+        field_values: @field_values,
+        modified_date: @modified_date
+      }
+    end
+
+    # (see RIQObject#payload)
+    def payload
+      pld = {}
+      data.each do |k, v|
+        if k == :field_values
+          pld['fieldValues'] = @field_values.to_raw
+        elsif k['_']
+          pld[k.to_cam] = v
+        else
+          pld[k] = v
+        end
+      end
+      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_sym, nil)
+      else
+        @field_values[key.to_sym] = value.to_s
+        {key.to_sym => value.to_s}
+      end
+    end
+
+    private
+
+    def init(obj = nil)
+      unless obj.nil?
+        @id = obj[:id]
+        @list_id = obj[:list_id]
+        @name = obj[:name]
+        @field_values = obj[:field_values] ? obj[:field_values].from_raw : {}
+        @account_id = obj[:account_id]
+        @contact_ids = obj[:contact_ids] || []
+        @modified_date = obj[:modified_date].cut_milis if obj[:modified_date]
+        @created_date = obj[:creaeted_date].cut_milis if obj[:creaeted_date]
+      else
+        @id = nil
+        @list_id = nil
+        @name = nil
+        @field_values = {}
+        @account_id = nil
+        @contact_ids = []
+        @modified_date = nil
+        @created_date = nil
+      end
+      self
+    end
+  end
+end