rbbt-views 1.0.1 → 2.0.0

data/lib/rbbt/workflow/rest.rb

@@ -13,23 +13,26 @@ require 'rbbt/workflow/rest/auth.rb'
 require 'rbbt/workflow/rest/email.rb'
 require 'rbbt/workflow/rest/helpers.rb'
 require 'rbbt/workflow/rest/entity.rb'
+require 'rbbt/workflow/rest/notes.rb'
 
 module WorkflowREST
-
   class << self
     attr_accessor :workflows
     self
   end
   self.workflows = []
 
-
   def self.setup
     configure do
       Compass.add_project_configuration(Rbbt.share.views.compass["compass.config"].find.dup.to_s)
     end
 
     Sinatra.module_eval do
+
       helpers Sinatra::SinatraRbbt
+
+      use Rack::Deflater
+
       enable :static
 
       # This would make random secrets that would make the server hang after reload by old cookies. 
@@ -38,19 +41,41 @@ module WorkflowREST
       use Rack::Session::Cookie, :key => 'rack.session',
         :path => '/',
         :expire_after => 2592000,
-        :secret => 'rbbt_default_secret. Please CHANGE!'
+        :secret => 'rbbt_default_secret. Please CHANGE! ' + WorkflowREST.workflows.collect{|w| w.to_s} * ", "
+
+      set :root, ENV["PWD"]
+      set :cache_dir, "var/cache" unless settings.respond_to? :cache_dir and settings.cache_dir
+      set :persistence_dir, "var/cache/persistence" unless settings.respond_to? :persistence_dir and settings.persistence_dir
+      set :file_dir, "var/files" unless settings.respond_to? :file_dir and settings.file_dir
+      set :note_dir, "var/notes" unless settings.respond_to? :note_dir and settings.note_dir
+      set :user_action_defaults, "var/user_defaults" unless settings.respond_to? :user_action_defaults and settings.user_action_defaults
 
-      set :cache_dir, "cache"
+      # To allow crossorigin with json
+      # http://trevorpower.com/blog/faiiure-to-access-json-on-a-remote-domain
+      set :protection, :except => :json_csrf
 
       before do
         @file_cache = {}
         @result_cache = {}
+        @js_files = []
+        @css_files = []
+
         headers "AJAX-URL" => request.env["REQUEST_URI"]
+
+        params.delete "_"
+        params.delete :_
+        cache_control :public, :must_revalidate, :max_age => 60
+
+        # CrossOrigin
+        headers 'Access-Control-Allow-Origin' => request.env['HTTP_ORIGIN'],
+          'Access-Control-Allow-Methods' => %w(GET POST OPTIONS),
+          'Access-Control-Allow-Credentials' => "true",
+          'Access-Control-Max-Age' => "1728000"
       end
 
       after do
-        @file_cache.clear
-        @result_cache.clear
+        @file_cache.clear if @file_cache
+        @result_cache.clear if @result_cache
       end
 
       helpers do
@@ -78,45 +103,94 @@ module WorkflowREST
       end
     end
 
-    if production?
-      before do
-        params.delete "_"
-        params.delete :_
-        cache_control :public, :must_revalidate, :max_age => 60
+    followed_users = {}
+    all_users = settings.users.keys
+    all_users.each do |user|
+      followed_users[user] = all_users - [user]
+    end
+    set :followed_users, followed_users
+
+    error do
+      error = request.env['sinatra.error']
+      workflow_render('error', :message => error.message)
+    end
+
+    #{{{ Files, CSS, and JS
+
+    get '/files/:filename' do
+      cache_control :public, :max_age => 36000 if production?
+      file = File.join(settings.file_dir, params[:filename])
+      send_file file
+    end
+
+    get '/stylesheets/entity/:type/:entity/:name.css' do
+
+      entity_type, format = params["type"].split ":"
+      entity = setup_entity(entity_type, format, params["entity"])
+
+      file = locate_file(WorkflowREST.workflows.last, nil, File.join("compass", params[:name] + '.sass'), entity)
+
+      content_type 'text/css', :charset => 'utf-8'
+      cache_control :public, :max_age => 36000 if production?
+      cache_type = production? ? :sync : :none
+      cache('css', params.merge(:cache_type => cache_type)) do
+        renderer = Sass::Engine.new(file.read, :filename => file.find)
+        css_text = renderer.render
+        YUI::CssCompressor.new.compress(css_text)
       end
