procore 0.6.7

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task default: :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "procore"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/procore.rb

@@ -0,0 +1,21 @@
+module Procore
+end
+
+require "logger"
+require "json"
+
+require "procore/auth/access_token_credentials"
+require "procore/auth/client_credentials"
+require "procore/auth/stores/active_record"
+require "procore/auth/stores/file"
+require "procore/auth/stores/memory"
+require "procore/auth/stores/redis"
+require "procore/auth/stores/session"
+require "procore/auth/token"
+require "procore/client"
+require "procore/configuration"
+require "procore/defaults"
+require "procore/errors"
+require "procore/response"
+require "procore/util"
+require "procore/version"

data/lib/procore/auth/access_token_credentials.rb

@@ -0,0 +1,35 @@
+require "oauth2"
+
+module Procore
+  module Auth
+    class AccessTokenCredentials
+      attr_reader :client_id, :client_secret, :host
+      def initialize(client_id:, client_secret:, host:)
+        @client_id = client_id
+        @client_secret = client_secret
+        @host = host
+      end
+
+      def refresh(token:, refresh:)
+        token = OAuth2::AccessToken.new(client, token, refresh_token: refresh)
+        new_token = token.refresh!
+
+        Procore::Auth::Token.new(
+          access_token: new_token.token,
+          refresh_token: new_token.refresh_token,
+          expires_at: new_token.expires_at,
+        )
+      end
+
+      private
+
+      def client
+        OAuth2::Client.new(
+          client_id,
+          client_secret,
+          site: "#{host}/oauth/token",
+        )
+      end
+    end
+  end
+end

data/lib/procore/auth/client_credentials.rb

@@ -0,0 +1,52 @@
+require "oauth2"
+
+module Procore
+  module Auth
+    class ClientCredentials
+      attr_reader :client_id, :client_secret, :host
+      def initialize(client_id:, client_secret:, host:)
+        unless client_id && client_secret
+          raise OAuthError.new("No client_id or client_secret provided.")
+        end
+
+        @client_id = client_id
+        @client_secret = client_secret
+        @host = host
+      end
+
+      def refresh(token: nil, refresh: nil)
+        new_token = client
+          .client_credentials
+          .get_token({}, { auth_scheme: :request_body })
+
+        Procore::Auth::Token.new(
+          access_token: new_token.token,
+          refresh_token: new_token.refresh_token,
+          expires_at: new_token.expires_at,
+        )
+
+      rescue OAuth2::Error => e
+        raise OAuthError.new(e.description, response: e.response)
+
+      rescue Faraday::ConnectionFailed => e
+        raise APIConnectionError.new("Connection Error: #{e.message}")
+
+      rescue URI::BadURIError
+        raise OAuthError.new(
+          "Host is not a valid URI. Check your host option to make sure it "   \
+          "is a properly formed url"
+        )
+      end
+
+      private
+
+      def client
+        OAuth2::Client.new(
+          client_id,
+          client_secret,
+          site: "#{host}/oauth/token",
+        )
+      end
+    end
+  end
+end

data/lib/procore/auth/stores/active_record.rb

@@ -0,0 +1,41 @@
+module Procore
+  module Auth
+    module Stores
+      class ActiveRecord
+        attr_reader :object
+
+        def initialize(object:)
+          @object = object
+        end
+
+        def save(token)
+          object.update(
+            access_token: token.access_token,
+            refresh_token: token.refresh_token,
+            expires_at: token.expires_at,
+          )
+        end
+
+        def fetch
+          Procore::Auth::Token.new(
+            access_token: object.access_token,
+            refresh_token: object.refresh_token,
+            expires_at: object.expires_at,
+          )
+        end
+
+        def delete
+          object.update(
+            access_token: nil,
+            expires_at: nil,
+            refresh_token: nil,
+          )
+        end
+
+        def to_s
+          "Active Record, Object: #{object.class} #{object.id}"
+        end
+      end
+    end
+  end
+end

data/lib/procore/auth/stores/file.rb

@@ -0,0 +1,32 @@
+require "yaml/store"
+
+module Procore
+  module Auth
+    module Stores
+      class File
+        attr_reader :key, :path
+        def initialize(key:, path:)
+          @key = key
+          @path = path
+          @store = YAML::Store.new(path)
+        end
+
+        def save(token)
+          @store.transaction { @store[key] = token }
+        end
+
+        def fetch
+          @store.transaction { @store[key] }
+        end
+
+        def delete
+          @store.transaction { @store.delete(key) }
+        end
+
+        def to_s
+          "File, Key: #{key}, Path: #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/procore/auth/stores/memory.rb

