toggl_cache 0.1.0

data/lib/toggl_api/reports_client.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require "uri"
+require "httparty"
+require "toggl_api/base_client"
+
+module TogglAPI
+
+  # The Toggl API Client
+  class ReportsClient < BaseClient
+    API_URL = "https://toggl.com/reports/api/v2"
+
+    # @param params [Hash]: Toggl API params
+    #   - date_since
+    #   - date_until
+    #   - workspace_id
+    #   - ... more params available, see Toggl API documentation for details
+    def fetch_reports(params)
+      page = 1
+      all_results = []
+      loop do
+        results_raw = fetch_reports_details_raw(
+          params.merge(page: page)
+        )
+        results = results_raw["data"]
+
+        all_results += results
+        break if all_results.count == results_raw["total_count"]
+        page += 1
+      end
+      all_results
+    end
+
+    private
+
+    def fetch_reports_details_raw(params)
+      fetch_reports_raw(api_url(:details), params)
+    end
+
+    def fetch_reports_summary_raw(params)
+      fetch_reports_raw(api_url(:summary), params)
+    end
+
+    # @param url [String]
+    # @param params [Hash]: Toggl API params
+    def fetch_reports_raw(url, params)
+      logger.info "Fetching Toggl reports for params #{params}" if logger
+      params = { user_agent: @user_agent }.merge(params)
+      response = HTTParty.get(
+        url,
+        headers: headers,
+        query: params,
+        basic_auth: credentials
+      )
+
+      handle_response(response)
+    end
+
+    def headers
+      { "Content-Type" => "application/json" }
+    end
+
+    def credentials
+      {
+        username: @api_token,
+        password: "api_token"
+      }
+    end
+
+    def handle_response(response)
+      if response.code == 200 || response.code == 201
+        JSON.parse(response.body)
+      else
+        fail(Error, "Toggl API error #{response.code}: #{response.body}")
+      end
+    end
+
+    def api_url(resource)
+      "#{API_URL}/#{resource}"
+    end
+  end
+end

data/lib/toggl_cache.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require "logger"
+require "toggl_api/reports_client"
+require "toggl_cache/data/report_repository"
+require "toggl_cache/version"
+
+# Facility to store/cache Toggl reports data in a PostgreSQL database.
+module TogglCache
+  HOUR = 3_600
+  DAY = 24 * HOUR
+  MONTH = 31 * DAY
+  DEFAULT_DATE_SINCE = Time.now - 1 * DAY # MONTH
+  DEFAULT_WORKSPACE_ID = ENV["TOGGL_WORKSPACE_ID"]
+
+  # Fetches new and updated reports from the specified start
+  # date to now. By default, fetches all reports since 1 month
+  # ago, allowing updates on old reports to update the cached
+  # reports too.
+  #
+  # The fetched reports either update the already
+  # existing ones, or create new ones.
+  #
+  # @param client [TogglAPI::Client] a configured client
+  # @param workspace_id [String] Toggl workspace ID (mandatory)
+  # @param date_since [Date] Date since when to fetch
+  #   the reports.
+  def self.sync_reports(client: default_client,
+                        date_since: default_date_since)
+    reports = fetch_reports(
+      client: client,
+      date_since: date_since
+    )
+    process_reports(reports)
+  end
+
+  # Fetch from Toggl
+  #
+  # Handles a fetch over multiple years, which requires splitting the requests
+  # over periods extending on a single year (Toggl API requirement).
+  # # @param client [TogglCache::Client] configured client
+  # @param workspace_id [String] Toggl workspace ID
+  # @param date_since [Date] Date since when to fetch
+  #   the reports
+  # @param date_until [Date] Date until when to fetch
+  #   the reports, defaults to Time.now
+  def self.fetch_reports(
+    client: default_client,
+    workspace_id: default_workspace_id,
+    date_since:,
+    date_until: Time.now
+  )
+    if date_since && date_until.year > date_since.year
+      fetch_reports(
+        client: client,
+        workspace_id: workspace_id,
+        date_since: date_since,
+        date_until: Date.new(date_since.year, 12, 31)
+      ) + fetch_reports(
+        client: client,
+        workspace_id: workspace_id,
+        date_since: Date.new(date_since.year + 1, 1, 1),
+        date_until: date_until
+      )
+    else
+      options = {
+        workspace_id: workspace_id, until: date_until.strftime("%Y-%m-%d")
+      }
+      options[:since] = date_since.strftime("%Y-%m-%d") unless date_since.nil?
+      client.fetch_reports(options)
+    end
+  end
+
+  def self.process_reports(reports)
+    reports.each do |report|
+      Data::ReportRepository.create_or_update(report)
+    end
+  end
+
+  def self.default_client(logger: default_logger)
+    return TogglAPI::ReportsClient.new(logger: logger) if logger
+    TogglAPI::ReportsClient.new
+  end
+
+  def self.default_workspace_id
+    DEFAULT_WORKSPACE_ID
+  end
+
+  def self.default_date_since
+    DEFAULT_DATE_SINCE
+  end
+
+  def self.default_logger
+    logger = ::Logger.new(STDOUT)
+    logger.level = default_log_level
+    logger
+  end
+
+  def self.default_log_level
+    Logger.const_get(ENV["TOGGL_CACHE_LOG_LEVEL"]&.upcase || "ERROR")
+  end
+end

