TokiCLI 0.2.1 → 0.3.0

data/lib/TokiServer/scss/app.scss

@@ -47,6 +47,11 @@ h1.title {
   border-bottom: 1px solid $blue;
 }
 
+h3.total {
+  text-align: center;
+  color: $white;
+}
+
 .name {
   color: $blue;
 }
@@ -98,5 +103,6 @@ h3.back {
 }
 
 img.icon {
-  margin-top: 3em;
+  margin: 2em auto;
+  text-align: center;
 }

data/lib/TokiServer/tokiserver.rb

@@ -3,10 +3,48 @@
 
 require "sinatra"
 require "sinatra/assetpack"
-require_relative "itunesicon"
+require_relative '../API/toki_api'
+require_relative '../TokiCLI/fileops'
+require_relative "itunesicons"
+require "sinatra/reloader"
 
 class TokiServer < Sinatra::Application
 
+  class Getters
+
+    def initialize(toki, fileops)
+      @toki = toki
+      @fileops = fileops
+    end
+
+    def bundles_from_name(bundles)
+      @fileops.get_bundle_from_name(Array(bundles))
+    end
+
+  end
+
+  # TOKI INIT
+
+  fileops = TokiCLI::FileOps.new
+  toki = TokiCLI::TokiAPI.new(fileops.db_file, fileops.bundles)
+  # Each toki instance has @response, which always contains the last result from a command
+  # So you can go with state (updated toki.response) or stateless (create new TokiAPI instances)
+  getters = Getters.new(toki, fileops)
+  icons = ItunesIcons.new(fileops)
+
+
+  # SINATRA INIT
+
+  configure :development do
+    register Sinatra::Reloader
+  end
+
+  configure do
+    file = File.new("#{fileops.log_path}/server.log", 'a+')
+    file.sync = true
+    use Rack::CommonLogger, file
+  end
+
   set :server, %w[thin webrick]
   set :port, 4567
   set :root, File.dirname(__FILE__)
@@ -14,6 +52,11 @@ class TokiServer < Sinatra::Application
   assets do
     serve '/js', :from => 'js'
     serve '/bower_components', :from => 'bower_components'
+    # serve '/css', :from => 'public/stylesheets'
+
+    # css :application, '/stylesheets/app.css', [
+    #   '/stylesheets/app.css'
+    # ]
 
     js :modernizr, [
       '/bower_components/modernizr/modernizr.js',
@@ -31,347 +74,299 @@ class TokiServer < Sinatra::Application
     js_compression :jsmin
   end
 
-  tk = TokiCLI::DBAPI.new
-  itunesgrabber = ItunesIcon.new
+
+  # WEB ROUTES
 
   get '/' do
     erb :index
   end
 
-  get '/api/?' do
-    endpoints = %w{apps/total apps/top apps/top/NUMBER apps/day/DATE apps/before/DATE apps/since/DATE apps/range/DATE1/DATE2 find/APP_NAME/log bundle/BUNDLE_ID/log find/APP_NAME/total bundle/BUNDLE_ID/total find/APP_NAME/before/DATE bundle/BUNDLE_ID/before/DATE find/APP_NAME/since/DATE bundle/BUNDLE_ID/since/DATE find/APP_NAME/range/DATE1/DATE2 bundle/BUNDLE_ID/range/DATE1/DATE2 find/APP_NAME/split/DATE bundle/BUNDLE_ID/split/DATE}
-    api_endpoints = endpoints.map {|url| "api/#{url}"}
-    content_type :json
-    {
-      meta: {code: 200, message: 'Welcome to the Toki API!'},
-      data: {
-        api_endpoints: api_endpoints,
-        web_endpoints: endpoints
-      }
-    }.to_json
-  end
-
   get '/apps/total/?' do
-    resp = JSON.parse tk.apps_total
-    title = 'Totals'
-    erb :apps_total, locals: {tk: tk, title: title, resp: resp}
+    data = JSON.parse(toki.apps_total)['data']
+    total = toki.helpers.calc_apps_total(data)
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: total }
   end
 
-  get '/api/apps/total/?' do
-    content_type :json
-    tk.apps_total
+  get '/apps/top/?:number?' do
+    data = if params[:number]
+      max = params[:number].to_i
+      JSON.parse(toki.apps_top(max))['data']
+    else
+      JSON.parse(toki.apps_top)['data']
+    end
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: nil }
   end
 
