hubspot-api-ruby 0.8.0

data/lib/hubspot/deal_pipeline.rb

@@ -0,0 +1,58 @@
+require 'hubspot/utils'
+
+module Hubspot
+  #
+  # HubSpot Deals API
+  #
+  # {http://developers.hubspot.com/docs/methods/deal-pipelines/overview}
+  #
+  class DealPipeline
+    PIPELINES_PATH = "/deals/v1/pipelines"
+    PIPELINE_PATH = "/deals/v1/pipelines/:pipeline_id"
+
+    attr_reader :active
+    attr_reader :display_order
+    attr_reader :label
+    attr_reader :pipeline_id
+    attr_reader :stages
+
+    def initialize(response_hash)
+      @active = response_hash["active"]
+      @display_order = response_hash["displayOrder"]
+      @label = response_hash["label"]
+      @pipeline_id = response_hash["pipelineId"]
+      @stages = response_hash["stages"]
+    end
+
+    class << self
+      def find(pipeline_id)
+        response = Hubspot::Connection.get_json(PIPELINE_PATH, { pipeline_id: pipeline_id })
+        new(response)
+      end
+
+      def all
+        response = Hubspot::Connection.get_json(PIPELINES_PATH, {})
+        response.map { |p| new(p) }
+      end
+
+      # Creates a DealPipeline
+      # {https://developers.hubspot.com/docs/methods/deal-pipelines/create-deal-pipeline}
+      # @return [Hubspot::PipeLine] Company record
+      def create!(post_data={})
+        response = Hubspot::Connection.post_json(PIPELINES_PATH, params: {}, body: post_data)
+        new(response)
+      end
+    end
+
+    # Destroys deal_pipeline
+    # {http://developers.hubspot.com/docs/methods/companies/delete_company}
+    # @return [TrueClass] true
+    def destroy!
+      Hubspot::Connection.delete_json(PIPELINE_PATH, pipeline_id: @pipeline_id)
+    end
+
+    def [](stage)
+      @stages[stage]
+    end
+  end
+end

data/lib/hubspot/deal_properties.rb

@@ -0,0 +1,59 @@
+module Hubspot
+  class DealProperties < Properties
+
+    ALL_PROPERTIES_PATH  = '/deals/v1/properties'
+    ALL_GROUPS_PATH      = '/deals/v1/groups'
+    CREATE_PROPERTY_PATH = '/deals/v1/properties/'
+    UPDATE_PROPERTY_PATH = '/deals/v1/properties/named/:property_name'
+    DELETE_PROPERTY_PATH = '/deals/v1/properties/named/:property_name'
+    CREATE_GROUP_PATH    = '/deals/v1/groups/'
+    UPDATE_GROUP_PATH    = '/deals/v1/groups/named/:group_name'
+    DELETE_GROUP_PATH    = '/deals/v1/groups/named/:group_name'
+
+    class << self
+      def add_default_parameters(opts={})
+        superclass.add_default_parameters(opts)
+      end
+
+      def all(opts={}, filter={})
+        superclass.all(ALL_PROPERTIES_PATH, opts, filter)
+      end
+
+      def groups(opts={}, filter={})
+        superclass.groups(ALL_GROUPS_PATH, opts, filter)
+      end
+
+      def create!(params={})
+        superclass.create!(CREATE_PROPERTY_PATH, params)
+      end
+
+      def update!(property_name, params={})
+        superclass.update!(UPDATE_PROPERTY_PATH, property_name, params)
+      end
+
+      def delete!(property_name)
+        superclass.delete!(DELETE_PROPERTY_PATH, property_name)
+      end
+
+      def create_group!(params={})
+        superclass.create_group!(CREATE_GROUP_PATH, params)
+      end
+
+      def update_group!(group_name, params={})
+        superclass.update_group!(UPDATE_GROUP_PATH, group_name, params)
+      end
+
+      def delete_group!(group_name)
+        superclass.delete_group!(DELETE_GROUP_PATH, group_name)
+      end
+
+      def same?(src, dst)
+        superclass.same?(src, dst)
+      end
+
+      def valid_params(params)
+        superclass.valid_params(params)
+      end
+    end
+  end
+end

data/lib/hubspot/deprecator.rb

@@ -0,0 +1,7 @@
+module Hubspot
+  class Deprecator
+    def self.build(version: "1.0")
+      ActiveSupport::Deprecation.new(version, "hubspot-api-ruby")
+    end
+  end
+end