data/lib/toggl_cache/data.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require "sequel"
+
+module TogglCache
+  module Data
+    DATABASE_URL = ENV["DATABASE_URL"]
+    DB = Sequel.connect(DATABASE_URL)
+    DB.extension :pg_array, :pg_json
+  end
+end

data/lib/toggl_cache/data/report_repository.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+require "toggl_cache/data"
+require "active_support/inflector"
+
+module TogglCache
+  module Data
+
+    # Superclass for repositories. Simply provide some shared
+    # methods.
+    class ReportRepository
+
+      MAPPED_REPORT_ATTRIBUTES = %w(
+        description
+        pid
+        project
+        uid
+        user
+        task
+        tid
+      ).freeze
+
+      # It inserts a new issue row with the specified data.
+      # If the issue already exists (unicity key is `id`)
+      # the row is updated instead.
+      def self.create_or_update(report)
+        id = report["id"].to_s
+        if exist_with_id?(id)
+          update_where({ id: id }, row(report: report))
+        else
+          table.insert row(report: report, insert_created_at: true)
+        end
+      end
+
+      def self.find_by_id(id)
+        table.where(id: id).first
+      end
+
+      def self.exist_with_id?(id)
+        table.where(id: id).count != 0
+      end
+
+      def self.delete_where(where_data)
+        table.where(where_data).delete
+      end
+
+      def self.update_where(where_data, values)
+        table.where(where_data).update(values)
+      end
+
+      def self.first_where(where_data)
+        table.where(where_data).first
+      end
+
+      def self.index
+        table.entries
+      end
+
+      def self.count
+        table.count
+      end
+
+      def self.table
+        DB[:toggl_cache_reports]
+      end
+
+      def self.row(report:, insert_created_at: false, insert_updated_at: true)
+        new_report = map_report_attributes(report: report)
+        new_report = add_timestamps(
+          report: new_report,
+          insert_created_at: insert_created_at,
+          insert_updated_at: insert_updated_at
+        )
+        new_report
+      end
+
+      def self.map_report_attributes(report:)
+        new_report = report.select { |k, _| MAPPED_REPORT_ATTRIBUTES.include?(k) }
+        new_report = new_report.merge(
+          duration: report["dur"] / 1_000,
+          end: report["end"] ? Time.parse(report["end"]) : nil,
+          id: report["id"].to_s,
+          start: Time.parse(report["start"]),
+          toggl_updated: Time.parse(report["updated"])
+        )
+        new_report
+      end
+
+      def self.add_timestamps(report:, insert_created_at:, insert_updated_at:)
+        new_report = {}.merge(report)
+        new_report["created_at"] = Time.now if insert_created_at
+        new_report["updated_at"] = Time.now if insert_updated_at
+        new_report
+      end
+    end
+  end
+end

data/lib/toggl_cache/version.rb

@@ -0,0 +1,3 @@
+module TogglCache
+  VERSION = File.read(File.expand_path('../../../VERSION', __FILE__)).strip
+end