-      Log.severity = 0
     end
 
     get '/stylesheets/:name.css' do
       file = locate_file(WorkflowREST.workflows.last, nil, File.join("compass", params[:name] + '.sass'))
 
       content_type 'text/css', :charset => 'utf-8'
-      cache('css', params.merge(:cache_type => :sync)) do
-        renderer = Sass::Engine.new(file.read)
-        renderer.render
+      cache_control :public, :max_age => 36000 if production?
+      cache_type = production? ? :sync : :none
+      cache('css', params.merge(:cache_type => cache_type)) do
+        renderer = Sass::Engine.new(file.read, :filename => file.find)
+        css_text = renderer.render
+        YUI::CssCompressor.new.compress(css_text)
       end
     end
 
+    get '/js/entity/:type/:entity/:name.js' do
+      content_type 'text/css', :charset => 'utf-8'
+      cache_control :public, :max_age => 36000 if production?
+
+      entity_type, format = params["type"].split ":"
+      entity = setup_entity(entity_type, format, params["entity"])
+
+      send_file locate_file(WorkflowREST.workflows.last, nil, File.join("js", params[:name] + '.js'), entity)
+    end
+
     get '/js/:name.js' do
       content_type 'text/css', :charset => 'utf-8'
-      send_file locate_file(nil, nil, File.join("js", params[:name] + '.js')).find
+      cache_control :public, :max_age => 36000 if production?
+      send_file locate_file(WorkflowREST.workflows.last, nil, File.join("js", params[:name] + '.js')).find
     end
 
-    get '/entity/:type/:entity' do
-      type = params[:type]
+    #{{{ entity
+    
+    get '/entity/:entity_type/:entity' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params[:entity_type]
 
       visualization_parameters = get_visualization_parameters(params)
 
-      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :sync
+      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :async
+      update = params.delete(:_update) || params.delete("_update") || nil
 
-      cache("Entity:", :params => params, :visualization_params => visualization_parameters, :user => user) do
-        entity_render(type, params.merge(visualization_parameters))
+      cache("Entity [#{ params[:entity] }]:", :update => update, :cache_type => cache_type, :params => params, :visualization_params => visualization_parameters, :user => user) do
+        entity_render(entity_type, params.merge(visualization_parameters))
       end
     end
 
     #{{{ entity_list
     
     get '/entity_list/:user' do
+      params.delete "captures"
+      params.delete "splat"
       list_user = params.delete(:user) || params.delete("user")
 
       list_user = user if list_user.to_s == "user"
@@ -129,124 +203,208 @@ module WorkflowREST
       workflow_render('user_lists', params.merge(:lists => lists))
     end
 
-    get '/entity_list/:type/:id' do
-      type = params.delete "type"
+    get '/entity_list/:entity_type/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
       visualization_parameters = get_visualization_parameters(params)
+      list_id = params[:id] = CGI.unescape(params[:id])
 
-      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :sync
+      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :async
       update = params.delete(:_update) || params.delete("_update") || nil
 
