hubspot-api-ruby 0.8.0

data/lib/hubspot/blog.rb

@@ -0,0 +1,98 @@
+module Hubspot
+  #
+  # HubSpot Contacts API
+  #
+  class Blog
+    BLOG_LIST_PATH = "/content/api/v2/blogs"
+    BLOG_POSTS_PATH = "/content/api/v2/blog-posts"
+    GET_BLOG_BY_ID_PATH = "/content/api/v2/blogs/:blog_id"
+
+    class << self
+      # Lists the blogs
+      # {https://developers.hubspot.com/docs/methods/blogv2/get_blogs}
+      # No param filtering is currently implemented
+      # @return [Hubspot::Blog] the first 20 blogs or empty_array
+      def list
+        response = Hubspot::Connection.get_json(BLOG_LIST_PATH, {})
+        response['objects'].map { |b| new(b) }
+      end
+
+      # Finds a specific blog by its ID
+      # {https://developers.hubspot.com/docs/methods/blogv2/get_blogs_blog_id}
+      # @return Hubspot::Blog
+      def find_by_id(id)
+        response = Hubspot::Connection.get_json(GET_BLOG_BY_ID_PATH, { blog_id: id })
+        new(response)
+      end
+    end
+
+    attr_reader :properties
+
+    def initialize(response_hash)
+      @properties = response_hash #no need to parse anything, we have properties
+    end
+
+    def [](property)
+      @properties[property]
+    end
+
+
+    # Returns the posts for this blog instance.
+    #   defaults to returning the last 2 months worth of published blog posts
+    #   in date descending order (i.e. most recent first)
+    # {https://developers.hubspot.com/docs/methods/blogv2/get_blog_posts}
+    # @return [Hubspot::BlogPost]
+    def posts(params = {})
+      default_params = {
+        content_group_id: self["id"],
+        order_by: '-created',
+        created__gt: Time.now - 2.month,
+        state: 'PUBLISHED'
+      }
+      raise Hubspot::InvalidParams.new('params must be passed as a hash') unless params.is_a?(Hash)
+      params = default_params.merge(params)
+
+      raise Hubspot::InvalidParams.new('State parameter was invalid') unless [false, 'PUBLISHED', 'DRAFT'].include?(params[:state])
+      params.each { |k, v| params.delete(k) if v == false }
+
+      response = Hubspot::Connection.get_json(BLOG_POSTS_PATH, params)
+      response['objects'].map { |p| BlogPost.new(p) }
+    end
+  end
+
+  class BlogPost
+    GET_BLOG_POST_BY_ID_PATH = "/content/api/v2/blog-posts/:blog_post_id"
+
+    # Returns a specific blog post by ID
+    # {https://developers.hubspot.com/docs/methods/blogv2/get_blog_posts_blog_post_id}
+    # @return Hubspot::BlogPost
+    def self.find_by_blog_post_id(id)
+      response = Hubspot::Connection.get_json(GET_BLOG_POST_BY_ID_PATH, { blog_post_id: id })
+      new(response)
+    end
+
+    def initialize(response_hash)
+      @properties = response_hash #no need to parse anything, we have properties
+    end
+
+    def [](property)
+      @properties[property]
+    end
+
+    def created_at
+      Time.at(@properties['created'] / 1000)
+    end
+
+    def topics
+      @topics ||= begin
+        if @properties['topic_ids'].empty?
+          []
+        else
+          @properties['topic_ids'].map do |topic_id|
+            Hubspot::Topic.find_by_topic_id(topic_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hubspot/collection.rb

@@ -0,0 +1,41 @@
+class Hubspot::Collection
+  def initialize(opts = {}, &block)
+    @options = opts
+    @fetch_proc = block
+    fetch
+  end
+
+  def refresh
+    fetch
+    self
+  end
+
+  def resources
+    @resources
+  end
+
+  def update_all(opts = {})
+    return true if empty?
+
+    # This assumes that all resources are the same type
+    resource_class = resources.first.class
+    unless resource_class.respond_to?(:batch_update)
+      raise "#{resource_class} does not support bulk update"
+    end
+
+    resource_class.batch_update(resources, opts)
+  end
+
+protected
+  def fetch
+    @resources = @fetch_proc.call(@options)
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    @resources.respond_to?(name, include_private)
+  end
+
+  def method_missing(method, *args, &block)
+    @resources.public_send(method, *args, &block)
+  end
+end

data/lib/hubspot/company.rb

@@ -0,0 +1,160 @@
+class Hubspot::Company < Hubspot::Resource
+  self.id_field = "companyId"
+  self.property_name_field = "name"
+
+  ADD_CONTACT_PATH        = '/companies/v2/companies/:id/contacts/:contact_id'
+  ALL_PATH                = '/companies/v2/companies/paged'
+  BATCH_UPDATE_PATH       = '/companies/v1/batch-async/update'
+  CONTACTS_PATH           = '/companies/v2/companies/:id/contacts'
+  CONTACT_IDS_PATH        = '/companies/v2/companies/:id/vids'
+  CREATE_PATH             = '/companies/v2/companies/'
+  DELETE_PATH             = '/companies/v2/companies/:id'
+  FIND_PATH               = '/companies/v2/companies/:id'
+  RECENTLY_CREATED_PATH   = '/companies/v2/companies/recent/created'
+  RECENTLY_MODIFIED_PATH  = '/companies/v2/companies/recent/modified'
+  REMOVE_CONTACT_PATH     = '/companies/v2/companies/:id/contacts/:contact_id'
+  SEARCH_DOMAIN_PATH      = '/companies/v2/domains/:domain/companies'
+  UPDATE_PATH             = '/companies/v2/companies/:id'
+
+  class << self
+    def all(opts = {})
+      Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+        response = Hubspot::Connection.get_json(
+          ALL_PATH,
+          options.merge(offset: offset, limit: limit)
+        )
+
+        companies = response["companies"].map { |result| from_result(result) }
+
+        [companies, response["offset"], response["has-more"]]
+      end
+    end
+
+    def search_domain(domain, opts = {})
+      Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+        request = {
+          "limit" => limit,
+          "requestOptions" => options,
+          "offset" => {
+            "isPrimary" => true,
+            "companyId" => offset
+          }
+        }
+
+        response = Hubspot::Connection.post_json(
+          SEARCH_DOMAIN_PATH,
+          params: { domain: domain },
+          body: request
+        )
+
+        companies = response["results"].map { |result| from_result(result) }
+
+        [companies, response["offset"]["companyId"], response["hasMore"]]
+      end
+    end
+
+    def recently_created(opts = {})
+      Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+        response = Hubspot::Connection.get_json(
+          RECENTLY_CREATED_PATH,
+          {offset: offset, count: limit}
+        )
+
+        companies = response["results"].map { |result| from_result(result) }
+
+        [companies, response["offset"], response["hasMore"]]
+      end
+    end
+
+    def recently_modified(opts = {})
+      Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+        response = Hubspot::Connection.get_json(
+          RECENTLY_MODIFIED_PATH,
+          {offset: offset, count: limit}
+        )
+
+        companies = response["results"].map { |result| from_result(result) }
+
+        [companies, response["offset"], response["hasMore"]]
+      end
+    end
+
+    def add_contact(id, contact_id)
+      Hubspot::Connection.put_json(
+        ADD_CONTACT_PATH,
+        params: { id: id, contact_id: contact_id }
+      )
+      true
+    end
+
+    def remove_contact(id, contact_id)
+      Hubspot::Connection.delete_json(
+        REMOVE_CONTACT_PATH,
+        { id: id, contact_id: contact_id }
+      )
+
+      true
+    end
+
+    def batch_update(companies, opts = {})
+      request = companies.map do |company|
+        # Use the specified options or update with the changes
+        changes = opts.empty? ? company.changes : opts
+
+        unless changes.empty?
+          {
+            "objectId" => company.id,
+            "properties" => changes.map { |k, v| { "name" => k, "value" => v } }
+          }
+        end
+      end
+
+      # Remove any objects without changes and return if there is nothing to update
+      request.compact!
+      return true if request.empty?
+
+      Hubspot::Connection.post_json(
+        BATCH_UPDATE_PATH,
+        params: {},
+        body: request
+      )
+
+      true
+    end
+  end
+
+  def contacts(opts = {})
+    Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+      response = Hubspot::Connection.get_json(
+        CONTACTS_PATH,
+        {"id" => @id, "vidOffset" => offset, "count" => limit}
+      )
+
+      contacts = response["contacts"].map do |result|
+        result["properties"] = Hubspot::Utils.properties_array_to_hash(result["properties"])
+        Hubspot::Contact.from_result(result)
+      end
+
+      [contacts, response["vidOffset"], response["hasMore"]]
+    end
+  end
+
+  def contact_ids(opts = {})
+    Hubspot::PagedCollection.new(opts) do |options, offset, limit|
+      response = Hubspot::Connection.get_json(
+        CONTACT_IDS_PATH,
+        {"id" => @id, "vidOffset" => offset, "count" => limit}
+      )
+
+      [response["vids"], response["vidOffset"], response["hasMore"]]
+    end
+  end
+
+  def add_contact(contact)
+    self.class.add_contact(@id, contact.to_i)
+  end
+
+  def remove_contact(contact)
+    self.class.remove_contact(@id, contact.to_i)
+  end
+end

data/lib/hubspot/company_properties.rb

@@ -0,0 +1,59 @@
+module Hubspot
+  class CompanyProperties < Properties
+
+    ALL_PROPERTIES_PATH  = "/properties/v1/companies/properties"
+    ALL_GROUPS_PATH      = "/properties/v1/companies/groups"
+    CREATE_PROPERTY_PATH = "/properties/v1/companies/properties"
+    UPDATE_PROPERTY_PATH = "/properties/v1/companies/properties/named/:property_name"
+    DELETE_PROPERTY_PATH = "/properties/v1/companies/properties/named/:property_name"
+    CREATE_GROUP_PATH    = "/properties/v1/companies/groups"
+    UPDATE_GROUP_PATH    = "/properties/v1/companies/groups/named/:group_name"
+    DELETE_GROUP_PATH    = "/properties/v1/companies/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/config.rb

@@ -0,0 +1,63 @@
+require 'logger'
+require 'hubspot/connection'
+
+module Hubspot
+  class Config
+    CONFIG_KEYS = [
+      :hapikey, :base_url, :portal_id, :logger, :access_token, :client_id,
+      :client_secret, :redirect_uri, :read_timeout, :open_timeout
+    ]
+    DEFAULT_LOGGER = Logger.new(nil)
+    DEFAULT_BASE_URL = "https://api.hubapi.com".freeze
+
+    class << self
+      attr_accessor *CONFIG_KEYS
+
+      def configure(config)
+        config.stringify_keys!
+        @hapikey = config["hapikey"]
+        @base_url = config["base_url"] || DEFAULT_BASE_URL
+        @portal_id = config["portal_id"]
+        @logger = config["logger"] || DEFAULT_LOGGER
+        @access_token = config["access_token"]
+        @client_id = config["client_id"] if config["client_id"].present?
+        @client_secret = config["client_secret"] if config["client_secret"].present?
+        @redirect_uri = config["redirect_uri"] if config["redirect_uri"].present?
+        @read_timeout = config['read_timeout'] || config['timeout']
+        @open_timeout = config['open_timeout'] || config['timeout']
+
+        unless authentication_uncertain?
+          raise Hubspot::ConfigurationError.new("You must provide either an access_token or an hapikey")
+        end
+
+        if access_token.present?
+          Hubspot::Connection.headers("Authorization" => "Bearer #{access_token}")
+        end
+        self
+      end
+
+      def reset!
+        @hapikey = nil
+        @base_url = DEFAULT_BASE_URL
+        @portal_id = nil
+        @logger = DEFAULT_LOGGER
+        @access_token = nil
+        Hubspot::Connection.headers({})
+      end
+
+      def ensure!(*params)
+        params.each do |p|
+          raise Hubspot::ConfigurationError.new("'#{p}' not configured") unless instance_variable_get "@#{p}"
+        end
+      end
+
+      private
+
+      def authentication_uncertain?
+        access_token.present? ^ hapikey.present?
+      end
+    end
+
+    reset!
+  end
+end

data/lib/hubspot/connection.rb

@@ -0,0 +1,152 @@
+module Hubspot
+  class Connection
+    include HTTParty
+
+    class << self
+      def get_json(path, opts)
+        url = generate_url(path, opts)
+        response = get(url, format: :json, read_timeout: read_timeout(opts), open_timeout: open_timeout(opts))
+        log_request_and_response url, response
+        handle_response(response)
+      end
+
+      def post_json(path, opts)
+        no_parse = opts[:params].delete(:no_parse) { false }
+
+        url = generate_url(path, opts[:params])
+        response = post(
+          url,
+          body: opts[:body].to_json,
+          headers: { 'Content-Type' => 'application/json' },
+          format: :json,
+          read_timeout: read_timeout(opts),
+          open_timeout: open_timeout(opts)
+        )
+
+        log_request_and_response url, response, opts[:body]
+        raise(Hubspot::RequestError.new(response)) unless response.success?
+
+        no_parse ? response : response.parsed_response
+      end
+
+      def put_json(path, options)
+        no_parse = options[:params].delete(:no_parse) { false }
+        url = generate_url(path, options[:params])
+
+        response = put(
+          url,
+          body: options[:body].to_json,
+          headers: { "Content-Type" => "application/json" },
+          format: :json,
+          read_timeout: read_timeout(options),
+          open_timeout: open_timeout(options),
+        )
+
+        log_request_and_response(url, response, options[:body])
+        raise(Hubspot::RequestError.new(response)) unless response.success?
+
+        no_parse ? response : response.parsed_response
+      end
+
+      def delete_json(path, opts)
+        url = generate_url(path, opts)
+        response = delete(url, format: :json, read_timeout: read_timeout(opts), open_timeout: open_timeout(opts))
+        log_request_and_response url, response, opts[:body]
+        raise(Hubspot::RequestError.new(response)) unless response.success?
+        response
+      end
+
+      protected
+
+      def read_timeout(opts = {})
+        opts.delete(:read_timeout) || Hubspot::Config.read_timeout
+      end
+
+      def open_timeout(opts = {})
+        opts.delete(:open_timeout) || Hubspot::Config.open_timeout
+      end
+
+      def handle_response(response)
+        if response.success?
+          response.parsed_response
+        else
+          raise(Hubspot::RequestError.new(response))
+        end
+      end
+
+      def log_request_and_response(uri, response, body=nil)
+        Hubspot::Config.logger.info(<<~MSG)
+          Hubspot: #{uri}.
+          Body: #{body}.
+          Response: #{response.code} #{response.body}
+        MSG
+      end
+
+      def generate_url(path, params={}, options={})
+        if Hubspot::Config.access_token.present?
+          options[:hapikey] = false
+        else
+          Hubspot::Config.ensure! :hapikey
+        end
+        path = path.clone
+        params = params.clone
+        base_url = options[:base_url] || Hubspot::Config.base_url
+        params["hapikey"] = Hubspot::Config.hapikey unless options[:hapikey] == false
+
+        if path =~ /:portal_id/
+          Hubspot::Config.ensure! :portal_id
+          params["portal_id"] = Hubspot::Config.portal_id if path =~ /:portal_id/
+        end
+
+        params.each do |k,v|
+          if path.match(":#{k}")
+            path.gsub!(":#{k}", CGI.escape(v.to_s))
+            params.delete(k)
+          end
+        end
+        raise(Hubspot::MissingInterpolation.new("Interpolation not resolved")) if path =~ /:/
+
+        query = params.map do |k,v|
+          v.is_a?(Array) ? v.map { |value| param_string(k,value) } : param_string(k,v)
+        end.join("&")
+
+        path += path.include?('?') ? '&' : "?" if query.present?
+        base_url + path + query
+      end
+
+      # convert into milliseconds since epoch
+      def converted_value(value)
+        value.is_a?(Time) ? (value.to_i * 1000) : CGI.escape(value.to_s)
+      end
+
+      def param_string(key,value)
+        case key
+        when /range/
+          raise "Value must be a range" unless value.is_a?(Range)
+          "#{key}=#{converted_value(value.begin)}&#{key}=#{converted_value(value.end)}"
+        when /^batch_(.*)$/
+          key = $1.gsub(/(_.)/) { |w| w.last.upcase }
+          "#{key}=#{converted_value(value)}"
+        else
+          "#{key}=#{converted_value(value)}"
+        end
+      end
+    end
+  end
+
+  class FormsConnection < Connection
+    follow_redirects true
+
+    def self.submit(path, opts)
+      url = generate_url(path, opts[:params], { base_url: 'https://forms.hubspot.com', hapikey: false })
+      post(url, body: opts[:body], headers: { 'Content-Type' => 'application/x-www-form-urlencoded' })
+    end
+  end
+
+  class EventConnection < Connection
+    def self.trigger(path, opts)
+      url = generate_url(path, opts[:params], { base_url: 'https://track.hubspot.com', hapikey: false })
+      get(url, body: opts[:body], headers: opts[:headers])
+    end
+  end
+end