freeagent-cli 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7abedc65bda2e935eac6777922e6b06f227745e2de0b1e60b8e1de95c72a0d83
-  data.tar.gz: b2c6ae0c9595a8087cf87360a8dc62ba9c5c4eb02da2e6b0a7cba346fb7f0a4b
+  metadata.gz: 2703612db678ca26cedc911b865604fec14eb13221ec8f359518da6b5b53a8e9
+  data.tar.gz: 26fc95d6335bd2173009fffb59f10dc5412108cd9543f553e4f8d234950c4fa7
 SHA512:
-  metadata.gz: 29fd16c93ea509618580da1d8b6e45738cc25917a945d77e213ef53cd8e345c57e118a2cfe493d28b497ba7de9b5b658b57af6fb26edb58a2e4307ea859e1d0e
-  data.tar.gz: c648be179c9d9ab46a9831b4a2d3ca412fd47bb2c4db729f86737b588bf46819d1ac0dbc747841a9d0ac7db6f025e5be63c4f39773e2c6444c727ce5d9f198ff
+  metadata.gz: 78f9c14112b395a5a011a5e5caa82ce4838531f59ec09a9e2955b0b59fc8e1722ce645f8db4b6fc28922d154a881afb85c0b0a38cdfb754559f64c326acd716d
+  data.tar.gz: 29192da5d9ef6905a7aa1f6342b7a925e35506f6342d8821331021076a979b4a8137a8df99eae482edf40ca87e53617a28a4c128506df9e0256d00b5a7b71aac

data/Rakefile

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-task default: %i[]
+task default: %i[build]

data/exe/fa

@@ -2,6 +2,7 @@
 
 require 'dotenv/load'
 require 'thor'
+require 'snaky_hash'
 require_relative '../lib/freeagent'
 
 def match type, collection, needle, *values
@@ -10,7 +11,7 @@ def match type, collection, needle, *values
   end
   if found.none?
     possibles = collection.product(values).map {|item, value| value.to_proc.call(item).to_s }
-    raise ArgumentError, "No #{type} matching '#{needle}' found, expecting one from #{possibles}"
+    raise ArgumentError, "No #{type} matching '#{needle}' found, expecting one from:\n#{possibles.sort.join("\n")}"
   end
   unless found.one?
     raise ArgumentError, "Ambiguous #{type}: could be #{found.map(&:url).join(', ')}"
@@ -18,85 +19,681 @@ def match type, collection, needle, *values
   found.first
 end
 
+def sql_format value
+  case value
+  when Numeric; value.to_s
+  else; "'" + value.gsub(/'/, "''") + "'"
+  end
+end
+
+def id_from_url url
+  URI.parse(url).path.split('/').last.to_i
+end
+
+def select_task project, task_name
+  tasks = api.tasks(project: project)
+  if task_name.nil?
+    raise ArgumentError, "Expecting only one task in project #{project.name}, found #{tasks.size}" if not tasks.one?
+    tasks.first
+  else
+    match :task, tasks, task_name, :name
+  end
+end
+
 module Freeagent
+  class Contacts < Thor
+    no_commands do
+      def sql contact
+        <<~SQL
+          INSERT OR REPLACE INTO contacts (id, first_name, last_name, organisation_name) VALUES (#{[
+            id_from_url(contact.url),
+            contact.first_name,
+            contact.last_name,
+            contact.organisation_name,
+          ].map(&method(:sql_format)).join(', ')});
+        SQL
+      end
+    end
+
+    SQL_SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS contacts (
+        id INTEGER PRIMARY KEY,
+        first_name TEXT,
+        last_name TEXT,
+        organisation_name TEXT
+      );
+    SQL
+  end
+
   class Timeslips < Thor
     no_commands do
       def api
         @api ||= API.new
       end
+
+      def users
+        @users ||= Hash.new {|cache, url| cache[url] = api.user url.split('/').last }
+      end
+
+      def projects
+        @projects ||= Hash.new {|cache, url| cache[url] = api.project url.split('/').last }
+      end
+
+      def tasks
+        @tasks ||= Hash.new {|cache, url| cache[url] = api.task url.split('/').last }
+      end
+
+      def human timeslip
+        [
+          Date::parse(timeslip.dated_on).strftime('%a %d %b %Y'),
+          users[timeslip.user].email,
+          projects[timeslip.project].name,
+          tasks[timeslip.task].name,
+          timeslip.hours,
+          timeslip.comment
+        ].join("\t")
+      end
     end
 