-      check = Entity::REST.list_file(type, params[:id], user)
-      check = Entity::REST.list_file(type, params[:id]) unless not check.nil? and File.exists? check
-
-      raise "List of type #{ type } not found for #{params[:id]}: #{ check.inspect }" if check.nil? or not File.exists?(check)
-
-      cache("Entity List:", :check => [check], :update => update, :cache_type => cache_type, :params => params, :type => type, :visualization_params => visualization_parameters, :user => user) do
-        if visualization_parameters[:_format] == 'json'
-          list = Entity::REST.load_list(type, params[:id], user)
-          list.collect{|elem| [elem.clean_annotations, elem.info]}.to_json
+      check = Entity::REST.list_file(entity_type, list_id, user)
+      check = Entity::REST.list_file(entity_type, list_id, :public) if check.nil? or not File.exists? check
+      check = Entity::REST.list_file(entity_type, list_id) if check.nil? or not File.exists? check
+
+      raise "List of type #{ entity_type } not found for #{list_id}: #{ check.inspect }" if check.nil? or not File.exists?(check)
+
+      content_type "text/plain" if visualization_parameters[:_format] == 'literal' or visualization_parameters[:_format] == 'tsv' or visualization_parameters[:_format] == 'bed'
+      content_type "application/json" if visualization_parameters[:_format] == 'json'
+
+      cache("Entity List:", :check => [check], :update => update, :cache_type => cache_type, :params => params, :entity_type => entity_type, :visualization_params => visualization_parameters, :user => user) do
+        case (visualization_parameters[:_format] || 'html').to_s
+        when  'json'
+          list = Entity::REST.load_list(entity_type, list_id, user)
+          list.collect{|elem| [elem.clean_annotations, elem.info.merge(:id => elem.id)]}.to_json
+        when  'bed'
+          list = Entity::REST.load_list(entity_type, list_id, user)
+          type = entity_type.split(":").first
+          case type
+          when "GenomicMutation"
+            list.collect{|elem| ['chr' + elem.chromosome, elem.position, elem.position+1] * "\t"} * "\n"
+          else
+            raise "Don't know how to produce bed file for entity type: #{ entity_type }"
+          end
+        when 'tsv'
+          list = Entity::REST.load_list(entity_type, list_id, user)
+          Annotated.tsv(list, :all).to_s
+        when 'literal'
+          list = Entity::REST.load_list(entity_type, list_id, user)
+          list * "\n"
         else
-          entity_list_render(type, params.merge(visualization_parameters))
+          entity_list_render(entity_type, params.merge(visualization_parameters))
         end
       end
     end
 
-    post '/entity_list/:type/copy/:id' do
-      type = params.delete "type"
+    post '/entity_list/:entity_type/create/:id' do
+      params.delete "captures"
+      params.delete "splat"
+
+      list_id = params.delete("id")
+      list_id = CGI.unescape(list_id)
+
+      entity_type = params.delete "entity_type"
+      entities = params.delete("entities")
+
+      raise "No entities" unless (entities and not entities.empty?)
+
+      entities = entities.split(/[,;|]/)
+
+      options = IndiferentHash.setup(params.dup)
+      entities = Misc.prepare_entity(entities, entity_type, options)
+
+      Entity::REST.save_list(entity_type, list_id, entities, user)
+
+      redirect "/entity_list/#{ entity_type }/#{list_id}"
+    end
+
+    post '/entity_list/:entity_type/copy/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
 
-      list = Entity::REST.load_list(type, params[:id], user)
-      Entity::REST.save_list(type, params[:new_id], list, user)
+      list_id = params[:id] = CGI.unescape(params[:id])
+      list = Entity::REST.load_list(entity_type, list_id, user)
+      Entity::REST.save_list(entity_type, params[:new_id], list, user)
 
-      redirect "/entity_list/#{ type }/#{params[:new_id]}"
+      redirect "/entity_list/#{ entity_type }/#{params[:new_id]}"
     end
 
-    post '/entity_list/:type/add/:id' do
-      type = params.delete "type"
+    post '/entity_list/:entity_type/add/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
 
-      list = Entity::REST.load_list(type, params[:id], user)
-      other_list = Entity::REST.load_list(type, params[:other_list], user)
+      list_id = params[:id] = CGI.unescape(params[:id])
+      list = Entity::REST.load_list(entity_type, list_id, user)
+      other_list = Entity::REST.load_list(entity_type, params[:other_list], user)
       list.concat other_list
-      Entity::REST.save_list(type, params[:id], list, user)
+      list.uniq!
+      Entity::REST.save_list(entity_type, list_id, list, user)
 
       redirect back
     end
 
-    post '/entity_list/:type/remove/:id' do
-      type = params.delete "type"
+    post '/entity_list/:entity_type/remove/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
 
-      list = Entity::REST.load_list(type, params[:id], user)
-      other_list = Entity::REST.load_list(type, params[:other_list], user)
-      Entity::REST.save_list(type, params[:id], list.remove(other_list), user)
+      list_id = params[:id] = CGI.unescape(params[:id])
+      list = Entity::REST.load_list(entity_type, list_id, user)
+      other_list = Entity::REST.load_list(entity_type, params[:other_list], user)
+      Entity::REST.save_list(entity_type, list_id, list.remove(other_list), user)
 
       redirect back
     end
 