data/lib/hubspot/engagement.rb

@@ -0,0 +1,222 @@
+require 'hubspot/utils'
+
+module Hubspot
+  #
+  # HubSpot Engagements API
+  #
+  # {http://developers.hubspot.com/docs/methods/engagements/create_engagement}
+  #
+  class Engagement
+    ALL_ENGAGEMENTS_PATH = '/engagements/v1/engagements/paged'
+    RECENT_ENGAGEMENT_PATH = '/engagements/v1/engagements/recent/modified'
+    CREATE_ENGAGMEMENT_PATH = '/engagements/v1/engagements'
+    ENGAGEMENT_PATH = '/engagements/v1/engagements/:engagement_id'
+    ASSOCIATE_ENGAGEMENT_PATH = '/engagements/v1/engagements/:engagement_id/associations/:object_type/:object_vid'
+    GET_ASSOCIATED_ENGAGEMENTS = '/engagements/v1/engagements/associated/:objectType/:objectId/paged'
+
+    attr_reader :id
+    attr_reader :engagement
+    attr_reader :associations
+    attr_reader :attachments
+    attr_reader :metadata
+
+    def initialize(response_hash)
+
+      @engagement = response_hash["engagement"]
+      @associations = response_hash["associations"]
+      @attachments = response_hash["attachments"]
+      @metadata = response_hash["metadata"]
+      @id = engagement["id"]
+    end
+
+    class << self
+      def create!(params={})
+        response = Hubspot::Connection.post_json(CREATE_ENGAGMEMENT_PATH, params: {}, body: params )
+        new(HashWithIndifferentAccess.new(response))
+      end
+
+      def find(engagement_id)
+        begin
+          response = Hubspot::Connection.get_json(ENGAGEMENT_PATH, { engagement_id: engagement_id })
+          response ? new(HashWithIndifferentAccess.new(response)) : nil
+        rescue Hubspot::RequestError => ex
+          if ex.response.code == 404
+            return nil
+          else
+            raise ex
+          end
+        end
+      end
+
+      def all(opts = {})
+        path = ALL_ENGAGEMENTS_PATH
+
+        response = Hubspot::Connection.get_json(path, opts)
+
+        result = {}
+        result['engagements'] = response['results'].map { |d| new(d) }
+        result['offset'] = response['offset']
+        result['hasMore'] = response['hasMore']
+        return result
+      end
+
+      def recent(opts = {})
+        path = RECENT_ENGAGEMENT_PATH
+
+        response = Hubspot::Connection.get_json(path, opts)
+
+        result = {}
+        result['engagements'] = response['results'].map { |d| new(d) }
+        result['offset'] = response['offset']
+        result['hasMore'] = response['hasMore']
+        result
+      end
+
+      def find_by_company(company_id)
+        find_by_association company_id, 'COMPANY'
+      end
+
+      def find_by_contact(contact_id)
+        find_by_association contact_id, 'CONTACT'
+      end
+
+      def find_by_association(association_id, association_type)
+        path = GET_ASSOCIATED_ENGAGEMENTS
+        params = { objectType: association_type, objectId: association_id }
+        raise Hubspot::InvalidParams, 'expecting Integer parameter' unless association_id.try(:is_a?, Integer)
+        raise Hubspot::InvalidParams, 'expecting String parameter' unless association_type.try(:is_a?, String)
+
+        engagements = []
+        begin
+          response = Hubspot::Connection.get_json(path, params)
+          engagements = response["results"].try(:map) { |engagement| new(engagement) }
+        rescue => e
+          raise e unless e.message =~ /not found/
+        end
+        engagements
+      end
+
+      # Associates an engagement with an object
+      # {https://developers.hubspot.com/docs/methods/engagements/associate_engagement}
+      # @param engagement_id [int] id of the engagement to associate
+      # @param object_type [string] one of contact, company, or deal
+      # @param object_vid [int] id of the contact, company, or deal to associate
+      def associate!(engagement_id, object_type, object_vid)
+        Hubspot::Connection.put_json(ASSOCIATE_ENGAGEMENT_PATH,
+                                     params: {
+                                       engagement_id: engagement_id,
+                                       object_type: object_type,
+                                       object_vid: object_vid
+                                     })
+      end
+    end
+
+    # Archives the engagement in hubspot
+    # {http://developers.hubspot.com/docs/methods/engagements/delete-engagement}
+    # @return [TrueClass] true
+    def destroy!
+      Hubspot::Connection.delete_json(ENGAGEMENT_PATH, {engagement_id: id})
+      @destroyed = true
+    end
+
+    def destroyed?
+      !!@destroyed
+    end
+
+    def [](property)
+      @properties[property]
+    end
+
+    # Updates the properties of an engagement
+    # {http://developers.hubspot.com/docs/methods/engagements/update_engagement}
+    # @param params [Hash] hash of properties to update
+    # @return [Hubspot::Engagement] self
+    def update!(params)
+      data = {
+        engagement: params[:engagement]     || engagement,
+        associations: params[:associations] || associations,
+        attachments: params[:attachments]   || attachments,
+        metadata: params[:metadata]         || metadata
+      }
+
+      Hubspot::Connection.put_json(ENGAGEMENT_PATH, params: { engagement_id: id }, body: data)
+      self
+    end
+  end
+
+  class EngagementNote < Engagement
+    def body
+      metadata['body']
+    end
+
+    def contact_ids
+      associations['contactIds']
+    end
+
+    class << self
+      def create!(contact_id, note_body, owner_id = nil, deal_id = nil)
+        data = {
+          engagement: {
+            type: 'NOTE'
+          },
+          associations: {
+            contactIds: [contact_id]
+          },
+          metadata: {
+            body: note_body
+          }
+        }
+
+        # if the owner id has been provided, append it to the engagement
+        data[:engagement][:owner_id] = owner_id if owner_id
+        # if the deal id has been provided, associate the note with the deal
+        data[:associations][:dealIds] = [deal_id] if deal_id
+
+        super(data)
+      end
+    end
+  end
+
+  class EngagementCall < Engagement
+    def body
+      metadata['body']
+    end
+
+    def contact_ids
+      associations['contactIds']
+    end
+
+    def company_ids
+      associations['companyIds']
+    end
+
+    def deal_ids
+      associations['dealIds']
+    end
+
+    class << self
+      def create!(contact_vid, body, duration, owner_id = nil, deal_id = nil, status = 'COMPLETED', time = nil)
+        data = {
+          engagement: {
+            type: 'CALL'
+          },
+          associations: {
+            contactIds: [contact_vid],
+            dealIds: [deal_id],
+            ownerIds: [owner_id]
+          },
+          metadata: {
+            body: body,
+            status: status,
+            durationMilliseconds: duration
+          }
+        }
+
+        data[:engagement][:timestamp] = (time.to_i) * 1000 if time
+        data[:engagement][:owner_id] = owner_id if owner_id
+
+        super(data)
+      end
+    end
+  end
+end

