TokiCLI 0.2.1 → 0.3.0

data/lib/API/toki_db.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module TokiCLI
+
+  class TokiDB
+
+    def initialize(db_path)
+      @db = Amalgalite::Database.new(db_path)
+      @table = 'KKAppActivity'
+    end
+
+    def apps_total
+      @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} GROUP BY bundleIdentifier")
+    end
+
+    def apps_range(starting, ending)
+      @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom >= #{starting} AND activeFrom < #{ending} GROUP BY bundleIdentifier")
+    end
+
+    def apps_since(day)
+      @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom >= #{day} GROUP BY bundleIdentifier")
+    end
+
+    def apps_before(day)
+      @db.execute("SELECT bundleIdentifier,sum(totalSeconds) FROM #{@table} WHERE activeFrom < #{day} GROUP BY bundleIdentifier")
+    end
+
+    # Get the log for an app given its exact bundle identifier
+    def bundle_log(bundle_id)
+       @db.execute("SELECT * FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}'")
+    end
+    def bundle_log_since(bundle_id, starting)
+       @db.execute("SELECT * FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{starting}")
+    end
+    def bundle_log_before(bundle_id, date)
+       @db.execute("SELECT * FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom < #{date}")
+    end
+    def bundle_log_range(bundle_id, starting, ending)
+       @db.execute("SELECT * FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{starting} AND activeFrom < #{ending}")
+    end
+
+    # Get the total time for an app given its exact bundle identifier, since a specific day
+    def bundle_total_since(bundle_id, starting)
+      @db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom >= #{starting}")
+    end
+
+    # Get the total time for an app given its exact bundle identifier, before a specific day
+    def bundle_total_before(bundle_id, ending)
+      @db.execute("SELECT sum(totalSeconds) FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}' AND activeFrom < #{ending}")
+    end
+
+    def log_since(day)
+      @db.execute("SELECT * FROM #{@table} WHERE activeFrom >= #{day}")
+    end
+    def log_range(starting, ending)
+      @db.execute("SELECT * FROM #{@table} WHERE activeFrom >= #{starting} AND activeFrom < #{ending}")
+    end
+
+    # ---
+
+    def delete_bundle(bundle_id)
+      @db.execute("DELETE FROM #{@table} WHERE bundleIdentifier IS '#{bundle_id}'")
+    end
+
+  end
+
+end

data/lib/TokiCLI.rb

@@ -1,7 +1,272 @@
 # encoding: utf-8
-require 'ostruct'
 require 'thor'