@@ -0,0 +1,29 @@
+module Procore
+  module Auth
+    module Stores
+      class Memory
+        attr_reader :key, :store
+        def initialize(key:)
+          @key = key
+          @store = {}
+        end
+
+        def save(token)
+          @store[key] = token
+        end
+
+        def fetch
+          @store[key]
+        end
+
+        def delete
+          @store.delete(key)
+        end
+
+        def to_s
+          "Memory, Key: #{key}"
+        end
+      end
+    end
+  end
+end

data/lib/procore/auth/stores/redis.rb

@@ -0,0 +1,42 @@
+module Procore
+  module Auth
+    module Stores
+      class Redis
+        attr_reader :key, :redis
+        def initialize(key:, redis:)
+          @key = key
+          @redis = redis
+        end
+
+        def save(token)
+          redis.set(redis_key, token.to_json)
+        end
+
+        def fetch
+          return if redis.get(redis_key).empty?
+
+          token = JSON.parse(redis.get(redis_key))
+          Procore::Auth::Token.new(
+            access_token: token["access_token"],
+            refresh_token: token["refresh_token"],
+            expires_at: token["expires_at"],
+          )
+        end
+
+        def delete
+          redis.set(redis_key, nil)
+        end
+
+        def to_s
+          "Redis, Key: #{redis_key}"
+        end
+
+        private
+
+        def redis_key
+          "procore-redis-#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/procore/auth/stores/session.rb

@@ -0,0 +1,38 @@
+module Procore
+  module Auth
+    module Stores
+      SESSION_KEY = "procore_token".to_sym
+
+      class Session
+        attr_reader :session, :key
+        def initialize(session:, key: SESSION_KEY)
+          @session = session
+          @key = key
+        end
+
+        def save(token)
+          session[key] = token.to_json
+        end
+
+        def fetch
+          return if session[key].nil?
+
+          token = JSON.parse(session[key])
+          Procore::Auth::Token.new(
+            access_token: token["access_token"],
+            refresh_token: token["refresh_token"],
+            expires_at: token["expires_at"],
+          )
+        end
+
+        def delete
+          session[key] = nil
+        end
+
+        def to_s
+          "Session, Key: #{key}"
+        end
+      end
+    end
+  end
+end

data/lib/procore/auth/token.rb

@@ -0,0 +1,20 @@
+module Procore
+  module Auth
+    class Token
+      attr_reader :access_token, :refresh_token, :expires_at
+      def initialize(access_token:, refresh_token:, expires_at:)
+        @access_token = access_token
+        @refresh_token = refresh_token
+        @expires_at = expires_at
+      end
+
+      def invalid?
+        access_token.nil?
+      end
+
+      def expired?
+        expires_at.to_i < Time.now.to_i
+      end
+    end
+  end
+end

data/lib/procore/client.rb