-  get '/apps/top/?' do
-    resp = JSON.parse tk.apps_top
-    top resp, tk
+  get '/apps/day/?:day?' do
+    day = params[:day]
+    data = JSON.parse(toki.apps_day(day))['data']
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: nil }
   end
 
-  get '/api/apps/top/?' do
-    content_type :json
-    tk.apps_top
+  get '/apps/range/:day1/?:day2?' do
+    day1, day2 = params[:day1], params[:day2]
+    data = JSON.parse(toki.apps_range(day1, day2))['data']
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: nil }
   end
 
-  get '/apps/top/:number/?' do
-    number = params[:number].to_i
-    resp = JSON.parse tk.apps_top number
-    top resp, tk
+  get '/apps/since/?:day?' do
+    day = params[:day]
+    data = JSON.parse(toki.apps_since(day))['data']
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: nil }
   end
 
-  get '/api/apps/top/:number/?' do
-    number = params[:number].to_i
-    content_type :json
-    tk.apps_top number
+  get '/apps/before/?:day?' do
+    day = params[:day]
+    data = JSON.parse(toki.apps_before(day))['data']
+    erb :apps_total, locals: { toki: toki, title: 'Total', data: data, total: nil }
   end
 
-  def top resp, tk
-    if resp['meta']['code'] == 200
-      title = 'Top'
-      erb :apps_total, locals: {tk: tk, title: title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: 'No data for this request'}
-    end
+  get '/activity/?' do
+    data = JSON.parse(toki.log_since)['data']
+    erb :activity, locals: { toki: toki, title: 'Activity', data: data, total: nil, name: 'Recent activity', icon: nil }
   end
 
-  get '/apps/before/:day/?' do
+  get '/activity/day/?:day?' do
     day = params[:day]
-    resp = JSON.parse tk.apps_before day
-    title = "Before #{day}"
-    if resp['meta']['code'] == 200
-      erb :apps_total, locals: {tk: tk, title: title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: 'No data for this request'}
-    end
+    data = JSON.parse(toki.log_day(day))['data']
+    total = toki.helpers.calc_logs_total(data)
+    erb :activity, locals: { toki: toki, title: 'Activity', data: data, total: total, name: "#{day} -", icon: nil }
   end
 
-  get '/api/apps/before/:day/?' do
+  get '/activity/since/?:day?' do
     day = params[:day]
-    content_type :json
-    tk.apps_before day
+    data = JSON.parse(toki.log_since(day))['data']
+    total = toki.helpers.calc_logs_total(data)
+    erb :activity, locals: { toki: toki, title: 'Activity', data: data, total: total, name: "Since #{day} -", icon: nil }
   end
 
-  get '/apps/since/:day/?' do
-    day = params[:day]
-    resp = JSON.parse tk.apps_since day
-    title = "Since #{day}"
-    if resp['meta']['code'] == 200
-      erb :apps_total, locals: {tk: tk, title: title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: 'No data for this request'}
-    end
+  get '/logs/bundle/:bundle/total/?' do
+    bundle = params[:bundle]
+    data = JSON.parse(toki.bundle_log(bundle))['data']
+    name = toki.bundles[bundle]
+    icon_url = icons.grab_small(name)
+    erb :activity, locals: { toki: toki, title: 'Total', data: data, total: nil, name: "#{bundle} - #{name}", icon: icon_url }
   end
 
-  get '/api/apps/since/:day/?' do
-    day = params[:day]
-    content_type :json
-    tk.apps_since day
+  get '/logs/bundle/:bundle/day/?:day?' do
+    bundle, day = params[:bundle], params[:day]
+    data = JSON.parse(toki.bundle_log_day(bundle, day))['data']
+    total = toki.helpers.calc_logs_total(data)
+    name = toki.bundles[bundle]
+    icon_url = icons.grab_small(name)
+    erb :activity, locals: { toki: toki, title: 'Total', data: data, total: total, name: "#{bundle} - #{name} -", icon: icon_url  }
   end
 
