TokiCLI 0.0.9 → 0.1.1

data/lib/API/helpers.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+module TokiCLI
+  class Helpers
+
+    attr_accessor :table, :bundles, :bundles_file, :home_path, :toki_path, :db_path
+    attr_reader :db
+
+    def initialize
+      @home_path = Dir.home
+      @toki_path = "#{@home_path}/.TokiCLI"
+      FileUtils.mkdir_p(@toki_path) unless Dir.exist?(@toki_path)
+      @db_path = "#{@home_path}/Library/Containers/us.kkob.Toki/Data/Documents/toki_data.sqlite3"
+      if File.exist? @db_path
+        FileUtils.copy @db_path, "#{@toki_path}/toki_data.sqlite3.bak"
+        @db = Amalgalite::Database.new @db_path
+      else
+        raise 'No DB'
+      end
+      @table = 'KKAppActivity'
+      @bundles_file = "#{@toki_path}/apps.json"
+      @bundles = if File.exist? @bundles_file
+        JSON.parse(File.read @bundles_file)
+      else
+        {}
+      end
+    end
+
+
+    # Returns the app name if exists
+    def find_app_name bundle_id
+      if @bundles[bundle_id]
+        @bundles[bundle_id]
+      else
+        nil
+      end
+    end
+
+    def humanized_date epoch
+      human = seconds_to_time epoch
+      "#{human[:hours]}h #{human[:minutes]}m #{human[:seconds]}s"
+    end
+
+    def seconds_to_time epoch
+      begin
+        hours = epoch / 3600
+        minutes = (epoch / 60 - hours * 60)
+        seconds = (epoch - (minutes * 60 + hours * 3600))
+        {hours: hours, minutes: minutes, seconds: seconds}
+      rescue Exception => e
+        oops e
+      end
+    end
+
+    def oops error
+      puts "\nOOPS! A gremlin crashed the app.\n\n"
+      puts "STACK: #{caller}\n\n"
+      abort "GREMLIN: #{error}\n\n"
+    end
+
+    def epoch_to_date epoch
+      Time.at(epoch).to_time
+    end
+
+    def sec_to_time sec
+      seconds_to_time sec
+    end
+
+    # Scans for names from bundle ids, saves the file and returns its content
+    def scan params = {}
+      bundle_ids = get_bundle_ids params
+      f = File.new "#{@toki_path}/apps.json", "w"
+      f.write bundle_ids.to_json
+      f.close
+      bundle_ids
+    end
+
+    # Scan for names from bundle ids
+    def get_bundle_ids params = {}
+      @infos = {}
+      get_bundles(get_plists("/Applications/*/Contents/*"), params)
+      get_bundles(get_plists("/Applications/Utilities/*/Contents/*"), params)
+      get_bundles(get_plists("#{@home_path}/Applications/*/Contents/*"), params)
+      @infos
+    end
+
+    def get_bundle_from_name name
+      (@bundles).each do |k,v|
+        if v.downcase =~ /#{name.downcase}/
+          return [v, k]
+        end
+      end
+      []
+    end
+
+    def meta_nodata
+      {
+        code: 404,
+        error: { message: 'No data returned from the database' }
+      }
+    end
+
+    def json_nodata
+      {
+        meta: meta_nodata,
+        data: {}
+      }.to_json
+    end
+
+    def tracked_bundles apps
+      tracked = JSON.parse(apps)
+      list = []
+      tracked['data']['apps'].each {|v| list << v['bundle']}
+      list
+    end
+
+    private
+
+    def get_plists path
+      Dir.glob(path).select {|f| (File.split f).last == 'Info.plist'}
+    end
+
+    def get_bundles plists, params
+      plists.each do |obj|
+        puts "Analyzing #{obj} ...\n" if params[:verbose] == true
+        begin
+          pl = CFPropertyList::List.new(:file => obj)
+        rescue CFFormatError
+          bundles_error if params[:verbose] == true
+          next
+        rescue NoMethodError
+          bundles_error if params[:verbose] == true
+          next
+        end
+        data = CFPropertyList.native_types(pl.value)
+        name = data['CFBundleName']
+        bundle_id = data['CFBundleIdentifier']
+        if name.nil?
+          name = data['CFBundleExecutable']
+        end
+        next if name.nil?
+        next if bundle_id.nil? || bundle_id.empty?
+        @infos[bundle_id] = name
+      end
+    end
+
+    def bundles_error
+      puts "Unable to read the file, skipping...\n"
+    end
+
+  end
+end