data/lib/hubspot/event.rb

@@ -0,0 +1,21 @@
+require 'hubspot/utils'
+
+module Hubspot
+  #
+  # HubSpot Events HTTP API
+  #
+  # {https://developers.hubspot.com/docs/methods/enterprise_events/http_api}
+  #
+  class Event
+    POST_EVENT_PATH = '/v1/event'
+
+    class << self
+      def trigger(event_id, email, options = {})
+        default_params = { _n: event_id, _a: Hubspot::Config.portal_id, email: email }
+        options[:params] = default_params.merge(options[:params] || {})
+
+        Hubspot::EventConnection.trigger(POST_EVENT_PATH, options).success?
+      end
+    end
+  end
+end

data/lib/hubspot/exceptions.rb

@@ -0,0 +1,18 @@
+module Hubspot
+  class RequestError < StandardError
+    attr_accessor :response
+
+    def initialize(response, message=nil)
+      message += "\n" if message
+      me = super("#{message}Response body: #{response.body}",)
+      me.response = response
+      return me
+    end
+  end
+
+  class ConfigurationError < StandardError; end
+  class MissingInterpolation < StandardError; end
+  class ContactExistsError < RequestError; end
+  class InvalidParams < StandardError; end
+  class ApiError < StandardError; end
+end

data/lib/hubspot/file.rb