-  get '/apps/day/:day/?' do
-    day = params[:day]
-    resp = JSON.parse tk.apps_day day
-    if resp['meta']['code'] == 200
-      erb :apps_total, locals: {tk: tk, title: day, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: 'No data for this request'}
-    end
+  get '/logs/bundle/:bundle/since/?:day?' do
+    bundle, day = params[:bundle], params[:day]
+    data = JSON.parse(toki.bundle_log_since(bundle, day))['data']
+    total = toki.helpers.calc_logs_total(data)
+    name = toki.bundles[bundle]
+    icon_url = icons.grab_small(name)
+    erb :activity, locals: { toki: toki, title: 'Total', data: data, total: total, name: "#{bundle} - #{name} -", icon: icon_url  }
   end
 
-  get '/api/apps/day/:day/?' do
-    day = params[:day]
-    content_type :json
-    tk.apps_day day
+  get '/logs/bundle/:bundle/before/?:day?' do
+    bundle, day = params[:bundle], params[:day]
+    data = JSON.parse(toki.bundle_log_before(bundle, day))['data']
+    total = toki.helpers.calc_logs_total(data)
+    name = toki.bundles[bundle]
+    icon_url = icons.grab_small(name)
+    erb :activity, locals: { toki: toki, title: 'Total', data: data, total: total, name: "#{bundle} - #{name} -", icon: icon_url  }
   end
 
-  get '/apps/range/:day1/:day2/?' do
-    day1, day2 = params[:day1], params[:day2]
-    begin
-      d1, d2 = Time.parse(day1), Time.parse(day2)
-    rescue ArgumentError => e
-      redirect '/'
-    end
-    if d1 > d2
-      title = "#{day2} #{day1}"
-      resp = JSON.parse tk.apps_range day2, day1
-    else
-      title = "#{day1} #{day2}"
-      resp = JSON.parse tk.apps_range day1, day2
-    end
-    if resp['meta']['code'] == 200
-      erb :apps_total, locals: {tk: tk, title: title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: 'No data for this request'}
-    end
+  get '/logs/bundle/:bundle/range/?:day1/?:day2?' do
+    bundle, day1, day2 = params[:bundle], params[:day1], params[:day2]
+    data = JSON.parse(toki.bundle_log_range(bundle, day1, day2))['data']
+    total = toki.helpers.calc_logs_total(data)
+    name = toki.bundles[bundle]
+    icon_url = icons.grab_small(name)
+    erb :activity, locals: { toki: toki, title: 'Total', data: data, total: total, name: "#{bundle} - #{name} -", icon: icon_url  }
   end
 
-  get '/api/apps/range/:day1/:day2/?' do
-    day1, day2 = params[:day1], params[:day2]
-    content_type :json
-    tk.apps_range day1, day2
-  end
+  # /logs/app will be added when I find time to create an interactive page with fields, checks, apps list, etc
 
-  get '/find/:name/total/?' do
-    name = params[:name]
-    resp = JSON.parse tk.name_total(name)
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
-    end
-  end
 
-  get '/api/find/:name/total/?' do
-    name = params[:name]
-    content_type :json
-    tk.name_total name
-  end
 
-  get '/bundle/:bundle/total/?' do
-    bundle = params[:bundle]
-    resp = JSON.parse tk.bundle_total bundle
-    erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
+
+  # API ROUTES
+
+  get '/api/?' do
+    content_type :json
+    {
+      'meta' => {
+        'code' => 200,
+        'message' => 'Welcome to the Toki API server.'
+      },
+      'data' => {
+        'routes' => %w{/api/apps/total /api/apps/top/[number] api/apps/day/(iso8601_date) /api/apps/range/(iso8601_date)/(iso8601_date) /api/apps/since/(iso8601_date) /api/apps/before/(iso8601_date) /api/activity /api/activity/day/(iso8601_date) /api/activity/since/(iso8601_date) /api/logs/bundle/(bundle_id)/total /api/logs/bundle/(bundle_id)/day/(iso8601_date) /api/logs/bundle/(bundle_id)/since/(iso8601_date) /api/logs/bundle/(bundle_id)/before/(iso8601_date) /api/logs/bundle/(bundle_id)/range/(iso8601_date)/(iso8601_date) /api/logs/app/(app_name)/total /api/logs/app/(app_name)/day/(iso8601_date) /api/logs/app/(app_name)/since/(iso8601_date) /api/logs/app/(app_name)/before/(iso8601_date) /api/logs/app/(app_name)/range/(iso8601_date)/(iso8601_date) /api/user /api/bundles}
+      }
+    }.to_json
   end
 
