harvest-ruby-v2 0.2.0

data/harvest-ruby-v2.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/harvest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'harvest-ruby-v2'
+  spec.version       = Harvest::VERSION
+  spec.authors       = ['Craig Davis']
+  spec.email         = ['craig.davis@rackspace.com']
+
+  spec.summary       = 'Fluent API Harvest Client API v2 '
+  spec.description   = 'Harvest API for v2  written in Fluent API style'
+  spec.homepage      = 'https://github.com/blade2005/harvest-ruby/wiki'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  # spec.metadata['allowed_push_host'] = 'TODO: Set to 'http://mygemserver.com''
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/blade2005/harvest-ruby'
+  spec.metadata['changelog_uri'] = 'https://github.com/blade2005/harvest-ruby/blob/master/CHANGELOG.rst'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  # spec.bindir        = 'exe'
+  # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+end

data/lib/harvest.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'date'
+require 'rest-client'
+
+require 'harvest/version'
+require 'harvest/resourcefactory'
+require 'harvest/httpclient'
+require 'harvest/exceptions'
+require 'harvest/finders'
+require 'harvest/discovers'
+require 'harvest/creates'
+
+# Conform to naming pattern of Finder, Discover, Creators.
+# @param key [Symbol] symbol of state
+def to_class_name(key)
+  key.to_s.split('_').map(&:capitalize).join.to_sym
+end
+
+def merge_state(state, meth, args)
+  state.merge(
+    meth => args.first ? !args.first.nil? : [],
+    active: meth
+  )
+end
+
+# Harvest
+module Harvest
+  # Harvest client interface
+  class Client
+    attr_reader :active_user, :client, :time_entries, :factory, :state
+
+    # @param config [Struct::Config] Configuration Struct which provides attributes
+    # @param state [Hash] State of the Client for FluentAPI
+    def initialize(config, state: { filtered: {} })
+      @config = config
+      @client = Harvest::HTTP::Api.new(**@config)
+      @factory = Harvest::ResourceFactory.new
+      @state = state
+      @active_user = @factory.user(@client.api_call(@client.api_caller('/users/me')))
+      @admin_api = if @active_user.is_admin
+                     config.admin_api
+                   else
+                     false
+                   end
+    end
+
+    def allowed?(meth)
+      %i[
+        projects
+        project_tasks
+        time_entry
+        tasks
+      ].include?(meth)
+    end
+
+    # @param meth [Symbol]
+    # @return [Boolean]
+    def respond_to_missing?(meth)
+      allowed?(meth)
+    end
+
+    # @param meth [Symbol]
+    # @param *args [Array] arguments passed to method.
+    def method_missing(meth, *args)
+      if allowed?(meth)
+        Harvest::Client.new(
+          @config,
+          state: merge_state(@state, meth, args)
+        )
+      else
+
+        super
+      end
+    rescue NoMethodError
+      # binding.pry
+      raise Harvest::Exceptions::BadState, "#{meth} is an invalid state change."
+    end
+
+    # Find single instance of resource
+    def find(id)
+      @state[@state[:active]] = Harvest::Finders.const_get(
+        to_class_name(@state[:active])
+      ).new.find(@factory, @client, id)
+      self
+    end
+
+    # Discover resources
+    def discover(**params)
+      @state[@state[:active]] = Harvest::Discovers.const_get(
+        to_class_name(@state[:active])
+      ).new.discover(
+        @admin_api, @client, @factory, active_user, @state, params
+      )
+      self
+    end
+
+    # Select a subset of all items depending on state
+    def select(&block)
+      @state[:filtered][@state[:active]] = @state[@state[:active]].select(&block)
+      self
+    end
+
+    # Create an instance of object based on state
+    def create(**kwargs)
+      @state[@state[:active]] = Harvest::Create.const_get(
+        to_class_name(@state[:active])
+      ).new.create(
+        @factory, @client, active_user, @state, kwargs
+      )
+      self
+    end
+  end
+end