data/lib/toggl_cli.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+require "thor"
+require "tty-pager"
+require "tty-progressbar"
+require "tty-spinner"
+# require "tty-table"
+require File.expand_path("../../config/boot", __FILE__)
+require "toggl_api/client"
+require "toggl_cache/data/report_repository"
+
+class TogglCLI < Thor
+  package_name "TogglCLI"
+  include Thor::Shell
+  FILTERS = %w(no description user clear).freeze
+  SHOW_REPORTS_COLUMNS = %w(description user duration).freeze
+
+  # Batch edition
+  # Workflow:
+  #   - select source project / task
+  #   - provide information about matching reports
+  #   - enable user to filter reports
+  #   - select target project / task
+  #   - apply transformation
+  desc "batch", "Batch edition"
+  method_option :no_cache_update, desc: "Don't update the local cache", type: :boolean
+  def batch
+    # TEMP
+    # source_project = select_project("Select the source project")
+    # source_task = select_task("Select the source task", source_project["id"])
+    source_project = { "name" => "technical (fake)", "id" => 9800254 }
+    source_task = { "name" => "No task", "id" => nil }
+    # END TEMP
+
+    reports = find_reports(source_project["id"], source_task["id"])
+    show_reports_info(reports)
+    reports = filter_reports(reports)
+
+    unless no?("Move these reports to a new project / task (enter 'n' or 'no' to cancel)")
+      target_project = select_project("Select the target project")
+      target_task = select_task("Select the target task", target_project["id"])
+
+      say(
+        "Will move #{reports.count} reports, " \
+        "from #{source_project['name']} > #{source_task['name']} " \
+        "to #{target_project['name']} > #{target_task['name']}"
+      )
+      if yes?("Are you sure? (enter 'y' or 'yes' to continue)")
+        say("MOVING!!!")
+      end
+    end
+    # TogglCache::Data::ReportRepository.create_or_update(report)
+  end
+
+  private
+
+  def filter_reports(reports)
+    begin
+      selected_filter = ask("Add filter?", limited_to: FILTERS)
+      reports = (
+        case selected_filter
+        when "no" then reports
+        when "description" then propose_description_regexp_filter(reports)
+        when "user" then propose_user_filter(reports)
+        else raise "Unexpected filter `#{selected_filter}`"
+        end
+      )
+      show_reports_info(reports)
+    end while(selected_filter != "no")
+    reports
+  end
+
+  def propose_description_regexp_filter(reports)
+    show_unique_descriptions(reports)
+    if yes?("Add regexp filter? (enter 'y' or 'yes' to continue)")
+      regexp = eval(ask("Enter regexp (e.g. /string/i - will go through `eval`):"))
+      filtered = reports.select { |r| r[:description] =~ regexp }
+      show_unique_descriptions(filtered)
+      return filtered unless no?("Keep filter? (enter 'n' or 'no' to discard the filter)")
+    end
+    reports
+  end
+
+  def propose_user_filter(reports)
+    selected_user = select_in_list(reports.map { |r| r[:user] }.uniq, "Select user")
+    filtered = reports.select { |r| r[:user] == selected_user }
+    show_reports_info(filtered)
+    return filtered unless no?("Keep filter? (enter 'n' or 'no' to discard the filter)")
+    reports
+  end
+
+  def show_unique_descriptions(reports)
+    unique_descriptions = reports.map { |r| r[:description] }.uniq
+    say("Found #{unique_descriptions.count} unique descriptions.")
+    if yes?("Show unique descriptions? (enter 'y' or 'yes' to show)")
+      page(unique_descriptions.join("\n") << "\n")
+    end
+  end
+
+  def show_reports_info(reports)
+    say("#{reports.count} matching reports.")
+    show_reports(reports) if yes?("Show reports? (enter 'y' or 'yes' to show)")
+  end
+
+  def show_reports(reports)
+    report_lines = reports.map do |r|
+      report_columns = SHOW_REPORTS_COLUMNS.map do |c|
+        r[c.to_sym]
+      end
+      report_columns.join(" | ")
+    end
+    page(report_lines.join("\n") << "\n")
+  end
+
+  def find_reports(project_id, task_id)
+    with_spinner("Fetching matching reports...") do
+      where_criteria = { pid: project_id.to_i }
+      where_criteria[:tid] = task_id if task_id
+      TogglCache::Data::ReportRepository.table.where(where_criteria).entries
+    end
+  end
+
+  def select_in_list(items, msg)
+    items.each.with_index { |item, i| say("  #{i}. #{item}") }
+    begin
+      index = ask("#{msg} (0-#{items.count - 1})").to_i
+    end while(index < 0 || index > items.count - 1)
+    items[index]
+  end
+
+  def select_project(msg)
+    say("Projects:")
+    project_name = select_in_list(project_names, msg)
+    project = projects.find { |p| p["name"] == project_name }
+    say("Selected project `#{project["name"]}`")
+    project
+  end
+
+  def select_task(msg, project_id)
+    source_project_tasks = project_tasks(project_id)
+    return { "id" => nil, "name" => "No task" } if source_project_tasks.empty?
+    say("Tasks for selected project:")
+    source_project_tasks.each.with_index do |task, i|
+      say("  #{i}. #{task['name']}")
+    end
+    begin
+      source_task_index = ask("#{msg} (0-#{source_project_tasks.count - 1})").to_i
+    end while(source_task_index < 0 || source_task_index > source_project_tasks.count - 1)
+    source_task = source_project_tasks[source_task_index]
+  end
+
+  def projects
+    @projects ||= (
+      with_spinner("Fetching projects...") do
+        client.get_workspace_projects(active: "both")
+      end
+    )
+  end
+
+  def project_tasks(project_id)
+    tasks = with_spinner("Fetching tasks...") do
+      client.get_project_tasks(project_id: project_id)
+    end
+    tasks.map do |task|
+      { "id" => task["id"], "name" => task["name"] }
+    end
+  end
+
+  def project_names
+    projects.map { |p| p["name"] }
+  end
+
+  def client
+    @client ||= TogglAPI::Client.new
+  end
+
+  def build_spinner(title)
+    TTY::Spinner.new("#{title} [:spinner]")
+  end
+
+  def build_bar(msg, count)
+    TTY::ProgressBar.new("#{msg} [:bar]", total: count)
+  end
+
+  def with_spinner(msg)
+    spinner = build_spinner(msg)
+    result = nil
+    yield
+    spinner.run("Done!") { result = yield }
+    result
+  end
+
+  def page(text)
+    pager = TTY::Pager::BasicPager.new
+    pager.page(text)
+  end
+end
+
+TogglCLI.start