-require 'amalgalite'
-require 'terminal-table/import'
-require_relative "TokiCLI/version"
-require_relative "TokiCLI/app"
+
+module TokiCLI
+  class App < Thor
+
+    package_name "TokiCLI"
+
+    require_relative 'API/toki_api'
+    %w{version status fileops view adnimport}.each {|r| require_relative "TokiCLI/#{r}"}
+
+    desc "version", "TokiCLI version number"
+    map "-v" => :version
+    def version
+      View.new.version
+    end
+
+    desc "scan", "Scan applications folders for full names"
+    def scan
+      puts Status.scanning
+      fileops = FileOps.new
+      fileops.save_bundles
+      puts Status.file_saved(fileops.bundles_file)
+      puts Status.next_launch_with_names
+    end
+
+    desc "total", "Show total for all apps"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def total
+      # Initializes files and instances
+      ## Replace with init(true) to backup the db before using it
+      ## Not necessary for read-only commands like this one
+      init()
+      # Gets the JSON response from TokiAPI
+      ## Here the response is stocked locally in 'apps' but using a variable is optional:
+      ## the response is memoized in @toki.response when a @toki method is called
+      ## (see other commands)
+      apps = @toki.apps_total()
+      # Export or display
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        # Title is optional: @view.apps_total(apps)
+        title = "Toki - Total usage of all apps"
+        @view.apps_total(apps, title)
+      end
+    end
+
+    desc "top", "Show total for most used apps"
+    option :number, aliases: '-n', type: :numeric, desc: 'Specify the number of apps'
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def top
+      init()
+      max = options[:number] || 5
+      @toki.apps_top(max)
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        @view.apps(@toki.response, "Toki - Total usage of most used apps")
+      end
+    end
+
+    desc "day DATE", "Show total for apps used on a specific day"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def day(*args)
+      init()
+      @toki.apps_day(args[0])
+      exit_with_msg_if_invalid_response()
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        @view.apps(@toki.response, "Toki - All apps used on #{args[0]}")
+      end
+    end
+
+    desc "range DATE1 DATE2", "Show total for all apps used between two specific days"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def range(*args)
+      init()
+      @toki.apps_range(args[0], args[1])
+      exit_with_msg_if_invalid_response()
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        @view.apps(@toki.response, "Toki - All apps used between #{args[0]} and #{args[1]}")
+      end
+    end
+
+    desc "since DATE", "Show total for all apps used since a specific day"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def since(*args)
+      init()
+      @toki.apps_since(args[0])
+      exit_with_msg_if_invalid_response()
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        @view.apps(@toki.response, "Toki - All apps used since #{args[0]}")
+      end
+    end
+
+    desc "before DATE", "Show total for all apps used before a specific day"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results in a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results in a CSV file'
+    def before(*args)
+      init()
+      @toki.apps_before(args[0])
+      exit_with_msg_if_invalid_response()
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      else
+        @view.apps(@toki.response, "Toki - All apps used before #{args[0]}")
+      end
+    end
+
+    desc "activity", "Shows recent log updates"
+    option :since, type: :string, desc: 'Request log starting on this date'
+    option :day, type: :string, desc: 'Request log for a specific day'
+    def activity
+      init()
+      if options.since?
+        @toki.log_since(options.since)
+      elsif options.day?
+        @toki.log_day(options.day)
+      else
+        @toki.log_since()
+      end
+      @view.log_activity(@toki.response)
+    end
+
+    desc "bundle BUNDLE_ID", "Show complete log for an app from its exact bundle id"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results as a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results as a CSV file'
+    option :before, type: :string, desc: 'Request log before this date'
+    option :since, type: :string, desc: 'Request log starting on this date'
+    option :day, type: :string, desc: 'Request log for a specific day'
+    option :range, type: :array, desc: 'Request log between two specific days'
+    def bundle(bundle_id)
+      init()
+      title = bundle_title(bundle_id, options)
+      bundle_log(bundle_id, options)
+      exit_with_msg_if_invalid_response(Status.no_data)
+      if options[:json] || options[:csv]
+        export(@toki, options)
+      elsif options[:since] || options[:before] || options[:day] || options[:range]
+        @view.log(@toki.response, title)
+      else
+        @view.log_total(@toki.response, title)
+      end
+    end
+
+    desc "app APP_NAME", "Show complete log for an app from (part of) its name"
+    option :json, aliases: '-J', type: :boolean, desc: 'Export the results as a JSON file'
+    option :csv, aliases: '-C', type: :boolean, desc: 'Export the results as a CSV file'
+    option :before, type: :string, desc: 'Request log before this date'
+    option :since, type: :string, desc: 'Request log starting on this date'
+    option :day, type: :string, desc: 'Request log for a specific day'
+    option :range, type: :array, desc: 'Request log between two specific days'
+    def app(*app_name)
+      init()
+      abort(Status.please_scan) if @toki.bundles.nil?
+      candidates = @fileops.get_bundle_from_name(app_name)
+      candidates.each.with_index(1) do |bundle_id, index|
+        say "\nApp N°#{'%.2d' % index}: #{bundle_id}" if candidates.length > 1
+        bundle_log(bundle_id, options)
+        if JSON.parse(@toki.response)['meta']['code'] != 200
+          say Status.no_data
+        else
+          if options[:json] || options[:csv]
+            export(@toki, options, bundle_id)
+          elsif options[:since] || options[:before] || options[:day] || options[:range]
+            @view.log(@toki.response, bundle_title(bundle_id, options))
+          else
+            @view.log_total(@toki.response, bundle_title(bundle_id, options))
+          end
+        end
+      end
+    end
+
+    desc "restore", "Restore your database from the App.net backup"
+    def restore
+      init(true)
+      adn = ADNImport.new(@fileops.data_path)
+      adn.restore
+    end
+
+    desc "serve", "Start a local Toki API server"
+    map "server" => :serve
+    def serve
+      require_relative '../lib/TokiServer/tokiserver'
+      puts "\n\n"
+      say_status :starting, "Toki API server"
+      say "\n\nPress [CTRL-C] to stop.\n\nThe index page URL is: http://localhost:4567\n\n"
+      TokiServer.run!
+      puts "\n\n"
+      say_status :halt, "Toki API server"
+    end
+
+    # ---
+
+    desc "delete BUNDLE_ID", "Permanently delete this application from the database"
+    option :'no-backup', aliases: '-X',type: :boolean, desc: 'Do not backup the database before processing'
+    def delete(bundle_id)
+      options['no-backup'] ? init() : init(true)
+      name = @toki.bundles[bundle_id]
+      confirm_delete(bundle_id, name)
+      say "\nDeleting entries..."
+      @toki.delete_bundle(bundle_id)
+      exit_with_msg_if_invalid_response(Status.wtf)
+      say "\nDone.\n"
+    end
+
+    private
+
+    def confirm_delete(bundle_id, name)
+      name.nil? ? insert = '' : insert = " (#{name})"
+      xx = yes?("\nAre you sure you want to remove all '#{bundle_id}'#{insert} entries from the database ?\n\n>> ")
+      abort("\nCanceled.\n\n") if xx == false
+    end
+
+    def bundle_log(bundle_id, options)
+      if options[:since]
+        @toki.bundle_log_since(bundle_id, options[:since])
+      elsif options[:before]
+        @toki.bundle_log_before(bundle_id, options[:before])
+      elsif options[:day]
+        @toki.bundle_log_day(bundle_id, options[:day])
+      elsif options[:range]
+        @toki.bundle_log_range(bundle_id, options[:range][0], options[:range][1])
+      else
+        @toki.bundle_log(bundle_id)
+      end
+    end
+
+    def bundle_title(bundle_id, options = {})
+      prefix = "Toki - Complete log for #{bundle_id}"
+      if options[:since]
+        "#{prefix} since #{options[:since]}"
+      elsif options[:before]
+        "#{prefix} before #{options[:before]}"
+      elsif options[:day]
+        "#{prefix} - #{options[:day]}"
+      elsif options[:range]
+        "#{prefix} - #{options[:range][0]}/#{options[:range][1]}"
+      else
+        prefix
+      end
+    end
+
+    def exit_with_msg_if_invalid_response(msg = Status.wtf)
+      abort(msg) if JSON.parse(@toki.response)['meta']['code'] != 200
+    end
+
+    def export(toki, options, title = nil)
+      @fileops.export(toki, options, title)
+    end
+
+    # Replaces usual initialize method
+    def init(backup = false)
+      @fileops = FileOps.new
+      @fileops.backup_db if backup == true
+      @toki = TokiAPI.new(@fileops.db_file, @fileops.bundles) # @fileops.bundles is optional
+      @view = View.new(@fileops.config) # @fileops.config is optional
+    end
+
+  end
+end