data/lib/harvest/config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Harvest
+  # @param domain [String] Harvest domain ex: https://company.harvestapp.com
+  # @param account_id [Integer] Harvest Account id
+  # @param personal_token [String] Harvest Personal token
+  # @param admin_api [Boolean] Certain API Requests will fail if you are not
+  #                            an admin in Harvest. This helps set that
+  #                            functionality to limit broken interfaces
+  Struct.new(
+    'Config',
+    :domain,
+    :account_id,
+    :personal_token,
+    keyword_init: true
+  ) do
+    def admin_api=(value: false)
+      @admin_api ||= value
+    end
+  end
+end

data/lib/harvest/creates.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Some API calls will return Project others ProjectAssignment.
+def true_project(project)
+  return project.project if project.respond_to?(:project)
+
+  project
+end
+
+module Harvest
+  module Create
+    class TimeEntry
+      def create(factory, client, active_user, state, kwargs)
+        @state = state
+        @active_user = active_user
+        begin
+          factory.time_entry(
+            client.api_call(
+              client.api_caller(
+                'time_entries',
+                http_method: 'post',
+                payload: time_entry_payload(kwargs).to_json,
+                headers: { content_type: 'application/json' }
+              )
+            )
+          )
+        rescue RestClient::UnprocessableEntity => e
+          puts "Harvest Error from Create Time Entry: #{JSON.parse(e.response.body)['message']}"
+          raise
+        end
+      end
+
+      private
+
+      # @api private
+      def time_entry_payload(kwargs)
+        possible_keys = %i[spent_date notes external_reference user_id]
+        payload = kwargs.map { |k, v| [k, v] if possible_keys.include?(k) }.to_h
+        payload[:user_id] ||= @active_user.id
+        payload[:task_id] = @state[:filtered][:project_tasks][0].task.id
+        payload[:project_id] = true_project(@state[:filtered][:projects][0]).id
+        payload
+      end
+    end
+  end
+end

data/lib/harvest/discovers.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Harvest
+  module Discovers
+    class Projects
+      def discover(admin_api, client, factory, active_user, _state, _params)
+        @client = client
+        @factory = factory
+        @active_user = active_user
+        admin_api ? admin_projects : project_assignments
+      end
+
+      private
+
+      # @api private
+      # All Projects
+      def admin_projects
+        @client
+          .api_call(
+            @client.api_caller('projects')
+          )['projects']
+          .map { |project| @factory.project(project) }
+      end
+
+      # @api private
+      # Projects assigned to the specified user_id
+      def project_assignments(user_id: @active_user.id)
+        @client
+          .api_call(
+            @client.api_caller(
+              "users/#{user_id}/project_assignments"
+            )
+          )['project_assignments']
+          .map do |project|
+            @factory.project_assignment(project)
+          end
+      end
+    end
+
+    class TimeEntry
+      def discover(_admin_api, client, factory, _active_user, _state, params)
+        paginator = client.paginator
+        paginator.path = 'time_entries'
+        paginator.data_key = 'time_entries'
+        paginator.param = params
+        client.pagination(paginator).map do |time_entry|
+          factory.time_entry(time_entry)
+        end
+      end
+    end
+
+    class ProjectTasks
+      def discover(_admin_api, _client, _factory, _active_user, state, _params)
+        state[:filtered][:projects][0].task_assignments
+      end
+    end
+  end
+end

data/lib/harvest/exceptions.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Harvest
+  module Exceptions
+    class Error < StandardError; end
+    class BadState < Error; end
+    class ProjectError < Error; end
+    class TooManyProjects < ProjectError; end
+    class NoProjectsFound < ProjectError; end
+  end
+end

data/lib/harvest/finders.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Harvest
+  module Finders
+    class Projects
+      def find(factory, client, id)
+        [factory.project(client.api_call(client.api_caller("projects/#{id}")))]
+      end
+    end
+
+    class TimeEntry
+      def find(factory, client, id)
+        [factory.time_entry(client.api_call(client.api_caller("time_entry/#{id}")))]
+      end
+    end
+  end
+end