-  get '/api/bundle/:bundle/total/?' do
-    bundle = params[:bundle]
+  get '/api/apps/total/?' do
     content_type :json
-    tk.bundle_total bundle
+    toki.apps_total()
   end
 
-  get '/find/:name/since/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.name_total_since name, day
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
+  get '/api/apps/top/?:number?' do
+    max = params[:number].to_i
+    content_type :json
+    if params[:number]
+      toki.apps_top(max)
     else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
+      toki.apps_top()
     end
   end
 
-  get '/api/find/:name/since/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/apps/day/?:day?' do
+    day = params[:day]
     content_type :json
-    tk.name_total_since name, day
+    toki.apps_day(day)
   end
 
-  get '/bundle/:name/since/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.bundle_total_since name, day
-    erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
+  get '/api/apps/range/:day1/?:day2?' do
+    day1, day2 = params[:day1], params[:day2]
+    content_type :json
+    toki.apps_range(day1, day2)
   end
 
-  get '/api/bundle/:name/since/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/apps/since/?:day?' do
+    day = params[:day]
     content_type :json
-    tk.bundle_total_since name, day
+    toki.apps_since(day)
   end
 
-  get '/find/:name/before/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.name_total_before name, day
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
-    end
+  get '/api/apps/before/?:day?' do
+    day = params[:day]
+    content_type :json
+    toki.apps_before(day)
   end
 
-  get '/api/find/:name/before/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/activity/?' do
     content_type :json
-    tk.name_total_before name, day
+    toki.log_since()
   end
 
-  get '/bundle/:name/before/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.bundle_total_before name, day
-    erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
+  get '/api/activity/recent/?' do
+    content_type :json
+    toki.log_since()
   end
 
-  get '/api/bundle/:name/before/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/activity/today/?' do
     content_type :json
-    tk.bundle_total_before name, day
+    toki.log_since()
   end
 