data/lib/TokiCLI/adnimport.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+module TokiCLI
+
+  class ADNImport
+
+    require 'rest-client'
+
+    CLIENT_ID = 'm6AccJFM56ENCn58Vde9cSg3uSpbvAAs'
+    CALLBACK_URL = 'http://aya.io/toki_cli/auth.html'
+
+    attr_reader :token, :config
+
+    def initialize(data_path)
+      @toki_db_file = "#{Dir.home}/Library/Containers/us.kkob.Toki/Data/Documents/toki_data.sqlite3"
+      @data_path = data_path
+      @user_file = "#{data_path}/user.json"
+      @shell = Thor::Shell::Basic.new
+      @auth_url = "https://account.app.net/oauth/authenticate?client_id=#{CLIENT_ID}&response_type=token&redirect_uri=#{CALLBACK_URL}&scope=basic,messages&include_marker=1"
+    end
+
+    def restore
+      please_quit()
+      if File.exist? @user_file
+        @shell.say_status :loading, "user infos"
+        @config = JSON.parse(File.read(@user_file))
+        @token = @config['token']
+      else
+        ask_token()
+        get_user_data()
+        @shell.say_status :analysing, "App.net channels"
+        channel = get_channel_id()
+        @shell.say_status :writing, "user file"
+        File.write(@user_file, @config.merge({'channel' => channel}).to_json)
+      end
+      adn_data = get_messages(@config['channel'])
+      @shell.say_status :writing, "App.net data file"
+      File.write("#{@data_path}/adn_backup.json", adn_data.to_json)
+      @shell.say_status :decoding, "App.net data file"
+      lines = decode(adn_data)
+      @shell.say_status :creating, "new database file"
+      db = create_db()
+      @shell.say_status :creating, "database table"
+      create_table(db)
+      @shell.say_status :populating, "database"
+      populate(db, lines)
+      @shell.say_status :replacing, "database file"
+      replace()
+      @shell.say_status :done, "Restore database from the App.net backup"
+      puts "\n\nDone. You may relaunch Toki.app now.\n\n"
+    end
+
+    private
+
+    def please_quit
+      resp = @shell.yes? "\nYou need to quit Toki.app before restoring data from App.net.\n\nPlease quit Toki.app then type 'Y' to continue.\n\n>> "
+      puts "\n"
+      abort("\nCanceled.\n\n") if resp == false
+    end
+
+    def ask_token
+      @shell.say "\nPlease click this URL, or copy/paste it in a browser:\n"
+      puts "\n#{@auth_url}\n\n"
+      @shell.say "then log in with your ADN credentials to authorize TokiCLI.\n\n"
+      @shell.say "You will then be redirected to a page showing a 'user token'.\n\n"
+      @token = @shell.ask "Copy the token then paste it here:\n\n>>"
+      puts "\n"
+    end
+
+    def get_user_data
+      @shell.say_status :connecting, "App.net"
+      @shell.say_status :downloading, "User infos"
+      resp = get_user()
+      @config = {
+        'username' => resp['data']['username'],
+        'name' => resp['data']['name'],
+        'id' => resp['data']['id'],
+        'handle' => "@#{resp['data']['username']}",
+        'token' => @token
+      }
+    end
+
+    def get_user
+      JSON.parse(RestClient.get("https://api.app.net/users/me?access_token=#{@token}", :verify_ssl => OpenSSL::SSL::VERIFY_NONE) {|response, request, result| response })
+    end
+
+    def get_channel_id
+      get_channels().each do |ch|
+        return ch['id'].to_i if ch['type'] == 'us.kkob.toki.sync-b'
+      end
+    end
+
+    def get_channels
+      args = {:count => 200, :before_id => nil}
+      channels = []
+      loop do
+        url = "http://api.app.net/users/me/channels?access_token=#{@token}&include_machine=1&include_message_annotations=1&include_deleted=0&include_html=0&count=#{args[:count]}&before_id=#{args[:before_id]}"
+        resp = JSON.parse(RestClient.get(url))
+        resp['data'].each { |m| channels << m }
+        break unless resp['meta']['more']
+        args = {:count => 200, :before_id => resp['meta']['min_id']}
+      end
+      channels
+    end
+
+    def get_messages(channel_id)
+      @shell.say_status :connecting, "App.net"
+      @shell.say_status :downloading, "Toki infos"
+      args = {:count => 200, :before_id => nil}
+      @messages = []
+      @index = 1
+      @shell.say_status :downloading, "Toki sync objects"
+      loop do
+        begin
+          @shell.say_status :downloading, "page #{'%.2d' % @index}"
+          url = "http://api.app.net/channels/#{channel_id}/messages?access_token=#{@token}&include_machine=1&include_message_annotations=1&include_user_annotations=0&include_deleted=0&include_html=0&count=#{args[:count]}&before_id=#{args[:before_id]}"
+          data = RestClient.get(url)
+          resp = JSON.parse(data)
+          dates = []
+          resp['data'].each do |m|
+            dates << m['created_at'][0..9]
+            @messages << m
+          end
+          @shell.say_status :downloaded, "#{dates.uniq.join(', ')}"
+          break unless resp['meta']['more']
+          @index += 1
+          args = {:count => 200, :before_id => resp['meta']['min_id']}
+        rescue Interrupt
+          abort(Status.canceled)
+        end
+      end
+      @messages
+    end
+
+    def decode(adn_data)
+      adn_data.map do |obj|
+        {
+          'type' => obj['annotations'][0]['type'],
+          'table' => obj['annotations'][0]['value']['c'],
+          'uuid' => obj['annotations'][0]['value']['d']['UUID'],
+          'bundleIdentifier' => obj['annotations'][0]['value']['d']['bundleIdentifier'],
+          'activeTo' => obj['annotations'][0]['value']['d']['activeTo'],
+          'activeFrom' => obj['annotations'][0]['value']['d']['activeFrom'],
+          'totalSeconds' => obj['annotations'][0]['value']['d']['totalSeconds'],
+          'id' => obj['annotations'][0]['value']['d']['id']
+        }
+      end
+    end
+
+    def create_db
+      file = "#{@data_path}/db_from_adn.sqlite3"
+      File.rm(file) if File.exist?(file)
+      Amalgalite::Database.new(file)
+    end
+
+    def create_table db
+      db.execute_batch <<-SQL
+        CREATE TABLE KKAppActivity (
+          id INTEGER,
+          bundleIdentifier VARCHAR(256),
+          activeTo INTEGER,
+          activeFrom INTEGER,
+          totalSeconds INTEGER,
+          UUID VARCHAR(256),
+          synced INTEGER,
+          availableToSync INTEGER
+        );
+      SQL
+      db.reload_schema!
+    end
+
+    def populate(db, lines)
+      before = Time.now
+      @shell.say_status :processing, "#{lines.size} rows"
+      db.transaction do |db_in_transaction|
+        lines.each do |obj|
+          insert_data = {}
+          insert_data[':id'] = obj['id']
+          insert_data[':bundleIdentifier'] = obj['bundleIdentifier']
+          insert_data[':activeTo'] = obj['activeTo']
+          insert_data[':activeFrom'] = obj['activeFrom']
+          insert_data[':totalSeconds'] = obj['totalSeconds']
+          insert_data[':UUID'] = obj['uuid']
+          insert_data[':synced'] = 1
+          insert_data[':availableToSync'] = 1
+
+          db_in_transaction.prepare("INSERT INTO KKAppActivity(id, bundleIdentifier, activeTo, activeFrom, totalSeconds, UUID, synced, availableToSync) VALUES(:id, :bundleIdentifier, :activeTo, :activeFrom, :totalSeconds, :UUID, :synced, :availableToSync);") do |insert|
+            insert.execute(insert_data)
+          end
+
+        end
+      end
+      @shell.say_status :finished, "insertion of #{idx} rows in #{Time.now - before} seconds"
+    end
+
+    def replace
+      FileUtils.mv @toki_db_file, "#{Dir.home}/.Trash/"
+      FileUtils.mv "#{@data_path}/db_from_adn.sqlite3", @toki_db_file
+    end
+
+  end
+
+end