hubspot-api-ruby 0.8.0

data/lib/hubspot/oauth.rb

@@ -0,0 +1,50 @@
+require 'httparty'
+
+module Hubspot
+  class OAuth < Connection
+    include HTTParty
+
+    DEFAULT_OAUTH_HEADERS = {"Content-Type" => "application/x-www-form-urlencoded;charset=utf-8"}
+
+    class << self
+      def refresh(token, params={}, options={})
+        oauth_post(token_url, { grant_type: "refresh_token", refresh_token: token }.merge(params),
+          options)
+      end
+
+      def create(code, params={}, options={})
+        oauth_post(token_url, { grant_type: "authorization_code", code: code }.merge(params),
+          options)
+      end
+
+      def authorize_url(scopes, params={})
+        client_id = params[:client_id] || Hubspot::Config.client_id
+        redirect_uri = params[:redirect_uri] || Hubspot::Config.redirect_uri
+        scopes = Array.wrap(scopes)
+
+        "https://app.hubspot.com/oauth/authorize?client_id=#{client_id}&scope=#{scopes.join("%20")}&redirect_uri=#{redirect_uri}"
+      end
+
+      def token_url
+        token_url = Hubspot::Config.base_url + "/oauth/v1/token"
+      end
+
+      def oauth_post(url, params, options={})
+        no_parse = options[:no_parse] || false
+
+        body = {
+          client_id: Hubspot::Config.client_id,
+          client_secret: Hubspot::Config.client_secret,
+          redirect_uri: Hubspot::Config.redirect_uri,
+        }.merge(params)
+
+        response = post(url, body: body, headers: DEFAULT_OAUTH_HEADERS)
+        log_request_and_response url, response, body
+
+        raise(Hubspot::RequestError.new(response)) unless response.success?
+
+        no_parse ? response : response.parsed_response
+      end
+    end
+  end
+end

data/lib/hubspot/owner.rb

@@ -0,0 +1,57 @@
+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_OWNER_PATH    = '/owners/v2/owners/:owner_id' # GET
+    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(id, include_inactive=false)
+        path     = GET_OWNER_PATH
+        response = Hubspot::Connection.get_json(path, owner_id: id,
+          include_inactive: include_inactive)
+        new(response)
+      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/paged_collection.rb

@@ -0,0 +1,35 @@
+class Hubspot::PagedCollection < Hubspot::Collection
+  attr_accessor :offset, :limit
+
+  def initialize(opts = {}, &block)
+    @limit_param = opts.delete(:limit_param) || "limit"
+    @limit = opts.delete(:limit) || 25
+    @offset_param = opts.delete(:offset_param) || "offset"
+    @offset = opts.delete(:offset)
+
+    super(opts, &block)
+  end
+
+  def more?
+    @has_more
+  end
+
+  def next_offset
+    @next_offset
+  end
+
+  def next_page?
+    @has_more
+  end
+
+  def next_page
+    @offset = next_offset
+    fetch
+    self
+  end
+
+protected
+  def fetch
+    @resources, @next_offset, @has_more = @fetch_proc.call(@options, @offset, @limit)
+  end
+end

data/lib/hubspot/properties.rb

@@ -0,0 +1,123 @@
+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 showCurrencySymbol),
+      valid_field_types: %w(textarea select text date file number radio checkbox booleancheckbox),
+      valid_types:       %w(string number bool date datetime enumeration),
+      options:           %w(description value label hidden displayOrder)
+    }
+    DEFAULT_PROPERTY = 'email'
+
+    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={})
+        if opts.keys.map(&:to_s).include? 'property'
+          opts
+        else
+          opts.merge(property: DEFAULT_PROPERTY)
+        end
+      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

data/lib/hubspot/railtie.rb

@@ -0,0 +1,10 @@
+require 'hubspot-api-ruby'
+require 'rails'
+module Hubspot
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      spec = Gem::Specification.find_by_name('hubspot-api-ruby')
+      load "#{spec.gem_dir}/lib/tasks/hubspot.rake"
+    end
+  end
+end

data/lib/hubspot/resource.rb