data/lib/harvest/httpclient.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Harvest
+  module HTTP
+    # lower level class which create the Client for making api calls
+    class Client
+      def initialize(state: {})
+        @state = state
+      end
+
+      attr_reader :state
+
+      def method_missing(meth, *args)
+        if allowed?(meth)
+          Client.new(
+            state: @state.merge(meth => args.first)
+          )
+        else
+          super
+        end
+      end
+
+      def allowed?(meth)
+        %i[
+          domain
+          headers
+          client
+        ].include?(meth)
+      end
+
+      def respond_to_missing?(*)
+        super
+      end
+
+      def headers(personal_token, account_id)
+        Client.new(
+          state: @state.merge(
+            {
+              headers: {
+                'User-Agent' => 'harvest-ruby API Client',
+                'Authorization' => "Bearer #{personal_token}",
+                'Harvest-Account-ID' => account_id
+              }
+            }
+          )
+        )
+      end
+
+      def client
+        RestClient::Resource.new(
+          "#{@state[:domain].chomp('/')}/api/v2",
+          headers: @state[:headers]
+        )
+      end
+    end
+    # Make
+    class Api
+      def initialize(domain:, account_id:, personal_token:)
+        @domain = domain
+        @account_id = account_id
+        @personal_token = personal_token
+      end
+
+      def client
+        Harvest::HTTP::Client
+          .new
+          .domain(@domain)
+          .headers(@personal_token, @account_id)
+          .client
+      end
+
+      # Make a api call to an endpoint.
+      # @api public
+      # @param struct [Struct::ApiCall]
+      def api_call(struct)
+        JSON.parse(
+          send(struct.http_method.to_sym, struct).tap do
+            require 'pry'
+            # binding.pry
+          end
+        )
+      end
+
+      # Pagination through request
+      # @api public
+      # @param struct [Struct::Pagination]
+      def pagination(struct)
+        struct.param[:page] = struct.page_count
+        page = api_call(struct.to_api_call)
+        struct.rows.concat(page[struct.data_key])
+
+        return struct.rows if struct.page_count >= page['total_pages']
+
+        struct.page_count += 1
+        pagination(struct)
+      end
+
+      # Create Paginaation struct message to pass to pagination call
+      def paginator(http_method: 'get', page_count: 1, param: {}, entries: [], headers: {})
+        Struct::Pagination.new(
+          {
+            http_method: http_method,
+            param: param,
+            rows: entries,
+            page_count: page_count,
+            headers: headers
+          }
+        )
+      end
+
+      def api_caller(path, http_method: 'get', param: {}, payload: nil, headers: {})
+        Struct::ApiCall.new(
+          {
+            path: path,
+            http_method: http_method.to_sym,
+            param: param,
+            payload: payload,
+            headers: headers
+          }
+        )
+      end
+
+      private
+
+      def get(struct)
+        client[struct.path].get(struct.headers)
+      end
+
+      def post(struct)
+        client[struct.path].post(struct.payload, struct.headers)
+      end
+    end
+
+    Struct.new(
+      'ApiCall',
+      :path,
+      :http_method,
+      :param,
+      :payload,
+      :headers,
+      keyword_init: true
+    ) do
+      def param(params)
+        headers['params'] = params
+      end
+    end
+
+    Struct.new(
+      'Pagination',
+      :path,
+      :data_key,
+      :http_method,
+      :page_count,
+      :param,
+      :payload,
+      :rows,
+      :headers,
+      keyword_init: true
+    ) do
+      def to_api_call
+        Struct::ApiCall.new(
+          {
+            path: path,
+            http_method: http_method,
+            param: param,
+            payload: payload,
+            headers: headers
+          }
+        )
+      end
+
+      def increment_page
+        self.page_count += 1
+        self
+      end
+    end
+  end
+end