-  get '/find/:name/range/:day1/:day2/?' do
-    name, day1, day2 = params[:name], params[:day1], params[:day2]
-    if Time.parse(day1) > Time.parse(day2)
-      title = "#{day2} #{day1}"
-      resp = JSON.parse tk.name_total_range name, day2, day1
-    else
-      title = "#{day1} #{day2}"
-      resp = JSON.parse tk.name_total_range name, day1, day2
-    end
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_total, locals: {tk: tk, title: title, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
-    end
+  get '/api/activity/day/?:day?' do
+    day = params[:day]
+    content_type :json
+    toki.log_day(day)
   end
 
-  get '/api/find/:name/range/:day1/:day2/?' do
-    name, day1, day2 = params[:name], params[:day1], params[:day2]
+  get '/api/activity/since/?:day?' do
+    day = params[:day]
     content_type :json
-    tk.name_total_range name, day1, day2
+    toki.log_since(day)
   end
 
-  get '/bundle/:name/range/:day1/:day2/?' do
-    name, day1, day2 = params[:name], params[:day1], params[:day2]
-    if Time.parse(day1) > Time.parse(day2)
-      title = "#{day2} #{day1}"
-      resp = JSON.parse tk.bundle_total_range name, day2, day1
-    else
-      title = "#{day1} #{day2}"
-      resp = JSON.parse tk.bundle_total_range name, day1, day2
-    end
-    erb :name_total, locals: {tk: tk, title: basic_title, resp: resp}
+  get '/api/logs/bundle/:bundle/total/?' do
+    bundle = params[:bundle]
+    content_type :json
+    toki.bundle_log(bundle)
   end
 
-  get '/api/bundle/:name/range/:day1/:day2/?' do
-    name, day1, day2 = params[:name], params[:day1], params[:day2]
+  get '/api/logs/bundle/:bundle/day/?:day?' do
+    bundle, day = params[:bundle], params[:day]
     content_type :json
-    tk.bundle_total_range name, day1, day2
+    toki.bundle_log_day(bundle, day)
   end
 
-  get '/find/:name/split/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.name_total_split name, day
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_split, locals: {tk: tk, title: day, resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
-    end
+  get '/api/logs/bundle/:bundle/since/?:day?' do
+    bundle, day = params[:bundle], params[:day]
+    content_type :json
+    toki.bundle_log_since(bundle, day)
+  end
+
+  get '/api/logs/bundle/:bundle/before/?:day?' do
+    bundle, day = params[:bundle], params[:day]
+    content_type :json
+    toki.bundle_log_before(bundle, day)
   end
 
-  get '/api/find/:name/split/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/logs/bundle/:bundle/range/?:day1/?:day2?' do
+    bundle, day1, day2 = params[:bundle], params[:day1], params[:day2]
     content_type :json
-    tk.name_total_split name, day
+    toki.bundle_log_range(bundle, day1, day2)
   end
 
-  get '/bundle/:name/split/:day/?' do
-    name, day = params[:name], params[:day]
-    resp = JSON.parse tk.bundle_total_split name, day
-    erb :name_split, locals: {tk: tk, title: day, resp: resp}
+  get '/api/logs/app/:app/total/?' do
+    app = params[:app]
+    content_type :json
+    candidates = getters.bundles_from_name(app)
+    candidates.map {|bundle| toki.bundle_log(bundle)}
   end
 
-  get '/api/bundle/:name/split/:day/?' do
-    name, day = params[:name], params[:day]
+  get '/api/logs/app/:app/day/?:day?' do
+    app, day = params[:app], params[:day]
     content_type :json
-    tk.bundle_total_split name, day
+    candidates = getters.bundles_from_name(app)
+    candidates.map {|bundle| toki.bundle_log_day(bundle, day)}
   end
 
-  get '/bundle/:name/log/?' do
-    name = params[:name]
-    resp = sort_log JSON.parse(tk.bundle_log(name))
-    erb :name_log, locals: {tk: tk, title: 'Log', resp: resp}
+  get '/api/logs/app/:app/since/?:day?' do
+    app, day = params[:app], params[:day]
+    content_type :json
+    candidates = getters.bundles_from_name(app)
+    candidates.map {|bundle| toki.bundle_log_since(bundle, day)}
   end
 
-  get '/api/bundle/:name/log/?' do
-    name = params[:name]
+  get '/api/logs/app/:app/before/?:day?' do
+    app, day = params[:app], params[:day]
     content_type :json
-    tk.bundle_log name
+    candidates = getters.bundles_from_name(app)
+    candidates.map {|bundle| toki.bundle_log_before(bundle, day)}
   end
 
-  get '/find/:name/log/?' do
-    name = params[:name]
-    resp = sort_log JSON.parse(tk.name_log(name))
-    if resp['meta']['code'] == 200
-      #@icon_url = itunesgrabber.grab_big(name)
-      erb :name_log, locals: {tk: tk, title: 'Log', resp: resp}
-    else
-      erb :error, locals: {resp: resp, message: "Unable to find '#{name}'"}
-    end
+  get '/api/logs/app/:app/range/?:day1/?:day2?' do
+    app, day1, day2 = params[:app], params[:day1], params[:day2]
+    content_type :json
+    candidates = getters.bundles_from_name(app)
+    candidates.map {|bundle| toki.bundle_log_range(bundle, day1, day2)}
   end
 
-  get '/api/find/:name/log/?' do
-    name = params[:name]
+  get '/api/user/?' do
     content_type :json
-    tk.name_log name
+    File.read(fileops.user_file)
   end
 
-  def sort_log resp
-    bucket, net = [], {}
-    resp['data']['log'].each do |id, content|
-      bucket << [id, content]
-    end
-    bucket.sort_by! {|id, content| content['start']}
-    bucket.each do |id, content|
-      net[id] = content
-    end
-    resp['data']['log'] = net
-    resp
+  get '/api/bundles/?' do
+    content_type :json
+    fileops.bundles.to_json
   end
 
-  def basic_title
-    "Total"
+  get '/api/names/?' do
+    content_type :json
+    fileops.bundles.to_json
+  end
+
+  # ---
+
+  not_found do
+    message = request.env['sinatra.error'].to_s.split('::')[1]
+    if request.path_info =~ /\/api/
+      content_type :json
+      {
+        'meta' => {
+          'code' => 404,
+          'message' => message,
+          'processed_at' => Time.now
+        },
+        'data' => request.env
+      }.to_json
+    else
+      erb :error, locals: { title: '404', data: request.env, error: message }
+    end
   end
 
 end
-