-    desc 'list USER PROJECT TASK FROM TO', "List timeslips"
-    def list user, project, task, from, to
-      from = Date::parse from
-      to = Date::parse to
-      user = match :user, api.users, user, :first_name, :last_name, :email
-      project = match :project, api.projects, project, :name
-      task = match :task, api.tasks(project), task, :name
+    desc 'list [-U USER] [-P PROJECT [-T TASK]] [-f FROM] [-t TO]', "List timeslips"
+    method_option :user, aliases: '-U', type: :string, default: nil, desc: 'Name or email of a user'
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: 'Name of a project'
+    method_option :task, aliases: '-T', type: :string, default: nil, desc: 'Name of a task within the project'
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list timeslips from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list timeslips to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def list
+      raise ArgumentError, '--project must be specified if --task if used' if options[:project].nil? && !options[:task].nil?
+
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+      user = options[:user].nil? ? nil : match(:user, api.users, options[:user], :first_name, :last_name, :email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+      task = options[:task].nil? ? nil : match(:task, api.tasks(project: project), options[:task], :name)
+
+      users[user.url] = user unless user.nil?
+      projects[project.url] = project unless project.nil?
+      tasks[task.url] = task unless task.nil?
 
       api.timeslips(user: user, project: project, task: task, from: from, to: to).each do |timeslip|
-        puts [Date::parse(timeslip.dated_on).strftime('%a %d %b %Y'), user.email, project.name, task.name, timeslip.hours, timeslip.comment].join("\t")
+        puts case options[:format].downcase
+        when 'human'; human(timeslip)
+        when 'json'; timeslip.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
       end
     end
 
-    desc 'create USER PROJECT TASK [FROM [TO]]', "Create timeslips"
+    desc 'create USER PROJECT [TASK [FROM [TO]]]', "Create timeslips"
     method_option :hours, aliases: '-h', type: :numeric, default: 8, desc: "Number of hours per day"
     method_option :weekends, aliases: '-w', type: :boolean, default: false, desc: "Create timeslips on Saturdays and Sundays"
     method_option :comment, aliases: '-c', type: :string, default: nil, desc: "Comment to add to any created timeslips"
-    def create user, project, task, from = nil, to = nil
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def create user, project, task = nil, from = nil, to = nil
       from = from.nil? ? Date::today : Date::parse(from)
       to = to.nil? ? from : Date::parse(to)
       user = match :user, api.users, user, :first_name, :last_name, :email
       project = match :project, api.projects, project, :name
-      task = match :task, api.tasks(project), task, :name
+      task = select_task project, task
+
+      users[user.url] = user unless user.nil?
+      projects[project.url] = project unless project.nil?
+      tasks[task.url] = task unless task.nil?
 
-      puts "Creating timeslips for #{user.first_name} #{user.last_name} for task '#{task.name}' in project '#{project.name}' between #{from} and #{to} inclusive"
       timeslips = from.step(to).map do |date|
         next if (date.saturday? || date.sunday?) && !options[:weekends]
-        {'task' => task.url, 'project' => project.url, 'user' => user.url, 'dated_on' => date.to_s, 'hours' => options[:hours], 'comment' => options[:comment]}
+        SnakyHash::StringKeyed.new(task: task.url, project: project.url, user: user.url, dated_on: date.to_s, hours: options[:hours], comment: options[:comment])
       end.reject(&:nil?)
       api.batch_create_timeslips timeslips
+      timeslips.each do |timeslip|
+        puts case options[:format].downcase
+        when 'human'; human(timeslip)
+        when 'json'; timeslip.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
     end
 
-    desc 'fill USER PROJECT TASK [FROM [TO]]', 'Fill remaining hours with new timeslips'
+    desc 'fill USER PROJECT [TASK [FROM [TO]]]', 'Fill remaining hours with new timeslips'
     method_option :hours, aliases: '-h', type: :numeric, default: 8, desc: "Number of hours per day"
     method_option :weekends, aliases: '-w', type: :boolean, default: false, desc: "Create timeslips on Saturdays and Sundays"
     method_option :comment, aliases: '-c', type: :string, default: nil, desc: "Comment to add to any created timeslips"
-    def fill user, project, task, from = nil, to = nil
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def fill user, project, task = nil, from = nil, to = nil
       from = from.nil? ? Date::today : Date::parse(from)
       to = to.nil? ? from : Date::parse(to)
       user = match :user, api.users, user, :first_name, :last_name, :email
       project = match :project, api.projects, project, :name
-      task = match :task, api.tasks(project), task, :name
+      task = select_task project, task
+
+      users[user.url] = user unless user.nil?
+      projects[project.url] = project unless project.nil?
+      tasks[task.url] = task unless task.nil?
 
       existing = api.timeslips(user: user, from: from, to: to).reduce(Hash.new) do |hash, timeslip|
         date = Date::parse timeslip.dated_on
         hash.update({date => (hash[date] || 0) + timeslip.hours.to_f})
       end
 
-      puts "Filling timeslips for #{user.first_name} #{user.last_name} up to #{options[:hours]}hrs using task '#{task.name}' in project '#{project.name}' between #{from} and #{to} inclusive"
       timeslips = from.step(to).map do |date|
         next if (date.saturday? || date.sunday?) && !options[:weekends]
         existing_hours = existing[date] || 0
         adding_hours = options[:hours] - existing_hours
         next if adding_hours <= 0
 
-        {'task' => task.url, 'project' => project.url, 'user' => user.url, 'dated_on' => date.to_s, 'hours' => adding_hours.to_s, 'comment' => options[:comment]}
+        SnakyHash::StringKeyed.new(task: task.url, project: project.url, user: user.url, dated_on: date.to_s, hours: adding_hours.to_s, comment: options[:comment])
       end.reject(&:nil?)
       api.batch_create_timeslips timeslips
+      timeslips.each do |timeslip|
+        puts case options[:format].downcase
+        when 'human'; human(timeslip)
+        when 'json'; timeslip.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+
+    desc 'import [-U USER] [-P PROJECT [-T TASK]]', 'Import timeslips'
+    method_option :user, aliases: '-U', type: :string, default: nil, desc: 'Name or email of a user to override in input data'
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: 'Name of a project to override in input data'
+    method_option :task, aliases: '-T', type: :string, default: nil, desc: 'Name of a task within the project to override in input data'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def import
+      raise ArgumentError, '--project must be specified if --task if used' if options[:project].nil? && !options[:task].nil?
+
+      user = options[:user].nil? ? nil : match(:user, api.users, options[:user], :first_name, :last_name, :email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+      task = options[:task].nil? ? nil : match(:task, api.tasks(project: project), options[:task], :name)
+
+      users[user.url] = user unless user.nil?
+      projects[project.url] = project unless project.nil?
+      tasks[task.url] = task unless task.nil?
+
+      api.batch_create_timeslips(JSON.parse(STDIN.read, object_class: SnakyHash::SymbolKeyed).map do |timeslip|
+        timeslip.user = user.url unless user.nil?
+        timeslip.project = project.url unless project.nil?
+        timeslip.task = task.url unless task.nil?
+
+        puts case options[:format].downcase
+        when 'human'; human(timeslip)
+        when 'json'; timeslip.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+
+        timeslip
+      end)
     end
 
     desc 'delete USER PROJECT TASK [FROM [TO]]', 'Delete timeslips'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
     def delete user, project, task, from = nil, to = nil
       from = from.nil? ? Date::today : Date::parse(from)
       to = to.nil? ? from : Date::parse(to)
       user = match :user, api.users, user, :first_name, :last_name, :email
       project = match :project, api.projects, project, :name
-      task = match :task, api.tasks(project), task, :name
+      task = match :task, api.tasks(project: project), task, :name
+
+      users[user.url] = user unless user.nil?
+      projects[project.url] = project unless project.nil?
+      tasks[task.url] = task unless task.nil?
 
-      puts "Deleting timeslips for #{user.first_name} #{user.last_name} for task '#{task.name}' in project '#{project.name}' between #{from} and #{to} inclusive"
       api.timeslips(user: user, project: project, task: task, from: from, to: to).each do |timeslip|
         api.delete_timeslip(timeslip)
+        puts case options[:format].downcase
+        when 'human'; human(timeslip)
+        when 'json'; timeslip.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+  end
+
+  class Projects < Thor
+    no_commands do
+      def api
+        @api ||= API.new
+      end
+
+      def contacts
+        @contacts ||= Hash.new {|cache, url| cache[url] = api.contact url.split('/').last }
+      end
+
+      def human project
+        [
+          project.name,
+          project.contact_name,
+          project.status,
+          project.starts_on,
+          project.ends_on,
+          project.budget,
+          project.notes && project.notes.map(&:note).join('; '),
+        ].join("\t")
+      end
+
+      def sql project
+        <<~SQL
+          #{Contacts.new.sql(contacts[project.contact])}
+          INSERT OR REPLACE INTO projects (id, contact_id, name, status, starts_on, ends_on, budget, budget_units) VALUES (#{[
+            id_from_url(project.url),
+            id_from_url(project.contact),
+            project.name,
+            project.status,
+            project.starts_on,
+            project.ends_on,
+            project.budget.to_f,
+            project.budget_units,
+          ].map(&method(:sql_format)).join(', ')});
+        SQL
+      end
+    end
+
+    SQL_SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS projects (
+        id INTEGER PRIMARY KEY,
+        contact_id INTEGER,
+        name TEXT,
+        status TEXT,
+        starts_on TEXT,
+        ends_on TEXT,
+        budget REAL,
+        budget_units TEXT,
+        FOREIGN KEY (contact_id) REFERENCES contacts(id)
+      );
+    SQL
+
+    desc 'list [-C CONTACT] [NAME [NAME ...]]', 'List projects'
+    method_option :contact, aliases: '-C', type: :string, default: nil, desc: "Limit to a contact, identified by name or email"
+    method_option :notes, type: :boolean, default: true, desc: 'Include notes in output'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def list *names
+      contact = options[:contact].nil? ? nil : match(:contact, api.contacts, options[:contact], :first_name, :last_name, :organisation_name, :email, :billing_email)
+      contacts[contact.url] = contact unless contact.nil?
+
+      api.projects(contact: contact).select do |project|
+        names.empty? || names.include?(project.name)
+      end.each do |project|
+        project.contact = contacts[project.contact]
+        if options[:notes]
+          project.notes = api.notes(project: project.url)
+          project.contact.notes = api.notes(contact: project.contact.url)
+        end
+
+        puts case options[:format].downcase
+        when 'human'; human(project)
+        when 'json'; project.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+  end
+
+  class Tasks < Thor
+    no_commands do
+      def api
+        @api ||= API.new
+      end
+
+      def projects
+        @projects ||= Hash.new {|cache, url| cache[url] = api.project url.split('/').last }
+      end
+
+      def human task
+        [
+          task.name,
+          projects[task.project].name,
+          task.status,
+          task.is_billable ? "#{task.billing_rate} #{task.currency} / #{task.billing_period}" : 'Unbillable'
+        ].join("\t")
+      end
+    end
+
+    STATUSES = %i[ active completed hidden ]
+
+    desc 'list [-P PROJECT] [-S STATUS]', 'List tasks'
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: "Limit to a project, identified by name"
+    method_option :status, aliases: '-S', type: :string, default: nil, desc: "Match a status, one of: #{STATUSES.join(', ')}"
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def list
+      status = options[:status].nil? ? nil : match(:status, STATUSES, options[:status], :to_s)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+
+      projects[project.url] = project unless project.nil?
+      api.tasks(project: project.url, view: status).each do |task|
+        puts case options[:format].downcase
+          when 'human'; human(task)
+          when 'json'; task.to_json
+          else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+
+    desc 'update STATUS [-P PROJECT] [-T TASK]', 'Update the status of a task'
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: 'Name of a project'
+    method_option :task, aliases: '-T', type: :string, default: nil, desc: 'Name of a task'
+    def update project, task, status
+      status = match(:status, STATUSES, status, :to_s)
+      project = match(:project, api.projects, project, :name)
+      task = match(:task, api.tasks(project: project), task, :name)
+
+      projects[project.url] = project unless project.nil?
+
+      api.tasks
+      task.status = status
+      api.update_task(task)
+
+      puts case options[:format].downcase
+        when 'human'; human(task)
+        when 'json'; task.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+      end
+    end
+
+    desc 'delete PROJECT TASK', 'Delete a task'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def delete project, task
+      project = match :project, api.projects, project, :name
+      task = match :task, api.tasks(project: project), task, :name
+
+      projects[project.url] = project unless project.nil?
+
+      api.delete_task(task)
+      puts case options[:format].downcase
+        when 'human'; human(task)
+        when 'json'; task.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+      end
+    end
+  end
+
+  class Invoices < Thor
+    no_commands do
+      def api
+        @api ||= API.new
+      end
+
+      def contacts
+        @contacts ||= Hash.new {|cache, url| cache[url] = api.contact url.split('/').last }
+      end
+
+      def projects
+        @projects ||= Hash.new {|cache, url| cache[url] = api.project url.split('/').last }
+      end
+
+      def human invoice
+        [
+          Date::parse(invoice.dated_on).strftime('%a %d %b %Y'),
+          Date::parse(invoice.due_on).strftime('%a %d %b %Y'),
+          invoice.contact_name,
+          projects[invoice.project].name,
+          invoice.reference,
+          invoice.total_value,
+          invoice.net_value,
+        ].join("\t")
+      end
+
+      def human_item item
+        [
+          item.description,
+          item.quantity,
+          item.item_type,
+          item.price,
+        ].join("\t")
+      end
+    end
+
+    STATUSES = %i[ all recent_open_or_overdue open overdue open_or_overdue draft paid scheduled_to_email thank_you_emails reminder_emails ]
+
+    desc 'list [-C CONTACT] [-P PROJECT] [-S STATUS] [-f FROM] [-t TO]', "List invoices"
+    method_option :contact, aliases: '-C', type: :string, default: nil, desc: "Limit to a contact, identified by name or email"
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: "Limit to a project, identified by name"
+    method_option :status, aliases: '-S', type: :string, default: nil, desc: "Invoices that match a status, one of: #{STATUSES.join(', ')}"
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list invoices from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list invoices to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def list
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+      status = options[:status].nil? ? nil : match(:status, STATUSES, options[:status], :to_s)
+      contact = options[:contact].nil? ? nil : match(:contact, api.contacts, options[:contact], :first_name, :last_name, :organisation_name, :email, :billing_email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+
+      contacts[contact.url] = contact unless contact.nil?
+      projects[project.url] = project unless project.nil?
+      api.invoices(contact: contact, project: project, view: status).select do |invoice|
+        from.nil? || Date::parse(invoice.dated_on) >= from
+      end.each do |invoice|
+        puts case options[:format].downcase
+        when 'human'; human(invoice)
+        when 'json'; invoice.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+
+    desc 'items [-C CONTACT] [-P PROJECT] [-S STATUS] [-f FROM] [-t TO]', 'List invoice items'
+    method_option :contact, aliases: '-C', type: :string, default: nil, desc: "Limit to a contact, identified by name or email"
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: "Limit to a project, identified by name"
+    method_option :status, aliases: '-S', type: :string, default: nil, desc: "Invoices that match a status, one of: #{STATUSES.join(', ')}"
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list invoices from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list invoices to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human or json'
+    def items
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+      status = options[:status].nil? ? nil : match(:status, statuses, options[:status], :to_s)
+      contact = options[:contact].nil? ? nil : match(:contact, api.contacts, options[:contact], :first_name, :last_name, :organisation_name, :email, :billing_email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+
+      contacts[contact.url] = contact unless contact.nil?
+      projects[project.url] = project unless project.nil?
+      list_call(contact: contact, project: project, view: status, nested_invoice_items: true).select do |invoice|
+        from.nil? || Date::parse(invoice.dated_on) >= from
+      end.flat_map(&:invoice_items).each do |item|
+        puts case options[:format].downcase
+        when 'human'; human_item(item)
+        when 'json'; item.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+  end
+
+  class Bills < Thor
+    no_commands do
+      def api
+        @api ||= API.new
+      end
+
+      def contacts
+        @contacts ||= Hash.new {|cache, url| cache[url] = api.contact url.split('/').last }
+      end
+
+      def projects
+        @projects ||= Hash.new {|cache, url| cache[url] = api.project url.split('/').last }
+      end
+
+      def human bill
+        [
+          Date::parse(bill.dated_on).strftime('%a %d %b %Y'),
+          Date::parse(bill.due_on).strftime('%a %d %b %Y'),
+          bill.contact_name,
+          projects[bill.project].name,
+          bill.reference,
+          bill.total_value,
+          bill.net_value,
+        ].join("\t")
+      end
+
+      def sql bill
+        contact_class = Contacts.new
+        project_class = Projects.new
+        <<~SQL
+          #{contact_class.sql(contacts[bill.contact])}
+          #{project_class.sql(projects[bill.project])}
+          INSERT OR REPLACE INTO bills (id, dated_on, due_on, contact_id, project_id, reference, total_value, net_value) VALUES (#{[
+            id_from_url(bill.url),
+            bill.dated_on,
+            bill.due_on,
+            id_from_url(bill.contact),
+            id_from_url(bill.project),
+            bill.reference,
+            bill.total_value.to_f,
+            bill.net_value.to_f,
+          ].map(&method(:sql_format)).join(", ")});
+        SQL
+      end
+
+      def human_item item
+        [
+          item.description,
+          item.quantity,
+          item.unit,
+          item.total_value,
+          item.total_value_ex_tax,
+        ].join("\t")
+      end
+    end
+
+    SQL_SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS bills (
+        id INTEGER PRIMARY KEY,
+        dated_on TEXT,
+        due_on TEXT,
+        contact_id INTEGER,
+        project_id INTEGER,
+        reference TEXT,
+        total_value REAL,
+        net_value REAL,
+        FOREIGN KEY (contact_id) REFERENCES contacts(id),
+        FOREIGN KEY (project_id) REFERENCES projects(id)
+      );
+    SQL
+
+    STATUSES = Invoices::STATUSES - %i[ recent_open_or_overdue scheduled_to_email thank_you_emails ] + %i[ open_or_overdue_payments open_or_overdue_refunds recurring hire_purchase cis ]
+
+    desc 'list [-C CONTACT] [-P PROJECT] [-S STATUS] [-f FROM] [-t TO]', "List bills"
+    method_option :contact, aliases: '-C', type: :string, default: nil, desc: "Limit to a contact, identified by name or email"
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: "Limit to a project, identified by name"
+    method_option :status, aliases: '-S', type: :string, default: nil, desc: "Bills that match a status, one of: #{STATUSES.join(', ')}"
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list bills from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list bills to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human, json or sql'
+    def list
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+      status = options[:status].nil? ? nil : match(:status, STATUSES, options[:status], :to_s)
+      contact = options[:contact].nil? ? nil : match(:contact, api.contacts, options[:contact], :first_name, :last_name, :organisation_name, :email, :billing_email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+
+      contacts[contact.url] = contact unless contact.nil?
+      projects[project.url] = project unless project.nil?
+
+      if options[:format].downcase == 'sql'
+        puts Contacts::SQL_SCHEMA
+        puts Projects::SQL_SCHEMA
+        puts SQL_SCHEMA
+      end
+
+      api.bills(contact: contact, project: project, view: status, nested_bill_items: true).select do |bill|
+        from.nil? || Date::parse(bill.dated_on) >= from
+      end.each do |bill|
+        puts case options[:format].downcase
+        when 'human'; human(bill)
+        when 'json'; bill.to_json
+        when 'sql'; sql(bill)
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+
+    desc 'items [-C CONTACT] [-P PROJECT] [-S STATUS] [-f FROM] [-t TO]', 'List bill items'
+    method_option :contact, aliases: '-C', type: :string, default: nil, desc: "Limit to a contact, identified by name or email"
+    method_option :project, aliases: '-P', type: :string, default: nil, desc: "Limit to a project, identified by name"
+    method_option :status, aliases: '-S', type: :string, default: nil, desc: "Bills that match a status, one of: #{STATUSES.join(', ')}"
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list bills from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list bills to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human, json or sql'
+    def items
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+      status = options[:status].nil? ? nil : match(:status, statuses, options[:status], :to_s)
+      contact = options[:contact].nil? ? nil : match(:contact, api.contacts, options[:contact], :first_name, :last_name, :organisation_name, :email, :billing_email)
+      project = options[:project].nil? ? nil : match(:project, api.projects, options[:project], :name)
+
+      contacts[contact.url] = contact unless contact.nil?
+      projects[project.url] = project unless project.nil?
+      api.bills(contact: contact, project: project, view: status, nested_bill_items: true).select do |bill|
+        from.nil? || Date::parse(bill.dated_on) >= from
+      end.flat_map(&:bill_items).each do |item|
+        puts case options[:format].downcase
+        when 'human'; human_item(item)
+        when 'json'; item.to_json
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
+      end
+    end
+  end
+
+  class Transactions < Thor
+    no_commands do
+      def api
+        @api ||= API.new
+      end
+
+      def human txn
+        [
+          Date::parse(txn.dated_on).strftime('%a %d %b %Y'),
+          txn.nominal_code,
+          txn.category_name,
+          txn.description,
+          txn.debit_value,
+        ].join("\t")
+      end
+
+      def sql txn
+        <<~SQL
+        INSERT OR REPLACE INTO transactions (id, dated_on, nominal_code, category_name, description, debit_value) VALUES (#{[
+          id_from_url(txn.url),
+          txn.dated_on,
+          txn.nominal_code,
+          txn.category_name,
+          txn.description,
+          txn.debit_value.to_f,
+        ].map(&method(:sql_format)).join(",")});
+        SQL
+      end
+    end
+
+    SQL_SCHEMA = <<~SQL
+      CREATE TABLE IF NOT EXISTS transactions (
+        id INTEGER PRIMARY KEY,
+        dated_on TEXT,
+        nominal_code TEXT,
+        category_name TEXT,
+        description TEXT,
+        debit_value REAL
+      );
+    SQL
+
+    desc 'list [-C CATEGORY] [-f FROM] [-t TO]', 'List transactions'
+    method_option :category, aliases: '-C', type: :string, default: nil, desc: 'Limit to a category, identified by name or code'
+    method_option :from, aliases: '-f', type: :string, default: nil, desc: 'Date to list transactions from'
+    method_option :to, aliases: '-t', type: :string, default: nil, desc: 'Date to list transactions to'
+    method_option :format, type: :string, default: 'human', desc: 'Output format, one of human, json or sql'
+    def list
+      category = options[:category].nil? ? nil : match(:category, api.categories, options[:category], :description, :nominal_code).nominal_code
+      from = options[:from].nil? ? nil : Date::parse(options[:from])
+      to = options[:to].nil? ? nil : Date::parse(options[:to])
+
+      puts SQL_SCHEMA if options[:format].downcase == 'sql'
+
+      api.transactions(category_code: category, from: from, to: to).each do |txn|
+        puts case options[:format].downcase
+        when 'human'; human(txn)
+        when 'json'; txn.to_json
+        when 'sql'; sql(txn)
+        else raise ArgumentError, "unknown output format #{options[:format]}"
+        end
       end
     end
   end