data/lib/TokiCLI/app.rb

@@ -2,161 +2,288 @@
 module TokiCLI
   class App < Thor
     package_name "TokiCLI"
-    %w{get_messages search_messages get_channels module status view authorize}.each {|r| require_relative "#{r}"}
+    %w{get_messages search_messages get_channels status view authorize export import scan ../API/dbapi}.each {|r| require_relative "#{r}"}
+
+    desc "auth", "App.net login"
+    def auth
+      begin
+        toki = DBAPI.new
+        adn = Authorize.new(toki.helpers.toki_path)
+        adn.authorize
+      rescue Interrupt
+        puts Status.canceled
+        exit
+      end
+    end
 
     desc "scan", "Scan /Applications to resolve app names"
     def scan
-      toki = create_toki(options)
-      bundle_ids = toki.get_bundle_ids
-      path = "#{Dir.home}/.TokiCLI"
-      Dir.mkdir path unless Dir.exist? path
-      f = File.new "#{path}/apps.json", "w"
-      f.write bundle_ids.to_json
-      f.close
-      puts "\nDone.\n\n"
-    end
-
-    desc "total", "Shows the total usage of all apps"
-    option :adn, aliases: '-a', type: :boolean, desc: 'Select ADN channel as source (toki total -a)'
+      scanner = Scan.new DBAPI.new
+      scanner.scan({verbose: true})
+    end
+
+    desc "total", "Total usage of all apps"
     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'
     def total
-      toki = create_toki(options)
-      apps = get_total(toki, options)
-      clear
-      View.new.total_table(apps)
-      export(options, apps, "toki-total-#{Time.now.to_s[0..9]}") if (options[:json] || options[:csv])
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_total
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, 'total'
+      end
     end
 
-    desc "top", "Shows your most used apps"
-    option :adn, aliases: '-a', type: :boolean, desc: 'Select ADN channel as source (toki top -a)'
-    option :number, aliases: '-n', type: :numeric, desc: 'Specify the number of apps (toki top -n 10)'
+    desc "top", "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 as a JSON file'
     option :csv, aliases: '-c', type: :boolean, desc: 'Export the results as a CSV file'
     def top
-      toki, entries = init(options)
-      clear
-      hits = toki.top(entries, options[:number] || 5)
-      View.new.hits_table(hits.reverse)
-      export(options, hits, "toki-top-#{Time.now.to_s[0..9]}") if (options[:json] || options[:csv])
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_top(options[:number] || 5)
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, 'top'
+      end
     end
 
-    desc "auth", "Input your App.net token for authorization"
-    def auth
+    desc "day DATE", "All apps used on a specific day"
+    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'
+    def day(*args)
+      abort(Status.specify_day) if args.empty?
       begin
-        ADNAuthorize::Authorize.new.authorize
-      rescue Interrupt
-        puts Status.canceled
-        exit
+        DateTime.strptime(args[0], '%Y-%m-%d')
+      rescue ArgumentError
+        abort(Status.specify_day)
+      end
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_day args[0]
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, "day-#{args[0]}"
       end
     end
 
-    desc "log APP", "Shows the complete log for an app"
-    option :adn, aliases: '-a', type: :boolean, desc: 'Select ADN channel as source (toki log -a)'
+    desc "since DATE", "All apps used since a specific day"
     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'
-    def log(*args)
-      abort(Status.specify_name) if args.empty?
-      asked = args[0]
-      toki, entries = init(options)
-      app_data = toki.get_app(asked, entries)
-      View.new.app_table(asked, app_data)
-      export(options, app_data, "toki-log-#{asked}-#{Time.now.to_s[0..9]}") if (options[:json] || options[:csv])
+    def since *args
+      abort(Status.specify_day) if args.empty?
+      begin
+        DateTime.strptime args[0], '%Y-%m-%d'
+      rescue ArgumentError
+        abort Status.specify_day
+      end
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_since args[0]
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, "since-#{args[0]}"
+      end
     end
 