@@ -0,0 +1,270 @@
+module Hubspot
+  class Resource
+
+    class_attribute :id_field, instance_writer: false
+    class_attribute :property_name_field, instance_writer: false
+    class_attribute :update_method, instance_writer: false
+
+    self.id_field = "id"
+    self.property_name_field = "property"
+    self.update_method = "put"
+
+    class << self
+      def from_result(result)
+        resource = new(result[id_field])
+        resource.send(:initialize_from, result.with_indifferent_access)
+        resource
+      end
+
+      def find(id)
+        instance = new(id)
+        instance.reload
+      end
+
+      def create(properties = {})
+        request = {
+          properties: Hubspot::Utils.hash_to_properties(properties.stringify_keys, key_name: property_name_field)
+        }
+        response = Hubspot::Connection.post_json(create_path, params: {}, body: request)
+        from_result(response)
+      end
+
+      def update(id, properties = {})
+        begin
+          update!(id, properties)
+        rescue Hubspot::RequestError => e
+          false
+        end
+      end
+
+      def update!(id, properties = {})
+        request = {
+          properties: Hubspot::Utils.hash_to_properties(properties.stringify_keys, key_name: property_name_field)
+        }
+
+        if update_method == "put"
+          response = Hubspot::Connection.put_json(update_path, params: { id: id, no_parse: true }, body: request)
+        else
+          response = Hubspot::Connection.post_json(update_path, params: { id: id, no_parse: true }, body: request)
+        end
+
+        response.success?
+      end
+    end
+
+    def initialize(id_or_properties = nil)
+      @changes = HashWithIndifferentAccess.new
+      @properties = HashWithIndifferentAccess.new
+
+      if id_or_properties.is_a?(Integer) || id_or_properties.nil?
+        @id = id_or_properties
+      elsif id_or_properties.is_a?(Hash)
+        @id = id_or_properties.delete(id_field) || id_or_properties.delete(:id)
+
+        add_accessors(id_or_properties.keys)
+        id_or_properties.each do |k, v|
+          send "#{k}=", v
+        end
+      else
+        raise InvalidParams.new("#{self.class.name} must be initialized with an ID, hash, or nil")
+      end
+
+      @persisted = @id.present?
+      @deleted = false
+    end
+
+    def id
+      @id
+    end
+
+    def id=(id)
+      @id = id
+    end
+
+    def to_i
+      @id
+    end
+
+    def metadata
+      @metadata
+    end
+
+    def changes
+      @changes
+    end
+
+    def changed?
+      !@changes.empty?
+    end
+
+    def [](name)
+      @changes[name] || @properties[name]
+    end
+
+    def reload
+      raise(Hubspot::InvalidParams.new("Resource must have an ID")) if @id.nil?
+
+      response = Hubspot::Connection.get_json(find_path, id: @id)
+      initialize_from(response.with_indifferent_access)
+
+      self
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def save
+      request = {
+        properties: Hubspot::Utils.hash_to_properties(@changes.stringify_keys, key_name: property_name_field)
+      }
+
+      if persisted?
+        if update_method == "put"
+          response = Hubspot::Connection.put_json(update_path, params: { id: @id }, body: request)
+        else
+          response = Hubspot::Connection.post_json(update_path, params: { id: @id }, body: request)
+        end
+
+        update_from_changes
+      else
+        response = Hubspot::Connection.post_json(create_path, params: {}, body: request)
+
+        # Grab the new ID from the response
+        @id = response[id_field]
+
+        # Update the fields with the response
+        initialize_from(response.with_indifferent_access)
+      end
+
+      @persisted = true
+      true
+    end
+
+    def update(properties)
+      if properties && !properties.is_a?(Hash)
+        raise ArgumentError, "When assigning properties, you must pass a hash as an argument."
+      end
+
+      @changes = @changes.merge(properties)
+      save
+    end
+
+    def delete
+      raise(Hubspot::InvalidParams.new("Resource must have an ID")) if @id.nil?
+
+      Hubspot::Connection.delete_json(delete_path, id: @id)
+
+      @deleted = true
+      @changes = HashWithIndifferentAccess.new
+      true
+    end
+
+    def deleted?
+      @deleted
+    end
+
+  protected
+
+    def self.create_path
+      begin
+        self::CREATE_PATH
+      rescue NameError
+        raise "CREATE_PATH not defined for #{self.class.name}"
+      end
+    end
+
+    def create_path
+      self.class.create_path
+    end
+
+    def self.find_path
+      begin
+        self::FIND_PATH
+      rescue NameError
+        raise "FIND_PATH not defined for #{self.class.name}"
+      end
+    end
+
+    def find_path
+      self.class.find_path
+    end
+
+    def self.update_path
+      begin
+        self::UPDATE_PATH
+      rescue NameError
+        raise "UPDATE_PATH not defined for #{self.class.name}"
+      end
+    end
+
+    def update_path
+      self.class.update_path
+    end
+
+    def self.delete_path
+      begin
+        self::DELETE_PATH
+      rescue NameError
+        raise "CREATE_PATH not defined for #{self.class.name}"
+      end
+    end
+
+    def delete_path
+      self.class.delete_path
+    end
+
+    def initialize_from(response)
+      @properties = response["properties"] || HashWithIndifferentAccess.new
+      @metadata = response.except "properties"
+
+      add_accessors(@properties.keys)
+
+      # Clear any changes
+      @changes = HashWithIndifferentAccess.new
+    end
+
+    def update_from_changes
+      @changes.each do |k, v|
+        @properties[k] ||= {}
+        @properties[k]["value"] = v
+      end
+
+      # Clear any changes
+      @changes = HashWithIndifferentAccess.new
+    end
+
+    def add_accessors(keys)
+      singleton_class.instance_eval do
+        keys.each do |k|
+          # Define a getter
+          define_method(k) { @changes[k.to_sym] || @properties.dig(k, "value") }
+
+          # Define a setter
+          define_method("#{k}=") do |v|
+            @changes[k.to_sym] = v
+          end
+        end
+      end
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      # When assigning a missing attribute define the accessors and set the value
+      if method_name.to_s.end_with?("=")
+        attr = method_name.to_s[0...-1].to_sym
+        add_accessors([attr])
+
+        # Call the new setter
+        return send(method_name, arguments[0])
+      elsif @properties.key?(method_name)
+        return @properties[method_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      (@properties && @properties.key?(method_name)) || super
+    end
+  end
+end