-    post '/entity_list/:type/subset/:id' do
-      type = params.delete "type"
+    post '/entity_list/:entity_type/subset/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
 
-      list = Entity::REST.load_list(type, params[:id], user)
-      other_list = Entity::REST.load_list(type, params[:other_list], user)
-      Entity::REST.save_list(type, params[:id], list.subset(other_list), user)
+      list_id = params[:id] = CGI.unescape(params[:id])
+      list = Entity::REST.load_list(entity_type, list_id, user)
+      other_list = Entity::REST.load_list(entity_type, params[:other_list], user)
+      Entity::REST.save_list(entity_type, list_id, list.subset(other_list), user)
 
       redirect back
     end
 
-    get '/entity_list/:type/edit/:id' do
-      type = params[:type]
+    get '/entity_list/:entity_type/edit/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params[:entity_type]
       visualization_parameters = get_visualization_parameters(params)
 
       workflow = WorkflowREST.workflows.last
-      id = params[:id]
-      list = Entity::REST.load_list(type, id, user)
+      list_id = params[:id] = CGI.unescape(params[:id])
+      id = list_id
+      list = Entity::REST.load_list(entity_type, id, user)
       workflow_render('edit_list', workflow, params.merge(:list => list))
     end
 
-    delete '/entity_list/:type/:id' do
-      Entity::REST.delete_list(params[:type], params[:id], user)
+    delete '/entity_list/:entity_type/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      list_id = params[:id] = CGI.unescape(params[:id])
+      Entity::REST.delete_list(params[:entity_type], list_id, user)
       redirect '/'
     end
  
-            # entities
-    delete '/entity_list/:type/:entity/:id' do
-      id = params[:id]
-      Log.debug "Deleting #{params[:entity] } from #{params[:id]}"
+    delete '/entity_list/:entity_type/:entity/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      id = params[:id] = CGI.unescape(params[:id])
+      Log.debug "Deleting #{params[:entity] } from #{id}"
 
-      list = Entity::REST.load_list(params[:type], id, user)
+      list = Entity::REST.load_list(params[:entity_type], id, user)
 
       list.delete params[:entity]
 
-      Entity::REST.save_list(params[:type], id, list, user)
+      Entity::REST.save_list(params[:entity_type], id, list, user)
 
       redirect back
     end
 
-    post '/entity_list/:type/:entity/:id' do
-      id     = params.delete(:id) || params.delete("id")
-      entity = params.delete(:entity) || params.delete("entity")
-      type   = params.delete(:type) || params.delete("type")
+    post '/entity_list/:entity_type/:entity/:list_id' do
+      params.delete "captures"
+      params.delete "splat"
+      list_id       = params.delete(:list_id) || params.delete("list_id")
+      entity        = params.delete(:entity) || params.delete("entity")
+      entity_type   = params.delete(:entity_type) || params.delete("entity_type")
 
-      info = {}
+      entity_type, entity_format = entity_type.split(":")
+      info = {:annotation_types => entity_type, :format => entity_format}
       params.each{|k,v| info[k] = begin JSON.parse(v) rescue v end}
       entity = Annotated.load_tsv_values(entity, [[info.to_json]], "JSON")
+      entity.id = params[:entity_id] if params.include? :entity_id
 
-      list = Entity::REST.load_list(type, id, user)
-
+      list = 
+        begin
+          Entity::REST.load_list(entity_type, list_id, user) || []
+        rescue
+          []
+        end
 
-      different = entity.info.select{|k,v| not v.nil? and v != list_info[k]}.any?
+      
+      different = Annotated === list ? entity.info.select{|k,v| not v.nil? and v != list.info[k]}.any? : true
 
+      if different
+        new = list.collect{|e| e}
+      else
+        new = list
+      end
 
-      new = list.collect{|e| e} if different
-      new.delete entity
+      new = new.reject{|e| e.id == entity.id}
       new << entity
-      Entity::REST.save_list(type, id, new, user)
 
-      redirect back
+
+      new.first.annotate new if new.collect{|e| e.info}.uniq.length == 1
+
+      Entity::REST.save_list(entity_type, list_id, new, user)
+
+      redirect back unless request.xhr?
     end
   
     #{{{ entity_action
 