-    desc "day DATE", "Shows all apps used on a specific day (toki day 2014-04-19)"
-    option :adn, aliases: '-a', type: :boolean, desc: 'Select ADN channel as source (toki day 2014-04-19 -a)'
+    desc "before DATE", "All apps used before a specific day"
     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'
-    def day(*args)
+    def before *args
       abort(Status.specify_day) if args.empty?
       begin
-        date = DateTime.strptime(args[0], '%Y-%m-%d')
+        DateTime.strptime args[0], '%Y-%m-%d'
       rescue ArgumentError
-        abort(Status.specify_day)
+        abort Status.specify_day
+      end
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_before args[0]
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, "before-#{args[0]}"
       end
-      toki, entries = init(options)
-      day_data = toki.get_day(date, entries, options)
-      clear
-      View.new.day_table(args[0], day_data)
-      export(options, day_data, "toki-day-#{args[0]}") if (options[:json] || options[:csv])
     end
 
-    desc "range DAY1 DAY2", "Shows all apps used between day 1 and day 2 (toki range 2014-04-16 2014-04-18)"
-    option :adn, aliases: '-a', type: :boolean, desc: 'Select ADN channel as source (toki range 2014-04-16 2014-04-18 -a)'
+    desc "range DATE1 DATE2", "All apps used between two specific days"
     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'
     def range(*args)
       abort(Status.specify_range) if args.empty? || args.length != 2
       begin
-        day1 = DateTime.strptime(args[0], '%Y-%m-%d')
-        day2 = DateTime.strptime(args[1], '%Y-%m-%d')
+        DateTime.strptime(args[0], '%Y-%m-%d')
+        DateTime.strptime(args[1], '%Y-%m-%d')
       rescue ArgumentError
         abort(Status.specify_range)
       end
-      toki, entries = init(options)
-      range_data = toki.get_range(day1, day2, entries, options)
-      clear
-      View.new.range_table(args[0], args[1], range_data)
-      export(options, range_data, "toki-range-#{args[0]}_#{args[1]}") if (options[:json] || options[:csv])
+      toki, view = DBAPI.new, View.new
+      apps = JSON.parse toki.apps_range args[0], args[1]
+      view.total_table apps
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.apps_total options, apps, "range-#{args[0]}_#{args[1]}"
+      end
     end
 
-    private
-
-    def export(options, data, filename)
-      case
-      when options[:json]
-        name = Dir.home + "/temp/toki/#{filename}.json"
-        File.write(name, data.to_h.to_json)
-      when options[:csv]
-        name = Dir.home + "/temp/toki/#{filename}.csv"
-        CSV.open(name, "wb") do |csv|
-          data.to_a.each {|line| csv << line}
-        end
+    desc "log APP", "Complete log for an app"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def log(*args)
+      abort(Status.specify_name) if args.empty?
+      asked = args[0]
+      toki = DBAPI.new
+      view = View.new
+      log = if options[:bundle]
+        JSON.parse toki.bundle_log asked
       else
-        exit
+        JSON.parse toki.name_log asked
+      end
+      view.app_table asked, log
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.log options, log, "log-#{log['data']['bundle'].gsub('.', '_')}"
       end
-      puts "File converted and exported to #{name}\n\n"
     end
 
-    def init(options)
-      toki = create_toki(options)
-      return toki, toki.get_content(options)
+    desc "app APP", "Total tracked time for an app"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def app *args
+      abort(Status.specify_name) if args.empty?
+      asked = args[0]
+      toki = DBAPI.new
+      view = View.new
+      app = if options[:bundle]
+        JSON.parse toki.bundle_total asked
+      else
+        JSON.parse toki.name_total asked
+      end
+      view.total_table app
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.app_total options, app, "app-#{app['data']['bundle'].gsub('.', '_')}"
+      end
     end
 
