hubspot-ruby 0.1.8 → 0.2.0

data/lib/hubspot/deal.rb

@@ -56,7 +56,7 @@ module Hubspot
     # {https://developers.hubspot.com/docs/methods/contacts/delete_contact}
     # @return [TrueClass] true
     def destroy!
-      response = Hubspot::Connection.delete_json(DEAL_PATH, {deal_id: deal_id})
+      Hubspot::Connection.delete_json(DEAL_PATH, {deal_id: deal_id})
       @destroyed = true
     end
 
@@ -74,7 +74,7 @@ module Hubspot
     # @return [Hubspot::Deal] self
     def update!(params)
       query = {"properties" => Hubspot::Utils.hash_to_properties(params.stringify_keys!, key_name: 'name')}
-      response = Hubspot::Connection.put_json(UPDATE_DEAL_PATH, params: { deal_id: deal_id }, body: query)
+      Hubspot::Connection.put_json(UPDATE_DEAL_PATH, params: { deal_id: deal_id }, body: query)
       @properties.merge!(params)
       self
     end

data/lib/hubspot/deal_pipeline.rb

@@ -0,0 +1,43 @@
+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
+    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/engagement.rb

@@ -0,0 +1,133 @@
+require 'hubspot/utils'
+
+module Hubspot
+  #
+  # HubSpot Engagements API
+  #
+  # {http://developers.hubspot.com/docs/methods/engagements/create_engagement}
+  #
+  class Engagement
+    CREATE_ENGAGMEMENT_PATH = '/engagements/v1/engagements'
+    ENGAGEMENT_PATH = '/engagements/v1/engagements/:engagement_id'
+    GET_ASSOCIATED_ENGAGEMENTS = '/engagements/v1/engagements/associated/:objectType/:objectId/paged'
+
+    attr_reader :id
+    attr_reader :engagement
+    attr_reader :associations
+    attr_reader :metadata
+
+    def initialize(response_hash)
+
+      @engagement = response_hash["engagement"]
+      @associations = response_hash["associations"]
+      @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 })
+          new(HashWithIndifferentAccess.new(response))
+        rescue Hubspot::RequestError => ex
+          if ex.response.code == 404
+            return nil
+          else
+            raise ex
+          end
+        end
+      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
+    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: engagement,
+        associations: associations,
+        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)
+        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
+
+        super(data)
+      end
+    end
+  end
+end

data/lib/hubspot/exceptions.rb

@@ -15,4 +15,4 @@ module Hubspot
   class ContactExistsError < RequestError; end
   class InvalidParams < StandardError; end
   class ApiError < StandardError; end
-end
+end

data/lib/hubspot/form.rb

@@ -5,16 +5,16 @@ module Hubspot
   # {https://developers.hubspot.com/docs/methods/forms/forms_overview}
   #
   class Form
-  	FORMS_PATH       = '/contacts/v1/forms'
-  	FORM_PATH        = '/contacts/v1/forms/:form_guid'
-  	FIELDS_PATH      = '/contacts/v1/fields/:form_guid'
-  	FIELD_PATH       = FIELDS_PATH + '/:field_name'
-  	SUBMIT_DATA_PATH = '/uploads/form/v2/:portal_id/:form_guid'
+    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)
+        response = Hubspot::Connection.post_json(FORMS_PATH, params: {}, body: opts)
         new(response)
       end
 
@@ -35,7 +35,7 @@ module Hubspot
     attr_reader :properties
 
     def initialize(hash)
-      self.send(:assign_properties, hash)	
+      self.send(:assign_properties, hash)
     end
 
     # {https://developers.hubspot.com/docs/methods/forms/get_fields}
@@ -45,26 +45,26 @@ module Hubspot
       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
+        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?
+        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={})    
+    def submit(opts={})
       response = Hubspot::FormsConnection.submit(SUBMIT_DATA_PATH, params: { form_guid: @guid }, body: opts)
-      [204, 302].include?(response.code)
+      [204, 302, 200].include?(response.code)
     end
 
     # {https://developers.hubspot.com/docs/methods/forms/update_form}
@@ -88,8 +88,8 @@ module Hubspot
 
     def assign_properties(hash)
       @guid = hash['guid']
-      @fields = hash['fields']
+      @fields = hash['formFieldGroups'].inject([]){ |result, fg| result | fg['fields'] }
       @properties = hash
     end
   end
-end
+end

data/lib/hubspot/owner.rb