-    get '/entity_action/:type/:action/:entity' do
-      type = params.delete "type"
+    get '/entity_action/:entity_type/:action/:entity' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
       action = params.delete "action" 
 
       visualization_parameters = get_visualization_parameters(params)
@@ -254,13 +412,22 @@ module WorkflowREST
       cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :async
       update = params.delete(:_update) || params.delete("_update") || nil
 
-      cache("Entity Action [#{action}][#{ params[:entity] }]", :update => update, :cache_type => cache_type, :params => params, :type => type, :action => action, :visualization_params => visualization_parameters, :user => user) do
-        entity_action_render(type, action, params.merge(visualization_parameters))
+      add_user_defaults(user, entity_type, action, params) if authorized?
+
+      html = cache("Entity Action [#{action}][#{ params[:entity] }]", :update => update, :cache_type => cache_type, :params => params, :entity_type => entity_type, :action => action, :visualization_params => visualization_parameters, :user => user) do
+        entity_action_render(entity_type, action, params.merge(visualization_parameters))
       end
+
+      save_user_defaults(user, entity_type, action, params) if authorized? and response.status == 200
+      clear_user_defaults(user, entity_type, action) if authorized? and response.status == 500
+
+      html
     end
 
-    get '/entity_list_action/:type/:action/:id' do
-      type = params.delete "type"
+    get '/entity_list_action/:entity_type/:action/:id' do
+      params.delete "captures"
+      params.delete "splat"
+      entity_type = params.delete "entity_type"
       action = params.delete "action" 
 
       visualization_parameters = get_visualization_parameters(params)
@@ -268,11 +435,78 @@ module WorkflowREST
       cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :async
       update = params.delete(:_update) || params.delete("_update") || nil
 
-      cache("Entity List Action [#{action}] [#{ params[:id]}]", :update => update, :cache_type => cache_type, :params => params, :type => type, :action => action, :visualization_params => visualization_parameters, :user => user) do
-        entity_list_action_render(type, action, params.merge(visualization_parameters))
+      add_user_defaults(user, entity_type, action, params) if authorized?
+
+      list_id = params[:id] = params[:id] = CGI.unescape(params[:id])
+      html = cache("Entity List Action [#{action}] [#{ list_id}]", :update => update, :cache_type => cache_type, :params => params, :entity_type => entity_type, :action => action, :visualization_params => visualization_parameters, :user => user) do
+        entity_list_action_render(entity_type, action, params.merge(visualization_parameters))
       end
+
+      save_user_defaults(user, entity_type, action, params) if authorized? and response.status == 200
+      clear_user_defaults(user, entity_type, action) if authorized? and response.status == 500
+
+      html
+    end
+
+    #{{{ Notes
+
+    get '/notes/edit/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      markup = get_notes_markup(path, params, user)
+      workflow_render('notes', StudyExplorer, nil, :markup => markup)
+    end
+
+    post '/notes/edit/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      path = path.sub("/notes/edit", "/notes")
+      markup = params.delete('markup')
+      save_notes(path, params, markup, user)
+      redirect request.env["REQUEST_URI"].sub('/notes/edit', '/notes')
     end
 
+    post '/notes/share/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      path = path.sub("/notes/edit", "/notes")
+      markup = params.delete('markup')
+      params.delete("_method")
+      share_notes(path, params, markup, user)
+      redirect back unless request.xhr?
+    end
+
+    post '/notes/unshare/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      path = path.sub("/notes/edit", "/notes")
+      markup = params.delete('markup')
+      params.delete("_method")
+      unshare_notes(path, params, markup, user)
+      redirect back unless request.xhr?
+    end
+
+
+    delete '/notes/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      params.delete("_method")
+      markup = delete_notes_markup(path, params, user)
+      redirect File.join("/", path)
+    end
+
+    get '/notes/shared/:user/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      sharing_user = params.delete('user')
+      render_notes(path, params, sharing_user, true)
+    end
+
+    get '/notes/*' do
+      params.delete "captures"
+      path = params.delete("splat").last
+      render_notes(path, params, user)
+    end
   end
 
   def self.add_task(workflow, task_name, type = nil)
@@ -301,8 +535,10 @@ module WorkflowREST
 
       case
       when visualization_parameters[:_format] == "json"
