sfctl 0.0.1

data/lib/sfctl/commands/time/providers/unset.rb

@@ -0,0 +1,43 @@
+require 'pastel'
+require 'tty-prompt'
+require_relative '../../../command'
+
+module Sfctl
+  module Commands
+    class Time
+      class Providers
+        class Unset < Sfctl::Command
+          def initialize(options)
+            @options = options
+            @pastel = Pastel.new(enabled: !@options['no-color'])
+          end
+
+          def execute(output: $stdout)
+            read_link_config
+
+            prompt = ::TTY::Prompt.new
+            provider = prompt.select('Unsetting:', PROVIDERS_LIST)
+
+            if config.fetch(:providers, provider).nil?
+              output.puts @pastel.yellow("[#{provider}] is already deleted from configuration.")
+            elsif prompt.yes?('Do you want to remove the delete the configuration?')
+              remove_provider!(provider, output)
+            end
+          rescue TTY::Config::ReadError
+            output.puts @pastel.yellow('Please initialize time before continue.')
+          end
+
+          private
+
+          def remove_provider!(provider, output)
+            providers = config.fetch(:providers)
+            providers.delete(provider)
+            config.set(:providers, value: providers)
+            save_link_config!
+            output.puts @pastel.green("Configuration for provider [#{provider}] was successfully deleted.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+require 'date'
+require 'pastel'
+require 'tty-prompt'
+require 'tty-spinner'
+require 'tty-table'
+require_relative '../../command'
+require_relative '../../starfish'
+require_relative '../../toggl'
+
+module Sfctl
+  module Commands
+    class Time
+      class Sync < Sfctl::Command # rubocop:disable Metrics/ClassLength
+        def initialize(options)
+          @options = options
+          @pastel = Pastel.new(enabled: !@options['no-color'])
+          @prompt = ::TTY::Prompt.new
+        end
+
+        def execute(output: $stdout)
+          return if !config_present?(output) || !link_config_present?(output)
+
+          success, data = Starfish.account_assignments(@options['starfish-host'], @options['all'], access_token)
+          unless success
+            output.puts @pastel.red('Something went wrong. Unable to fetch assignments')
+            return
+          end
+
+          sync_assignments(output, assignments_to_sync(data['assignments']))
+        rescue ThreadError, JSON::ParserError
+          output.puts @pastel.red('Something went wrong.')
+        end
+
+        private
+
+        def assignments_to_sync(assignments)
+          assignment_name = select_assignment(assignments)
+
+          return assignments if assignment_name == 'all'
+
+          assignments.select { |a| a['name'] == assignment_name }.to_a
+        end
+
+        def select_assignment(assignments)
+          @prompt.select('Which assignment do you want to sync?') do |menu|
+            assignments.each do |asmnt|
+              menu.choice name: "#{asmnt['name']} / #{asmnt['service']}", value: asmnt['name']
+            end
+            menu.choice name: 'All', value: 'all'
+          end
+        end
+
+        def sync_assignments(output, list)
+          list.each do |assignment|
+            assignment_name = assignment['name']
+            connection = read_link_config['connections'].select { |c| c == assignment_name }
+
+            if connection.empty?
+              output.puts @pastel.red("Unable to find a connection for assignment \"#{assignment_name}\"")
+              next
+            end
+
+            sync(output, assignment, connection[assignment_name])
+          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
+          output.puts "Synchronizing: #{@pastel.cyan("[#{assignment['name']} / #{assignment['service']}]")}"
+
+          success, next_report = Starfish.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)
+
+          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)
+        end
+
+        def touchy?(next_report)
+          @options['touchy'] && next_report['data'] == 'present'
+        end
+
+        def report_name(next_report)
+          "[#{next_report['year']}-#{next_report['month']}]"
+        end
+
+        def print_no_next_reporting_segment(output)
+          message = <<~HEREDOC
+            No next reporting segment on Starfish that accepts time report data, the synchronization will be skipped.
+          HEREDOC
+          output.puts @pastel.red(message)
+          true
+        end
+
+        def print_dry_run_enabled(output)
+          output.puts @pastel.yellow('Dry run enabled. Skipping upload to starfish.team.')
+          output.puts
+          true
+        end
+
+        def print_report_contains_data(output, next_report)
+          output.puts @pastel.yellow(
+            "Report #{report_name(next_report)} contains data. Skipping upload to starfish.team."
+          )
+          output.puts
+          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
+        end
+
+        def time_entries_table_rows(time_entries)
+          rows = time_entries.map do |te|
+            [
+              Date.parse(te['start']).to_s,
+              te['description'],
+              "#{humanize_duration(te['duration'])}h"
+            ]
+          end
+          rows.push(['Total:', '', "#{humanize_duration(time_entries.map { |te| te['duration'] }.sum)}h"])
+          rows
+        end
+
+        def get_toggle_time_entries(next_report, connection)
+          _success, time_entries = Toggl.time_entries(
+            read_link_config['providers'][TOGGL_PROVIDER]['access_token'], time_entries_params(next_report, connection)
+          )
+          unless connection['task_ids'].empty?
+            time_entries.delete_if { |te| !connection['task_ids'].include?(te['id'].to_s) }
+          end
+
+          time_entries
+        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
+          {
+            wid: connection['workspace_id'],
+            pid: connection['project_ids'],
+            start_date: start_date.to_datetime.to_s,
+            end_date: "#{end_date}T23:59:59+00:00"
+          }
+        end
+
+        def humanize_duration(seconds)
+          minutes = seconds / 60
+          int = (minutes / 60).ceil
+          dec = minutes % 60
+          amount = (dec * 100) / 60
+          amount = dec.zero? ? '' : ".#{amount}"
+          "#{int}#{amount}"
+        end
+
+        def assignment_items(time_entries)
+          time_entries.map do |te|
+            {
+              time: humanize_duration(te['duration']),
+              date: Date.parse(te['start']).to_s,
+              comment: te['description']
+            }
+          end
+        end
+
+        def uploading_to_starfish(output, assignment, time_entries)
+          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)
+          )
+          print_upload_results(output, success, spinner)
+        end
+
+        def print_upload_results(output, success, spinner)
+          if success
+            spinner.success(@pastel.green('Done'))
+          else
+            spinner.error
+            output.puts @pastel.red('Something went wrong. Unable to upload time entries to starfish.team')
+          end
+          output.puts
+          output.puts
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sfctl/starfish.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+require 'json'
+
+module Sfctl
+  module Starfish
+    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