@@ -0,0 +1,86 @@
+require "procore/requestable"
+
+module Procore
+  # Main class end users interact with. An instance of a client can call out
+  # the Procore API using methods matching standard HTTP verbs #get, #post,
+  # #patch, #delete.
+  #
+  # @example Creating a new client:
+  #   store = Procore::Auth::Stores::Session.new(session: session)
+  #   client = Procore::Client.new(
+  #     client_id: Rails.application.secrets.procore_client_id,
+  #     client_secret: Rails.application.secrets.procore_secret_id,
+  #     store: store
+  #   )
+  #
+  #   client.get("me").body #=> { id: 5, email: "person@example.com" }
+  class Client
+    include Procore::Requestable
+
+    attr_reader :options, :store
+
+    # @param client_id [String] Client ID issued from Procore
+    # @param client_secret [String] Client Secret issued from Procore
+    # @param store [Auth::Store] A store to use for saving, updating and
+    #   refreshing tokens
+    # @param options [Hash] options to configure the client with
+    # @option options [String] :host Endpoint to use for the API. Defaults to
+    #   Configuration.host
+    # @option options [String] :user_agent User Agent string to send along with
+    #   the request. Defaults to Configuration.user_agent
+    def initialize(client_id:, client_secret:, store:, options: {})
+      @options = Procore::Defaults::client_options.merge(options)
+      @credentials = Procore::Auth::AccessTokenCredentials.new(
+        client_id: client_id,
+        client_secret: client_secret,
+        host: @options[:host],
+      )
+      @store = store
+    end
+
+    private
+
+    def base_api_path
+      "#{options[:host]}/vapid"
+    end
+
+    # @raise [OAuthError] if the store does not have a token stored in it prior
+    #   to making a request.
+    # @raise [OAuthError] if a token cannot be refreshed.
+    # @raise [OAuthError] if incorrect credentials have been supplied.
+    def access_token
+      token = store.fetch
+
+      if token.nil? || token.invalid?
+        raise Procore::OAuthError.new(
+          "Unable to retreive an access token from the store. Double check "   \
+          "your store configuration and make sure to correctly store a token " \
+          "before attempting to make API requests"
+        )
+      end
+
+      if token.expired?
+        Util.log_info("Token Expired", store: store)
+        begin
+          token = @credentials.refresh(
+            token: token.access_token,
+            refresh: token.refresh_token,
+          )
+
+          Util.log_info("Token Refresh Successful", store: store)
+          store.save(token)
+        rescue RuntimeError
+          Util.log_error("Token Refresh Failed", store: store)
+          raise Procore::OAuthError.new(
+            "Unable to refresh the access token. Perhaps the Procore API is "  \
+            "down or the your access token store is misconfigured. Either "    \
+            "way, you should clear the store and prompt the user to sign in "  \
+            "again."
+          )
+        end
+      end
+
+      token.access_token
+    end
+  end
+end

data/lib/procore/configuration.rb

@@ -0,0 +1,88 @@
+require "procore/defaults"
+
+module Procore
+  # Yields the configuration so the end user can set multiple attributes at
+  # once.
+  #
+  # @example Within config/initializers/procore.rb
+  #   Procore.configure do |config|
+  #     config.timeout = 5.0
+  #     config.user_agent = MyApp
+  #   end
+  def self.configure
+    yield(configuration)
+  end
+
+  # The current configuration for the gem.
+  #
+  # @return [Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Holds the configuration for the Procore gem.
+  class Configuration
+    # @!attribute [rw] host
+    # @note defaults to Defaults::API_ENDPOINT
+    #
+    # Base API host name. Alter this depending on your environment - in a
+    # staging or test environment you may want to point this at a sandbox
+    # instead of production.
+    #
+    # @return [String]
+    attr_accessor :host
+
+    # @!attribute [rw] logger
+    # @note defaults to nil
+    #
+    # Instance of a Logger. This gem will log information about requests,
+    # responses and other things it might be doing. In a Rails application it
+    # should be set to Rails.logger
+    #
+    # @return [Logger, nil]
+    attr_accessor :logger
+
+    # @!attribute [rw] max_retries
+    # @note Defaults to 1
+    #
+    # Number of times to retry a failed API call. Reasons an API call
+    # could potentially fail:
+    # 1. Service is briefly down or unreachable
+    # 2. Timeout hit - service is experiencing immense load or mid restart
+    # 3. Because computers
+    #
+    # Would recommend 3-5 for production use. Has exponential backoff - first
+    # request waits a 1.5s after a failure, next one 2.25s, next one 3.375s,
+    # 5.0, etc.
+    #
+    # @return [Integer]
+    attr_accessor :max_retries
+
+    # @!attribute [rw] timeout
+    # @note defaults to 1.0
+    #
+    # Threshold for canceling an API request. If a request takes longer
+    # than this value it will automatically cancel.
+    #
+    # @return [Float]
+    attr_accessor :timeout
+
+    # @!attribute [rw] user_agent
+    # @note defaults to Defaults::USER_AGENT
+    #
+    # User Agent sent with each API request. API requests must have a user
+    # agent set. It is recomended to set the user agent to the name of your
+    # application.
+    #
+    # @return [String]
+    attr_accessor :user_agent
+
+    def initialize
+      @host = Procore::Defaults::API_ENDPOINT
+      @logger = nil
+      @max_retries = 1
+      @timeout = 1.0
+      @user_agent = Procore::Defaults::USER_AGENT
+    end
+  end
+end