@@ -0,0 +1,49 @@
+module Hubspot
+  #
+  # HubSpot Owners API
+  #
+  # {http://developers.hubspot.com/docs/methods/owners/get_owners}
+  #
+  # TODO: Create an Owner
+  # TODO: Update an Owner
+  # TODO: Delete an Owner
+  class Owner
+    GET_OWNERS_PATH   = '/owners/v2/owners' # GET
+    CREATE_OWNER_PATH = '/owners/v2/owners' # POST
+    UPDATE_OWNER_PATH = '/owners/v2/owners/:owner_id' # PUT
+    DELETE_OWNER_PATH = '/owners/v2/owners/:owner_id' # DELETE
+
+
+    attr_reader :properties, :owner_id, :email
+
+    def initialize(property_hash)
+      @properties = property_hash
+      @owner_id   = @properties['ownerId']
+      @email      = @properties['email']
+    end
+
+    def [](property)
+      @properties[property]
+    end
+
+    class << self
+      def all(include_inactive=false)
+        path     = GET_OWNERS_PATH
+        params   = { includeInactive: include_inactive }
+        response = Hubspot::Connection.get_json(path, params)
+        response.map { |r| new(r) }
+      end
+
+      def find_by_email(email, include_inactive=false)
+        path     = GET_OWNERS_PATH
+        params   = { email: email, includeInactive: include_inactive }
+        response = Hubspot::Connection.get_json(path, params)
+        response.blank? ? nil : new(response.first)
+      end
+
+      def find_by_emails(emails, include_inactive=false)
+        emails.map { |email| find_by_email(email, include_inactive) }.reject(&:blank?)
+      end
+    end
+  end
+end

data/lib/hubspot/properties.rb

@@ -0,0 +1,119 @@
+module Hubspot
+  class Properties
+
+    PROPERTY_SPECS = {
+      group_field_names: %w(name displayName displayOrder properties),
+      field_names:       %w(name groupName description fieldType formField type displayOrder label options),
+      valid_field_types: %w(textarea select text date file number radio checkbox),
+      valid_types:       %w(string number bool datetime enumeration),
+      options:           %w(description value label hidden displayOrder)
+    }
+
+    class << self
+      # TODO: properties can be set as configuration
+      # TODO: find the way how to set a list of Properties + merge same property key if present from opts
+      def add_default_parameters(opts={})
+        properties = 'email'
+        opts.merge(property: properties)
+      end
+
+      def all(path, opts={}, filter={})
+        response = Hubspot::Connection.get_json(path, opts)
+        filter_results(response, :groupName, filter[:include], filter[:exclude])
+      end
+
+      def groups(path, opts={}, filter={})
+        response = Hubspot::Connection.get_json(path, opts)
+        filter_results(response, :name, filter[:include], filter[:exclude])
+      end
+
+      def create!(path, params={})
+        post_data = valid_property_params(params)
+        return nil if post_data.blank?
+        Hubspot::Connection.post_json(path, params: {}, body: post_data)
+      end
+
+      def update!(path, property_name, params={})
+        post_data = valid_property_params(params)
+        return nil if post_data.blank?
+        Hubspot::Connection.put_json(path, params: { property_name: property_name }, body: post_data)
+      end
+
+      def delete!(path, property_name)
+        response = Hubspot::Connection.delete_json(path, property_name: property_name)
+        response.parsed_response
+      end
+
+      def create_group!(path, params={})
+        post_data = valid_group_params(params)
+        return nil if post_data.blank?
+        Hubspot::Connection.post_json(path, params: {}, body: post_data)
+      end
+
+      def update_group!(path, group_name, params={})
+        post_data = valid_group_params(params)
+        return nil if post_data.blank?
+        Hubspot::Connection.put_json(path, params: { group_name: group_name }, body: post_data)
+      end
+
+      def delete_group!(path, group_name)
+        response = Hubspot::Connection.delete_json(path, group_name: group_name)
+        response.parsed_response
+      end
+
+      def same?(src, dst)
+        src_params = valid_params(src)
+        dst_params = valid_params(dst)
+        src_params.eql?(dst_params)
+        # hash_same?(src_params, dst_params)
+      end
+
+      def valid_params(params={})
+        valid_property_params(params)
+      end
+
+      private
+
+      def filter_results(results, key, include, exclude)
+        key = key.to_s
+        results.select { |result|
+          (include.blank? || include.include?(result[key])) &&
+            (exclude.blank? || !exclude.include?(result[key]))
+        }
+      end
+
+      def valid_property_params(params)
+        return {} if params.blank?
+        result = params.slice(*PROPERTY_SPECS[:field_names])
+        result.delete('fieldType') unless check_field_type(result['fieldType'])
+        result.delete('type') unless check_type(result['type'])
+        result['options'] = valid_option_params(result['options'])
+        result
+      end
+
+      def valid_group_params(params)
+        return {} if params.blank?
+        result = params.slice(*PROPERTY_SPECS[:group_field_names])
+        result['properties'] = valid_property_params(result['properties']) unless result['properties'].blank?
+        result
+      end
+
+      def check_field_type(val)
+        return true if PROPERTY_SPECS[:valid_field_types].include?(val)
+        puts "Invalid field type: #{val}"
+        false
+      end
+
+      def check_type(val)
+        return true if PROPERTY_SPECS[:valid_types].include?(val)
+        puts "Invalid type: #{val}"
+        false
+      end
+
+      def valid_option_params(options)
+        return [] if options.blank?
+        options.map { |o| o.slice(*PROPERTY_SPECS[:options]) }
+      end
+    end
+  end
+end