+        content_type "application/json"
         task_info.to_json
       when visualization_parameters[:_format] == "raw"
+        content_type "text/plain"
         task_info.collect{|k,v| [k,v] * "\t"} * "\n"
       when visualization_parameters[:_format] == "html"
         workflow_render("task_info", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:task_info => task_info))
@@ -376,7 +612,7 @@ module WorkflowREST
 
       when :exec
         result = workflow.job(task_name, real_jobname, inputs.dup).exec
-        workflow_render_result(result, workflow, task_name, visualization_parameters.merge(:inputs => inputs))
+        workflow_render_result(result, workflow, task_name, visualization_parameters.merge(:inputs => inputs).merge(workflow.task_info(task_name)))
 
       when :synchronous, :asynchronous
         job = workflow.job(task_name, real_jobname, inputs)
@@ -426,7 +662,11 @@ module WorkflowREST
 
       session[:jobname] = jobname
 
-      step = workflow.load_id(File.join(task_name, real_jobname))
+      step = nil
+      [real_jobname, jobname].uniq.each do |jname|
+        step = workflow.load_id(File.join(task_name, jname))
+        break if File.exists? step.info_file
+      end
 
       case
 
@@ -436,7 +676,7 @@ module WorkflowREST
         if visualization_parameters[:_format] == "html"
           content_type "text/html"
           status 500
-          return workflow_render("error", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs]))
+          return workflow_render("step_error", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs]))
         else
           status 500
           content_type "text/plain"
@@ -449,8 +689,13 @@ module WorkflowREST
         if visualization_parameters[:_format] == "html"
           content_type "text/html"
           status 202
-          @rbbt_refresh = 30 unless step.error?
-          return workflow_render("wait", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs]))
+          if request.xhr?
+            visualization_parameters[:_layout] = false
+            return workflow_render("wait", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs]))
+          else
+            @rbbt_refresh = 30 unless step.error?
+            return workflow_render("wait", workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs]))
+          end
         else
           status 202
           step.status
@@ -467,21 +712,45 @@ module WorkflowREST
               :user => user
              ) do
                case
+               when visualization_parameters[:_format].to_s == "excel"
+                 require 'rbbt/tsv/excel'
+                 data = nil
+                 excel_file = TmpFile.tmp_file
+                 result = step.load
+                 result.excel(excel_file, :name => params[:_excel_use_name],:sort_by => params[:_excel_sort_by], :sort_by_cast => params[:_excel_sort_by_cast])
+                 send_file excel_file, :type => 'application/vnd.ms-excel', :filename => step.clean_name + '.xls'
                when visualization_parameters[:_format] == "html"
                  result = step.load
                  workflow_render_result(result, workflow, task_name, workflow.task_info(task_name).merge(visualization_parameters).merge(:jobname => jobname, :step => step, :inputs => step.info[:inputs], :result => result))
 
-               when visualization_parameters[:_format] == "json"
-                 content_type "application/json"
+               when visualization_parameters[:_format].to_s == "json"
                  result = step.load
                  result = paginate(result, visualization_parameters[:_page]) if visualization_parameters.include? "_page"
 
-                 if TSV === result
+                 content_type "application/json"
+
+                 case
+                 when TSV === result
                    result.dup.to_json
+                 when workflow.task_info(task_name)[:result_type] == :annotations
+                   Annotated.json(result, true)
                  else
                    result.to_json
                  end
 
+               when visualization_parameters[:_format].to_s == "raw"
+                 content_type "text/plain"
+                 result = step.load
+
+                 case
+                 when workflow.task_info(task_name)[:result_type] == :annotations
+                   Annotated.tsv(result, :all).to_s
+                 when Array === result
+                   result * "\n"
+                 else
+                   result.to_s
+                 end
+
                else
                  content_type "text/plain"
                  result = step.load
@@ -636,7 +905,8 @@ module WorkflowREST
 
       get File.join("/plugins", workflow.to_s, "*") do
         file = params[:splat].first
-        send_file RbbtHTMLHelpers.locate_file(workflow, nil, 'plugins/' + file)
+        path = RbbtHTMLHelpers.locate_file(workflow, nil, 'plugins/' + file)
+        send_file path
       end
 
       workflow.asynchronous_exports.each do |name|