@@ -104,6 +701,21 @@ module Freeagent
   class Command < Thor
     desc "timeslips", "Create, read, update and delete timeslips"
     subcommand "timeslips", Timeslips
+
+    desc "projects", "Create, read, update and delete projects"
+    subcommand "projects", Projects
+
+    desc "tasks", "Create, read, update and delete tasks"
+    subcommand "tasks", Tasks
+
+    desc "invoices", "Read invoices"
+    subcommand "invoices", Invoices
+
+    desc "bills", "Read bills"
+    subcommand "bills", Bills
+
+    desc "transactions", "Read transactions"
+    subcommand "transactions", Transactions
   end
 end
 

data/lib/freeagent.rb

@@ -63,7 +63,7 @@ module Freeagent
     def get *parts, **params
       relatives = parts.map(&:to_s).join('/')
       uri = URI.parse(relatives)
-      puts "GET #{uri}"
+      STDERR.puts "GET #{uri}#{params.any? ? '?' + URI.encode_www_form(params) : ''}"
       res = @token.get(uri, params: params, headers: {'Accept': 'application/json'})
       data = res.parsed
       if res.headers.include? 'Link'
@@ -79,6 +79,8 @@ module Freeagent
         STDERR.puts "Rate limited; sleeping for #{retry_after}"
         sleep retry_after
         retry