@@ -0,0 +1,38 @@
+require 'hubspot/utils'
+require 'base64'
+require 'pp'
+
+module Hubspot
+  #
+  # HubSpot Files API
+  #
+  # {https://developers.hubspot.com/docs/methods/files/post_files}
+  #
+  class File
+    GET_FILE_PATH    = "/filemanager/api/v2/files/:file_id"
+    DELETE_FILE_PATH = "/filemanager/api/v2/files/:file_id/full-delete" 
+    LIST_FILE_PATH   = "/filemanager/api/v2/files"
+
+    attr_reader :id
+    attr_reader :properties
+
+    def initialize(response_hash)
+      @id = response_hash["id"]
+      @properties = response_hash
+    end
+
+    class << self
+      def find_by_id(file_id)
+        response = Hubspot::Connection.get_json(GET_FILE_PATH, { file_id: file_id })
+	new(response)
+      end
+    end
+
+    # Permanently delete a file and all related data and thumbnails from file manager.
+    # {https://developers.hubspot.com/docs/methods/files/hard_delete_file_and_associated_objects}
+    def destroy!
+      Hubspot::Connection.post_json(DELETE_FILE_PATH, params: {file_id: id})
+    end
+
+  end
+end

data/lib/hubspot/form.rb

@@ -0,0 +1,95 @@
+module Hubspot
+  #
+  # HubSpot Form API
+  #
+  # {https://developers.hubspot.com/docs/methods/forms/forms_overview}
+  #
+  class Form
+    FORMS_PATH       = '/forms/v2/forms' # '/contacts/v1/forms'
+    FORM_PATH        = '/forms/v2/forms/:form_guid' # '/contacts/v1/forms/:form_guid'
+    FIELDS_PATH      = '/forms/v2/fields/:form_guid' # '/contacts/v1/fields/:form_guid'
+    FIELD_PATH       = FIELDS_PATH + '/:field_name'
+    SUBMIT_DATA_PATH = '/uploads/form/v2/:portal_id/:form_guid'
+
+    class << self
+      # {https://developers.hubspot.com/docs/methods/forms/create_form}
+      def create!(opts={})
+        response = Hubspot::Connection.post_json(FORMS_PATH, params: {}, body: opts)
+        new(response)
+      end
+
+      def all
+        response = Hubspot::Connection.get_json(FORMS_PATH, {})
+        response.map { |f| new(f) }
+      end
+
+      # {https://developers.hubspot.com/docs/methods/forms/get_form}
+      def find(guid)
+        response = Hubspot::Connection.get_json(FORM_PATH, { form_guid: guid })
+        new(response)
+      end
+    end
+
+    attr_reader :guid
+    attr_reader :fields
+    attr_reader :properties
+
+    def initialize(hash)
+      self.send(:assign_properties, hash)
+    end
+
+    # {https://developers.hubspot.com/docs/methods/forms/get_fields}
+    # {https://developers.hubspot.com/docs/methods/forms/get_field}
+    def fields(opts={})
+      bypass_cache = opts.delete(:bypass_cache) { false }
+      field_name = opts.delete(:only) { nil }
+
+      if field_name
+        field_name = field_name.to_s
+        if bypass_cache || @fields.nil? || @fields.empty?
+          response = Hubspot::Connection.get_json(FIELD_PATH, { form_guid: @guid, field_name: field_name })
+          response
+        else
+          @fields.detect { |f| f['name'] == field_name }
+        end
+      else
+        if bypass_cache || @fields.nil? || @fields.empty?
+          response = Hubspot::Connection.get_json(FIELDS_PATH, { form_guid: @guid })
+          @fields = response
+        end
+        @fields
+      end
+    end
+
+    # {https://developers.hubspot.com/docs/methods/forms/submit_form}
+    def submit(opts={})
+      response = Hubspot::FormsConnection.submit(SUBMIT_DATA_PATH, params: { form_guid: @guid }, body: opts)
+      [204, 302, 200].include?(response.code)
+    end
+
+    # {https://developers.hubspot.com/docs/methods/forms/update_form}
+    def update!(opts={})
+      response = Hubspot::Connection.post_json(FORM_PATH, params: { form_guid: @guid }, body: opts)
+      self.send(:assign_properties, response)
+      self
+    end
+
+    # {https://developers.hubspot.com/docs/methods/forms/delete_form}
+    def destroy!
+      response = Hubspot::Connection.delete_json(FORM_PATH, { form_guid: @guid })
+      @destroyed = (response.code == 204)
+    end
+
+    def destroyed?
+      !!@destroyed
+    end
+
+    private
+
+    def assign_properties(hash)
+      @guid = hash['guid']
+      @fields = (hash['formFieldGroups'] || []).inject([]) { |result, fg| result | fg['fields'] }
+      @properties = hash
+    end
+  end
+end