data/lib/sfctl/templates/.gitkeep

@@ -0,0 +1 @@
+#

data/lib/sfctl/toggl.rb

@@ -0,0 +1,27 @@
+require 'faraday'
+require 'json'
+
+module Sfctl
+  module Toggl
+    def self.conn(token)
+      raise 'Please set toggl provider before continue.' if token.nil?
+
+      headers = {
+        'Content-Type' => 'application/json'
+      }
+      Faraday.new(url: "https://#{token}:api_token@www.toggl.com/api/v8/", 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.time_entries(token, params)
+      response = conn(token).get('time_entries', params)
+      parsed_response(response)
+    end
+  end
+end

data/lib/sfctl/version.rb

@@ -0,0 +1,3 @@
+module Sfctl
+  VERSION = '0.0.1'.freeze
+end

data/scripts/test.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+
+echo "---  Prepare :bundler: dependencies"
+bundle install
+
+echo "+++ Run :rspec:"
+bundle exec rspec

data/sfctl.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/sfctl/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'sfctl'
+  spec.license = 'MIT'
+  spec.version = Sfctl::VERSION
+  spec.authors = ['Serhii Rudik', 'Markus Kuhnt']
+  spec.email = ['serhii@starfish.team']
+
+  spec.summary = 'sfctl is a command line interface for the Starfish API.'
+  # spec.homepage      = ''
+  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'] = ''
+  # spec.metadata['changelog_uri'] = ''
+
+  # 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('..', __FILE__)) 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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: sfctl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Serhii Rudik
+- Markus Kuhnt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-08 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- serhii@starfish.team
+executables:
+- sfctl
+extensions: []
+extra_rdoc_files: []
+files:
+- ".buildkite/hooks/pre-command"
+- ".buildkite/pipeline.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/sfctl
+- lib/sfctl.rb
+- lib/sfctl/cli.rb
+- lib/sfctl/command.rb
+- lib/sfctl/commands/account.rb
+- lib/sfctl/commands/account/assignments.rb
+- lib/sfctl/commands/account/info.rb
+- lib/sfctl/commands/auth.rb
+- lib/sfctl/commands/auth/bye.rb
+- lib/sfctl/commands/auth/init.rb
+- lib/sfctl/commands/time.rb
+- lib/sfctl/commands/time/connections.rb
+- lib/sfctl/commands/time/connections/add.rb
+- lib/sfctl/commands/time/connections/get.rb
+- lib/sfctl/commands/time/init.rb
+- lib/sfctl/commands/time/providers.rb
+- lib/sfctl/commands/time/providers/get.rb
+- lib/sfctl/commands/time/providers/set.rb
+- lib/sfctl/commands/time/providers/unset.rb
+- lib/sfctl/commands/time/sync.rb
+- lib/sfctl/starfish.rb
+- lib/sfctl/templates/.gitkeep
+- lib/sfctl/toggl.rb
+- lib/sfctl/version.rb
+- scripts/test.sh
+- sfctl.gemspec
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: sfctl is a command line interface for the Starfish API.
+test_files: []