sfctl 0.0.2 → 1.0.1

data/lib/sfctl/commands/time/sync.rb

@@ -4,8 +4,9 @@ require 'tty-prompt'
 require 'tty-spinner'
 require 'tty-table'
 require_relative '../../command'
-require_relative '../../starfish'
-require_relative '../../toggl'
+require_relative '../../starfish/client'
+require_relative '../../toggl/sync'
+require_relative '../../harvest/sync'
 
 module Sfctl
   module Commands
@@ -47,6 +48,9 @@ module Sfctl
 
         def assignments_to_sync
           assignments = assignments_from_connections
+
+          return assignments if @options['all']
+
           assignment_id = select_assignment(assignments)
 
           return assignments if assignment_id == 'all'
@@ -67,37 +71,46 @@ module Sfctl
           list.each do |assignment|
             assignment_id = assignment['id'].to_s
             connection = read_link_config['connections'].select { |c| c == assignment_id }
-
-            if connection.empty?
-              output.puts @pastel.red("Unable to find a connection for assignment \"#{assignment['name']}\"")
-              next
-            end
-
             sync(output, assignment, connection[assignment_id])
           end
         end
 
-        def sync(output, assignment, connection)
-          case connection['provider']
-          when TOGGL_PROVIDER
-            sync_with_toggl!(output, assignment, connection)
-          end
-        end
-
-        def sync_with_toggl!(output, assignment, connection) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def sync(output, assignment, connection) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           output.puts "Synchronizing: #{@pastel.cyan("[#{assignment['name']} / #{assignment['service']}]")}"
 
-          success, next_report = Starfish.next_report(@options['starfish-host'], access_token, assignment['id'])
+          success, next_report = Starfish::Client.next_report(@options['starfish-host'], access_token, assignment['id'])
 
           print_no_next_reporting_segment(output) && return if !success || next_report.empty?
 
-          time_entries = load_data_from_toggl(output, next_report, connection)
+          time_entries = load_time_entries(output, next_report, connection)
 
           print_dry_run_enabled(output) && return if @options['dry_run']
 
           print_report_contains_data(output, next_report) && return if touchy?(next_report)
 
-          uploading_to_starfish(output, assignment, time_entries)
+          uploading_to_starfish(output, assignment, time_entries, connection)
+        end
+
+        def report_interval(record)
+          start_date = Date.parse("#{record['year']}-#{record['month']}-01")
+          end_date = start_date.next_month.prev_day
+          [start_date, end_date]
+        end
+
+        def load_time_entries(output, next_report, connection)
+          output.puts "Next Report:   #{@pastel.cyan(report_name(next_report))}"
+          next_report_interval = report_interval(next_report)
+
+          case connection['provider']
+          when TOGGL_PROVIDER
+            Toggl::Sync.load_data(
+              output, connection, read_link_config['providers'][TOGGL_PROVIDER], @pastel, next_report_interval
+            )
+          when HARVEST_PROVIDER
+            Harvest::Sync.load_data(
+              output, connection, read_link_config['providers'][HARVEST_PROVIDER], @pastel, next_report_interval
+            )
+          end
         end
 
         def touchy?(next_report)
@@ -130,93 +143,21 @@ module Sfctl
           true
         end
 
-        def load_data_from_toggl(output, next_report, connection)
-          output.puts "Next Report:   #{@pastel.cyan(report_name(next_report))}"
-
-          spinner = TTY::Spinner.new("Loaded data from #{TOGGL_PROVIDER}: [:spinner]", format: :dots)
-          spinner.auto_spin
-
-          time_entries = get_toggle_time_entries(next_report, connection)
-
-          spinner.success(@pastel.green('Done'))
-
-          table = TTY::Table.new %w[Date Comment Time], time_entries_table_rows(time_entries)
-          output.puts
-          output.print table.render(:unicode, padding: [0, 1], alignments: %i[left left right])
-          output.puts
-          output.puts
-
-          time_entries['data']
-        end
-
-        def time_entries_table_rows(time_entries)
-          rows = time_entries['data'].sort_by { |te| te['start'] }.map do |te|
-            [
-              Date.parse(te['start']).to_s,
-              te['description'],
-              "#{humanize_duration(te['dur'])}h"
-            ]
-          end
-          rows.push(['Total:', '', "#{humanize_duration(time_entries['total_grand'])}h"])
-          rows
-        end
-
-        def get_toggle_time_entries(next_report, connection)
-          _success, data = Toggl.time_entries(
-            read_link_config['providers'][TOGGL_PROVIDER]['access_token'], time_entries_params(next_report, connection)
-          )
-
-          data
-        end
-
-        def time_entries_params(next_report, connection)
-          start_date = Date.parse("#{next_report['year']}-#{next_report['month']}-01")
-          end_date = start_date.next_month.prev_day
-          params = {
-            workspace_id: connection['workspace_id'],
-            project_ids: connection['project_ids'],
-            billable: connection['billable'],
-            rounding: connection['rounding'],
-            since: start_date.to_s,
-            until: end_date.to_s
-          }
-          params[:task_ids] = connection['task_ids'] if connection['task_ids'].length.positive?
-          params
-        end
-
-        def humanize_duration(milliseconds)
-          return '0' if milliseconds.nil?
-
-          seconds = milliseconds / 1000
-          minutes = seconds / 60
-          int = (minutes / 60).ceil
-          dec = minutes % 60
-          amount = (dec * 100) / 60
-          amount = if dec.zero?
-                     ''
-                   elsif amount.to_s.length == 1
-                     ".0#{amount}"
-                   else
-                     ".#{amount}"
-                   end
-          "#{int}#{amount}"
-        end
-
-        def assignment_items(time_entries)
-          time_entries.map do |te|
-            {
-              time: humanize_duration(te['dur']).to_f,
-              date: Date.parse(te['start']).to_s,
-              comment: te['description']
-            }
+        def assignment_items(time_entries, connection)
+          case connection['provider']
+          when TOGGL_PROVIDER
+            Toggl::Sync.assignment_items(time_entries)
+          when HARVEST_PROVIDER
+            Harvest::Sync.assignment_items(time_entries, connection)
           end
         end
 
-        def uploading_to_starfish(output, assignment, time_entries)
+        def uploading_to_starfish(output, assignment, time_entries, connection)
           spinner = TTY::Spinner.new('Uploading to starfish.team: [:spinner]', format: :dots)
           spinner.auto_spin
-          success = Starfish.update_next_report(
-            @options['starfish-host'], access_token, assignment['id'], assignment_items(time_entries)
+
+          success = Starfish::Client.update_next_report(
+            @options['starfish-host'], access_token, assignment['id'], assignment_items(time_entries, connection)
           )
           print_upload_results(output, success, spinner)
         end

data/lib/sfctl/harvest/client.rb

@@ -0,0 +1,44 @@
+require 'faraday'
+require 'json'
+
+module Sfctl
+  module Harvest
+    module Client
+      API_V2_PATH = 'api/v2/'.freeze
+
+      def self.conn(account_id, token)
+        raise 'Please set Harvest provider before continue.' if account_id.nil? || token.nil?
+
+        headers = {
+          'Content-Type' => 'application/json',
+          'Harvest-Account-ID' => account_id,
+          'Authorization' => "Bearer #{token}"
+        }
+
+        Faraday.new(url: "https://api.harvestapp.com/#{API_V2_PATH}", headers: headers) do |builder|
+          builder.request :retry
+          builder.adapter :net_http
+        end
+      end
+
+      def self.parsed_response(response, key)
+        [response.status == 200, JSON.parse(response.body)[key]]
+      end
+
+      def self.projects(account_id, token)
+        response = conn(account_id, token).get('projects')
+        parsed_response(response, 'projects')
+      end
+
+      def self.tasks(account_id, token)
+        response = conn(account_id, token).get('tasks')
+        parsed_response(response, 'tasks')
+      end
+
+      def self.time_entries(account_id, token, params)
+        response = conn(account_id, token).get('time_entries', params)
+        parsed_response(response, 'time_entries')
+      end
+    end
+  end
+end

data/lib/sfctl/harvest/sync.rb

@@ -0,0 +1,80 @@
+require 'tty-spinner'
+require 'tty-table'
+require_relative '../command'
+require_relative './client'
+
+module Sfctl
+  module Harvest
+    module Sync
+      def self.load_data(output, connection, harvest_config, pastel, report_interval)
+        spinner = TTY::Spinner.new("Loaded data from #{Sfctl::Command::HARVEST_PROVIDER}: [:spinner]", format: :dots)
+        spinner.auto_spin
+
+        time_entries = get_time_entries(connection, harvest_config, report_interval)
+
+        spinner.success(pastel.green('Done'))
+
+        table = TTY::Table.new %w[Date Comment Time], time_entries_table_rows(time_entries, connection)
+        output.puts
+        output.print table.render(:unicode, padding: [0, 1], alignments: %i[left left right])
+        output.puts
+        output.puts
+
+        time_entries
+      end
+
+      def self.get_time_entries(connection, harvest_config, report_interval)
+        _success, data = Harvest::Client.time_entries(
+          harvest_config['account_id'],
+          harvest_config['access_token'],
+          time_entries_params(connection, report_interval)
+        )
+
+        data
+      end
+
+      def self.hours_field(rounding)
+        return 'rounded_hours' if rounding == 'on'
+
+        'hours'
+      end
+
+      def self.time_entries_table_rows(time_entries, connection)
+        hours_field = hours_field(connection['rounding'])
+        rows = time_entries.sort_by { |te| te['spent_date'] }.map do |te|
+          [
+            te['spent_date'],
+            te['notes'],
+            "#{te[hours_field]}h"
+          ]
+        end
+        total_grand = time_entries.map { |te| te[hours_field] }.sum
+        rows.push(['Total:', '', "#{total_grand}h"])
+        rows
+      end
+
+      def self.time_entries_params(connection, report_interval)
+        start_date, end_date = report_interval
+        params = {
+          project_id: connection['project_id'],
+          task_id: connection['task_id'],
+          from: start_date.to_s,
+          to: end_date.to_s
+        }
+        params[:is_billed] = connection['billable'] == 'yes' unless connection['billable'] == 'both'
+        params
+      end
+
+      def self.assignment_items(time_entries, connection)
+        hours_field = hours_field(connection['rounding'])
+        time_entries.map do |te|
+          {
+            time: te[hours_field],
+            date: te['spent_date'].to_s,
+            comment: te['notes']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sfctl/starfish/client.rb

@@ -0,0 +1,53 @@
+require 'faraday'
+require 'json'
+
+module Sfctl
+  module Starfish
+    module Client
+      def self.conn(endpoint, token)
+        raise 'Before continue please pass endpoint and token.' if endpoint.nil? || token.nil?
+
+        headers = {
+          'Content-Type' => 'application/json',
+          'X-Starfish-Auth' => token
+        }
+        Faraday.new(url: "#{endpoint}/api/v1", headers: headers) do |builder|
+          builder.request :retry
+          builder.adapter :net_http
+        end
+      end
+
+      def self.parsed_response(response)
+        [response.status == 200, JSON.parse(response.body)]
+      end
+
+      def self.check_authorization(endpoint, token)
+        response = conn(endpoint, token).get('profile')
+        response.status == 200
+      end
+
+      def self.account_info(endpoint, token)
+        response = conn(endpoint, token).get('profile')
+        parsed_response(response)
+      end
+
+      def self.account_assignments(endpoint, all, token)
+        api_conn = conn(endpoint, token)
+        response = all ? api_conn.get('assignments?all=1') : api_conn.get('assignments')
+        parsed_response(response)
+      end
+
+      def self.next_report(endpoint, token, assignment_id)
+        api_conn = conn(endpoint, token)
+        response = api_conn.get("assignments/#{assignment_id}/next_report")
+        parsed_response(response)
+      end
+
+      def self.update_next_report(endpoint, token, assignment_id, items)
+        api_conn = conn(endpoint, token)
+        response = api_conn.put("assignments/#{assignment_id}/next_report", JSON.generate(items: items))
+        response.status == 204
+      end
+    end
+  end
+end

data/lib/sfctl/toggl/client.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+require 'json'
+
+module Sfctl
+  module Toggl
+    module Client
+      DEFAULT_API_PATH = 'api/v8/'.freeze
+      REPORTS_API_PATH = 'reports/api/v2/'.freeze
+
+      def self.conn(token, api = 'default')
+        raise 'Please set toggl provider before continue.' if token.nil?
+
+        api_path = api == 'reports' ? REPORTS_API_PATH : DEFAULT_API_PATH
+
+        headers = { 'Content-Type' => 'application/json' }
+        Faraday.new(url: "https://#{token}:api_token@www.toggl.com/#{api_path}", headers: headers) do |builder|
+          builder.request :retry
+          builder.adapter :net_http
+        end
+      end
+
+      def self.parsed_response(response)
+        [response.status == 200, JSON.parse(response.body)]
+      end
+
+      def self.workspaces(token)
+        response = conn(token).get('workspaces')
+        parsed_response(response)
+      end
+
+      def self.workspace_projects(token, workspace_id)
+        response = conn(token).get("workspaces/#{workspace_id}/projects")
+        parsed_response(response)
+      end
+
+      def self.project_tasks(token, project_id)
+        response = conn(token).get("workspaces/#{project_id}/tasks")
+
+        return [] if response.body.length.zero?
+
+        parsed_response(response)
+      end
+
+      def self.time_entries(token, params)
+        params[:user_agent] = 'api_test'
+        response = conn(token, 'reports').get('details', params)
+        parsed_response(response)
+      end
+    end
+  end
+end

data/lib/sfctl/toggl/sync.rb

@@ -0,0 +1,105 @@
+require 'tty-spinner'
+require 'tty-table'
+require_relative '../command'
+require_relative './client'
+
+module Sfctl
+  module Toggl
+    module Sync
+      def self.load_data(output, connection, toggl_config, pastel, report_interval)
+        spinner = TTY::Spinner.new("Loaded data from #{Sfctl::Command::TOGGL_PROVIDER}: [:spinner]", format: :dots)
+        spinner.auto_spin
+
+        time_entries = get_time_entries(connection, toggl_config, report_interval)
+
+        spinner.success(pastel.green('Done'))
+
+        table = TTY::Table.new %w[Date Comment Time], time_entries_table_rows(time_entries)
+        output.puts
+        output.print table.render(:unicode, padding: [0, 1], alignments: %i[left left right])
+        output.puts
+        output.puts
+
+        time_entries
+      end
+
+      def self.time_entries_table_rows(time_entries)
+        rows = time_entries.sort_by { |te| te['start'] }.map do |te|
+          [
+            Date.parse(te['start']).to_s,
+            te['description'],
+            "#{humanize_duration(te['dur'])}h"
+          ]
+        end
+        total_grand = time_entries.sum { |te| te['dur'] }
+        rows.push(['Total:', '', "#{humanize_duration(total_grand)}h"])
+        rows
+      end
+
+      def self.get_time_entries(connection, toggl_config, report_interval)
+        entries_list = []
+
+        page = 1
+        loop do
+          _success, body = Toggl::Client.time_entries(
+            toggl_config['access_token'],
+            time_entries_params(connection, report_interval, page)
+          )
+
+          entries_list << body['data']
+          entries_list.flatten!
+          entries_list.compact!
+
+          break if entries_list.length >= body['total_count']
+
+          page += 1
+        end
+
+        entries_list
+      end
+
+      def self.time_entries_params(connection, report_interval, page = 1)
+        start_date, end_date = report_interval
+        params = {
+          workspace_id: connection['workspace_id'],
+          project_ids: connection['project_ids'],
+          billable: connection['billable'],
+          rounding: connection['rounding'],
+          since: start_date.to_s,
+          until: end_date.to_s,
+          page: page
+        }
+        params[:task_ids] = connection['task_ids'] if connection['task_ids'].length.positive?
+        params
+      end
+
+      def self.humanize_duration(milliseconds)
+        return '0' if milliseconds.nil?
+
+        seconds = milliseconds / 1000
+        minutes = seconds / 60
+        int = (minutes / 60).ceil
+        dec = minutes % 60
+        amount = (dec * 100) / 60
+        amount = if dec.zero?
+                   ''
+                 elsif amount.to_s.length == 1
+                   ".0#{amount}"
+                 else
+                   ".#{amount}"
+                 end
+        "#{int}#{amount}"
+      end
+
+      def self.assignment_items(time_entries)
+        time_entries.map do |te|
+          {
+            time: humanize_duration(te['dur']).to_f,
+            date: Date.parse(te['start']).to_s,
+            comment: te['description']
+          }
+        end
+      end
+    end
+  end
+end