-    def create_toki(options)
-      options[:adn] ? total_adn : total_db
+    desc "app_before APP DATE", "Total tracked time for an app before a specific day"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def app_before *args
+      abort('Error') if args.empty? #TODO: better and more complete
+      asked = args[0]
+      date = args[1]
+      begin
+        DateTime.strptime args[1], '%Y-%m-%d'
+      rescue ArgumentError
+        abort Status.specify_day
+      end
+      toki = DBAPI.new
+      view = View.new
+      app = if options[:bundle]
+        JSON.parse toki.bundle_total_before asked, date
+      else
+        JSON.parse toki.name_total_before asked, date
+      end
+      view.total_table app
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.app_total options, app, "app_before-#{app['data']['bundle'].gsub('.', '_')}_#{args[1]}"
+      end
     end
 
-    def total_adn
-      clear
-      puts Status.get_all
-      init_toki_adn
+    desc "app_since APP DATE", "Total tracked time for an app since a specific day"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def app_since *args
+      abort('Error') if args.empty? #TODO: better and more complete
+      asked = args[0]
+      date = args[1]
+      begin
+        DateTime.strptime args[1], '%Y-%m-%d'
+      rescue ArgumentError
+        abort Status.specify_day
+      end
+      toki = DBAPI.new
+      view = View.new
+      app = if options[:bundle]
+        JSON.parse toki.bundle_total_since asked, date
+      else
+        JSON.parse toki.name_total_since asked, date
+      end
+      view.total_table app
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.app_total options, app, "app_since-#{app['data']['bundle'].gsub('.', '_')}_#{date}"
+      end
     end
 
-    def total_db
-      clear
-      #puts "getting data from db\n"
-      init_toki_db
+    desc "app_day APP DATE", "Total tracked time for an app on a specific day"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def app_day *args
+      abort('Error') if args.empty? #TODO: better and more complete
+      asked = args[0]
+      date = args[1]
+      begin
+        DateTime.strptime args[1], '%Y-%m-%d'
+      rescue ArgumentError
+        abort Status.specify_day
+      end
+      toki = DBAPI.new
+      view = View.new
+      app = if options[:bundle]
+        JSON.parse toki.bundle_total_day asked, date
+      else
+        JSON.parse toki.name_total_day asked, date
+      end
+      view.total_table app
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.app_total options, app, "app_day-#{app['data']['bundle'].gsub('.', '_')}_#{date}"
+      end
     end
 
-    def get_total(toki, options)
+    desc "app_range APP DATE1 DATE2", "total tracked time for an app between two specific days"
+    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 :bundle, aliases: '-b', type: :boolean, desc: "Specify the complete bundle identifier (in case the app name resolve doesn't work)"
+    def app_range *args
+      abort('Error') if args.empty? || args.length != 3
       begin
-        get_all(toki, options)
-      rescue Interrupt
-        abort Status.canceled
-      rescue => e
-        abort Status.error(e)
+        DateTime.strptime(args[1], '%Y-%m-%d')
+        DateTime.strptime(args[2], '%Y-%m-%d')
+      rescue ArgumentError
+        abort(Status.specify_range)
+      end
+      toki = DBAPI.new
+      view = View.new
+      app = if options[:bundle]
+        JSON.parse toki.bundle_total_range args[0], args[1], args[2]
+      else
+        JSON.parse toki.name_total_range args[0], args[1], args[2]
+      end
+      view.total_table app
+      if (options[:json] || options[:csv])
+        export = Export.new toki, view
+        export.app_total options, app, "app_range-#{app['data']['bundle'].gsub('.', '_')}_#{args[1]}_#{args[2]}"
       end
     end
 
-    def init_toki_db
-      TokiCLI::Toki.new(nil, nil)
+    desc "restore", "Restore data from App.net and rebuild the Toki.app database"
+    def restore
+      toki_api = DBAPI.new
+      view = View.new
+      import = Import.new toki_api, view
+      import.restore get_token, get_channel_id
     end
 
-    def init_toki_adn(channel_id = get_channel_id)
-      TokiCLI::Toki.new("#{get_token}", channel_id)
-    end
+    private
 
     def get_token
       filepath = Dir.home + '/.TokiCLI/config.json'
@@ -182,13 +309,5 @@ module TokiCLI
       abort Status.no_channel
     end
 
-    def clear
-      puts "\e[H\e[2J"
-    end
-
-    def get_all(t, options)
-      content = t.get_content(options)
-      t.all_data(content)
-    end
   end
 end