+      else
+        raise err
       end
     end
 
@@ -97,15 +99,22 @@ module Freeagent
       data = parts.pop
       relatives = parts.map(&:to_s).join('/')
       uri = URI.parse(relatives)
-      puts "POST #{uri}"
+      STDERR.puts "POST #{uri}"
       body = data.to_json
       @token.post(uri, body: body, params: params, headers: {'Content-Type': 'application/json', 'Accept': 'application/json'}).parsed
     end
 
+    def put *parts, **params
+      relatives = parts.map(&:to_s).join('/')
+      uri = URI.parse(relatives)
+      STDERR.puts "PUT #{uri}"
+      @token.put(uri, params: params, headers: {'Accept': 'application/json'})
+    end
+
     def delete *parts, **params
       relatives = parts.map(&:to_s).join('/')
       uri = URI.parse(relatives)
-      puts "DELETE #{uri}"
+      STDERR.puts "DELETE #{uri}"
       @token.delete(uri, params: params, headers: {'Accept': 'application/json'})
     end
 
@@ -126,12 +135,39 @@ module Freeagent
       get('payroll_profiles', year).profiles
     end
 
-    def projects
-      get_pages('projects').flat_map(&:projects)
+    def project id
+      get('projects', id).project
+    end
+
+    def projects contact: nil
+      params = [
+        [:contact, contact && contact.url]
+      ].reject {|(k ,v)| v.nil?}.to_h
+      get_pages('projects', **params).flat_map(&:projects)
+    end
+
+    def task id
+      get('tasks', id).task
+    end
+
+    def tasks project: nil, view: nil, updated_since: nil
+      params = [
+        [:project, project&.to_s],
+        [:view, view&.to_s],
+        [:updated_since, updated_since&.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('tasks', **params).flat_map(&:tasks)
+    end
+
+    def update_task status: nil
+      attribs = [
+        [:status, status&.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      put(task.url, task: attribs)
     end
 
-    def tasks project
-      get_pages('tasks', project: project.url).flat_map(&:tasks)
+    def delete_task task
+      delete(task.url, {})
     end
 
     def timeslips user: nil, project: nil, task: nil, from: nil, to: nil
@@ -156,7 +192,7 @@ module Freeagent
     end
 
     def batch_create_timeslips timeslips
-      post('timeslips', {'timeslips' => timeslips})
+      post('timeslips', {'timeslips' => timeslips.to_a})
     end
 
     def delete_timeslip timeslip
@@ -164,6 +200,39 @@ module Freeagent
       delete('timeslips', id)
     end
 
+    def invoices contact: nil, project: nil, view: nil, updated_since: nil, nested_invoice_items: false, sort: nil
+      params = [
+        [:contact, contact && contact.url],
+        [:project, project && project.url],
+        [:view, view && view.to_s],
+        [:updated_since, updated_since && updated_since.to_s],
+        [:nested_invoice_items, nested_invoice_items && nested_invoice_items.to_s],
+        [:sort, sort && sort.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('invoices', **params).flat_map(&:invoices)
+    end
+
+    def invoice id
+      get('invoices', id).invoice
+    end
+
+    def bills contact: nil, project: nil, nested_bill_items: false, view: nil, from: nil, to: nil, updated_since: nil
+      params = [
+        [:contact, contact && contact.url],
+        [:project, project && project.url],
+        [:view, view && view.to_s],
+        [:from_date, from && from.to_s],
+        [:to_date, to && to.to_s],
+        [:updated_since, updated_since && updated_since.to_s],
+        [:nested_bill_items, nested_bill_items && nested_bill_items.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('bills', **params).flat_map(&:bills)
+    end
+
+    def bill id
+      get('bills', id).bill
+    end
+
     def users
       get_pages('users').flat_map(&:users)
     end
@@ -172,8 +241,49 @@ module Freeagent
       get('users', id).user
     end
 
+    def contacts view: nil, updated_since: nil, sort: nil
+      params = [
+        [:view, view && view.to_s],
+        [:updated_since, updated_since && updated_since.to_s],
+        [:sort, sort && sort.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('contacts', **params).flat_map(&:contacts)
+    end
+
+    def contact id
+      get('contacts', id).contact
+    end
+
     def profile year, user
       get('payroll_profiles', year, user: user)
     end
+
+    def notes contact: nil, project: nil
+      params = [
+        [:contact, contact && contact.to_s],
+        [:project, project && project.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('notes', **params).flat_map(&:notes)
+    end
+
+    def transactions category_code: nil, from: nil, to: nil
+      params = [
+        [:from_date, from && from.to_s],
+        [:to_date, to && to.to_s],
+        [:nominal_code, category_code && category_code.to_s],
+      ].reject {|k, v| v.nil? }.to_h
+      get_pages('accounting', 'transactions', **params).flat_map(&:transactions)
+    end
+
+    def categories
+      get_pages('categories', sub_accounts: true).flat_map do |response|
+        [
+          *(response.admin_expense_categories || []),
+          *(response.cost_of_sales_categories || []),
+          *(response.income_categories || []),
+          *(response.general_categories || []),
+        ]
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freeagent-cli
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - Simon Worthington
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-02 00:00:00.000000000 Z
+date: 2026-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2
@@ -66,6 +66,20 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: snaky_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement