rbbt-views 1.0.0 → 1.0.1

data/lib/rbbt/workflow/rest.rb

@@ -12,6 +12,7 @@ require 'rbbt/workflow/rest/render.rb'
 require 'rbbt/workflow/rest/auth.rb'
 require 'rbbt/workflow/rest/email.rb'
 require 'rbbt/workflow/rest/helpers.rb'
+require 'rbbt/workflow/rest/entity.rb'
 
 module WorkflowREST
 
@@ -29,9 +30,18 @@ module WorkflowREST
 
     Sinatra.module_eval do
       helpers Sinatra::SinatraRbbt
-      enable :sessions
       enable :static
 
+      # This would make random secrets that would make the server hang after reload by old cookies. 
+      # enable :sessions 
+      # Util fix...
+      use Rack::Session::Cookie, :key => 'rack.session',
+        :path => '/',
+        :expire_after => 2592000,
+        :secret => 'rbbt_default_secret. Please CHANGE!'
+
+      set :cache_dir, "cache"
+
       before do
         @file_cache = {}
         @result_cache = {}
@@ -53,6 +63,7 @@ module WorkflowREST
           request.env['REMOTE_USER'] == user || throw(:halt, [ 401, 'Authorization Required' ])
         end
       end
+
     end
 
     set :public_folder, RbbtHTMLHelpers.locate_file(nil, nil, 'public/').find
@@ -69,6 +80,8 @@ module WorkflowREST
 
     if production?
       before do
+        params.delete "_"
+        params.delete :_
         cache_control :public, :must_revalidate, :max_age => 60
       end
       Log.severity = 0
@@ -78,7 +91,7 @@ module WorkflowREST
       file = locate_file(WorkflowREST.workflows.last, nil, File.join("compass", params[:name] + '.sass'))
 
       content_type 'text/css', :charset => 'utf-8'
-      cache('css', params) do
+      cache('css', params.merge(:cache_type => :sync)) do
         renderer = Sass::Engine.new(file.read)
         renderer.render
       end
@@ -93,27 +106,155 @@ module WorkflowREST
       type = params[:type]
 
       visualization_parameters = get_visualization_parameters(params)
+
+      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :sync
+
       cache("Entity:", :params => params, :visualization_params => visualization_parameters, :user => user) do
         entity_render(type, params.merge(visualization_parameters))
       end
     end
 
+    #{{{ entity_list
+    
+    get '/entity_list/:user' do
+      list_user = params.delete(:user) || params.delete("user")
+
+      list_user = user if list_user.to_s == "user"
+
+      if list_user != "public"
+        raise "Not allowed to view entity lists for: #{ user }" unless authorized? and user.to_s == list_user
+      end
+
+      lists = Entity::REST.list_files(list_user)
+      workflow_render('user_lists', params.merge(:lists => lists))
+    end
+
     get '/entity_list/:type/:id' do
       type = params.delete "type"
       visualization_parameters = get_visualization_parameters(params)
 
-      cache("Entity List:", :params => params, :type => type, :visualization_params => visualization_parameters, :user => user) do
-        entity_list_render(type, params.merge(visualization_parameters))
+      cache_type = params.delete(:_cache_type) || params.delete("_cache_type") || :sync
+      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
+        else
+          entity_list_render(type, params.merge(visualization_parameters))
+        end
       end
     end
 
+    post '/entity_list/:type/copy/:id' do
+      type = params.delete "type"
+
+      list = Entity::REST.load_list(type, params[:id], user)
+      Entity::REST.save_list(type, params[:new_id], list, user)
+
+      redirect "/entity_list/#{ type }/#{params[:new_id]}"
+    end
+
+    post '/entity_list/:type/add/:id' do
+      type = params.delete "type"
+
+      list = Entity::REST.load_list(type, params[:id], user)
+      other_list = Entity::REST.load_list(type, params[:other_list], user)
+      list.concat other_list
+      Entity::REST.save_list(type, params[:id], list, user)
+
+      redirect back
+    end
+
+    post '/entity_list/:type/remove/:id' do
+      type = params.delete "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)
+
+      redirect back
+    end
+
+    post '/entity_list/:type/subset/:id' do
+      type = params.delete "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)
+
+      redirect back
+    end
+
+    get '/entity_list/:type/edit/:id' do
+      type = params[:type]
+      visualization_parameters = get_visualization_parameters(params)
+
+      workflow = WorkflowREST.workflows.last
+      id = params[:id]
+      list = Entity::REST.load_list(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)
+      redirect '/'
+    end
+ 
+            # entities
+    delete '/entity_list/:type/:entity/:id' do
+      id = params[:id]
+      Log.debug "Deleting #{params[:entity] } from #{params[:id]}"
+
+      list = Entity::REST.load_list(params[:type], id, user)
+
+      list.delete params[:entity]
+
+      Entity::REST.save_list(params[: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")
+
+      info = {}
+      params.each{|k,v| info[k] = begin JSON.parse(v) rescue v end}
+      entity = Annotated.load_tsv_values(entity, [[info.to_json]], "JSON")
+
+      list = Entity::REST.load_list(type, id, user)
+
+
+      different = entity.info.select{|k,v| not v.nil? and v != list_info[k]}.any?
+
+
+      new = list.collect{|e| e} if different
+      new.delete entity
+      new << entity
+      Entity::REST.save_list(type, id, new, user)
+
+      redirect back
+    end
+  
+    #{{{ entity_action
+
     get '/entity_action/:type/:action/:entity' do
       type = params.delete "type"
       action = params.delete "action" 
 
       visualization_parameters = get_visualization_parameters(params)
 
-      cache("Entity Action [#{action}]:", :params => params, :type => type, :action => action, :visualization_params => visualization_parameters, :user => user) do
+      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))
       end
     end
@@ -124,7 +265,10 @@ module WorkflowREST
 
       visualization_parameters = get_visualization_parameters(params)
 
-      cache("Entity List Action [#{action}]:", :params => params, :type => type, :action => action, :visualization_params => visualization_parameters, :user => user) do
+      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))
       end
     end
@@ -518,5 +662,4 @@ module WorkflowREST
     end
 
   end
-
 end

data/lib/rbbt/workflow/rest/auth.rb

@@ -38,15 +38,15 @@ module Sinatra
       end
 
       app.post '/login' do
-        Log.debug "Loggin: #{params.inspect}"
-        if options.users.include? params[:user] and options.users[params[:user]] == params[:pass]
-          Log.debug "Loggin Successful"
+        Log.debug "Login: #{params.inspect}"
+        if settings.users.include? params[:user] and settings.users[params[:user]] == params[:pass]
+          Log.debug "Login Successful"
           session[:authorized] = true
           session[:user] = params[:user]
           session[:context] = nil
           redirect '/'
         else
-          Log.debug "Loggin Failed"
+          Log.debug "Login Failed"
           session[:authorized] = false
           session[:user] = nil
           session[:context] = nil

data/lib/rbbt/workflow/rest/entity.rb

@@ -1,7 +1,16 @@
 module Entity
 
   module REST
-    LIST_REPO = {}
+    include RbbtHTMLHelpers
+
+    def rbbt_id
+      return "" unless self.annotations.include? :format and String === self.format
+      ([self.format.downcase, self] * "=").gsub(/[^\w]/,'_')
+    end
+
+    class << self
+      attr_accessor :list_repo
+    end
 
     def link(text = nil, url = nil, options = {})
       return nil if self.nil?
@@ -19,7 +28,7 @@ module Entity
         text = self if text.nil? or text == :literal or text.to_s.strip.empty?
 
         klass = options[:class]
-        klass ||= "entity " + (self.respond_to?(:format)? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " ")
+        klass ||= "entity " + ((self.respond_to?(:format) and not self.format.nil?) ? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " ")
 
         klass += " " << options[:extra_classes] || "" if options.include? :extra_classes
         klass += " " << html_class if self.respond_to? :html_class
@@ -38,31 +47,102 @@ module Entity
                 end
 
         annotations_str = params.collect{|k,v| [k, CGI.escape(v.to_s)] * "="} * "&"
-        "<a class='#{klass}' href='#{url + (annotations_str.any? ? '?' + annotations_str : "")}'>#{text}</a>"
+        "<a class='#{klass}' #{rbbt_id} href='#{url + (annotations_str.any? ? '?' + annotations_str : "")}'>#{text}</a>"
       end
     end
 
-    def self.save_list(id, list)
-      Entity::REST::LIST_REPO[id] = list
+    def self.list_file(type, id, user = nil)
+      type = type.split(":").first if not type.nil? and type.index ':'
+      if production?
+        if user.nil?
+          File.join(Entity.entity_list_cache, type.to_s, id)
+        else
+          File.join(Entity.entity_list_cache, user.to_s, type.to_s, id)
+        end
+      else
+        nil
+      end
     end
 
-    def self.load_list(id)
-      Entity::REST::LIST_REPO[id]
+    def self.list_files(user)
+      if production?
+        lists = {}
+        Dir.glob(File.join(Entity.entity_list_cache, user, '*', '*')).each do |file|
+          user, type, list = file.split("/")[-3..-1]
+          lists[type] ||= []
+          lists[type] << list
+        end
+        lists
+      else
+        {}
+      end
+    end
+
+    def self.load_list(type, id, user = nil)
+      if production?
+        path = list_file(type, id, user)
+        path = list_file(type, id, :public) unless File.exists? path
+        path = list_file(type, id) unless File.exists? path
+
+        Misc.lock path do
+          Annotated.load_tsv TSV.open(path)
+        end
+      else
+        @@list_cache ||= {}
+        @@list_cache[id]
+      end
+    end
+
+    def self.save_list(type, id, list, user = nil)
+      if production?
+        path = list_file(type, id, user)
+
+        Misc.lock path do
+          begin
+            Open.write(path, Annotated.tsv(list, :all).to_s)
+          rescue
+            FileUtils.rm path if File.exists? path
+            raise $!
+          end
+        end
+      else
+        @@list_cache ||= {}
+        @@list_cache[id] = list
+      end
+    end
+
+
+    def self.delete_list(type, id, user)
+      if production?
+        path = list_file(type, id, user)
+        "This list does not belong to #{ user }: #{[type, id] * ": "}" unless File.exists? path
+        Misc.lock path do
+          begin
+            FileUtils.rm path if File.exists? path
+          rescue
+            raise $!
+          end
+        end
+      else
+        @@list_cache.delete(id) if @@list_cache and @@list_cache.include? id
+      end
     end
 
     def list_link(text = nil, id = nil, options = {})
-      text = self.length if text.nil? or (String === text and text.strip.empty?)
+      reuse = options.delete("reuse") || options.delete(:reuse)
+      text = self.length if text.nil? or (String === text and text.strip.empty?) or text == :length
 
       id ||= options[:id] || Misc.digest((self * "|").inspect)
 
-      Entity::REST.save_list(id, self)
 
-      klass = self.respond_to?(:format)? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " "
+      klass = (self.respond_to?(:format) and not self.format.nil?) ? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " "
 
       klass += " " << options[:extra_classes] if options.include? :extra_classes
       klass += " " << html_class if self.respond_to? :html_class
 
-      type = self.respond_to?(:format)? annotation_types.last.to_s + ":" + self.format : annotation_types.last.to_s
+      type = (self.respond_to?(:format) and not self.format.nil?) ? annotation_types.last.to_s + ":" + self.format : annotation_types.last.to_s
+
+      Entity::REST.save_list(annotation_types.last.to_s, id, self) unless reuse
 
       annotations_str = self.info.reject{|k,v| [:annotation_types, :format].include?(k)}.collect{|k,v| [k, CGI.escape(v.to_s)] * "="} * "&"
 
@@ -71,32 +151,50 @@ module Entity
 
     def action_link(action, text = nil, inputs = {})
       options = inputs.delete(:link_options) || {}
+      options[:extra_classes] = inputs.delete(:extra_classes) || inputs.delete("extra_class") if inputs.include?(:extra_classes) or inputs.include?("extra_classes")
       clean_inputs = {}
       inputs.each do |k, v| 
         clean_inputs[k] = Array === v ? v * "," : v
       end
-      link(text, nil, options.merge(:extra_params => clean_inputs, :action => action))
+
+      klass ||= "entity_action " + (self.respond_to?(:format)? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " ")
+      klass += " " << options[:extra_classes] if options.include? :extra_classes
+      klass += " " << html_class if self.respond_to? :html_class
+
+      link(text, nil, options.merge(:extra_params => clean_inputs, :action => action, :class => klass))
     end
 
     def list_action_link(action, text = nil, id = nil, options = {})
+      reuse = options.delete("reuse") || options.delete(:reuse)
+
       text = self.length if text.nil? or (String === text and text.strip.empty?)
       id ||= options[:id] || Misc.digest((self * "|").inspect)
 
       text = id if text == :id
 
-      Entity::REST.save_list(id, self)
 
-      klass = self.respond_to?(:format)? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " "
+      klass = (self.respond_to?(:format) and not self.format.nil?) ? self.format.gsub(/\s/,'_') : annotation_types.collect{|t| t.to_s.gsub(/\s/,'_')} * " "
 
-      klass += " " << options[:extra_classes] if options.include? :extra_classes
+      klass += " " << options.delete(:extra_classes) if options.include? :extra_classes
       klass += " " << html_class if self.respond_to? :html_class
 
-      type = self.respond_to?(:format)? annotation_types.last.to_s + ":" + self.format : annotation_types.last.to_s
+      type = (self.respond_to?(:format) and not self.format.nil?)? annotation_types.last.to_s + ":" + self.format : annotation_types.last.to_s
 
-      annotations_str = self.info.reject{|k,v| [:annotation_types, :format].include?(k)}.collect{|k,v| [k, CGI.escape(v.to_s)] * "="} * "&"
+      Entity::REST.save_list(annotation_types.last.to_s, id, self) unless reuse
+
+      annotations_str = self.info.merge(options).reject{|k,v| [:annotation_types, :format].include?(k)}.collect{|k,v| [k, CGI.escape(v.to_s)] * "="} * "&"
 
       "<a class='entity_list_action #{klass}' href='#{File.join("/entity_list_action", type, action, id) + (annotations_str.any? ? '?' + annotations_str : "")}'>#{text}</a>"
     end
 
+    def html_table(fields, workflow = nil, field_names = nil)
+      raise "Must be an Array to produce html table: #{self.inspect}" unless Array === self
+      rows = self.collect{|entity|
+        [entity.id, entity.tsv_values(fields)]
+      }
+
+      workflow_partial('partials/_table', workflow = nil, :rows => rows, :header => field_names || fields)
+    end
+
   end
 end

data/lib/rbbt/workflow/rest/helpers.rb

@@ -35,4 +35,53 @@ module RbbtHTMLHelpers
       str
     end
   end
+
+  def input(type, name, options = {})
+    id, hide, value, klass, default, description, select_options = Misc.process_options options, :id, :hide, :value, :class, :default, :description, :select_options
+    str = "<div class='form_input' id='#{ id }'>"
+
+    if hide
+      str << "<input #{"id='#{ id }'" if id} type='hidden' name='#{ name }' #{"class='#{ klass }'" if klass} #{"value='#{ value }'" if value}/>" << '</div>' << "\n"
+      return str
+    end
+
+    case type
+    when :select
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}</label>" << "\n"
+      str << "<select id='input_#{id}_true' name='#{ name }'>" << "\n"
+      if not select_options.nil?
+        select_options.each do |option|
+          option, option_name = option if Array === option
+          option_name ||= option
+          str << "<option id='input_#{id}_option_#{option.to_s}' value='#{option.to_s}' #{option.to_s == value.to_s ? "selected=selected" : "" }>" << option_name.to_s << "</option>" << "\n"
+        end
+      end
+      str << "</select>" << "\n"
+      str << "</div>"
+      str
+    when :boolean
+      not_value = ! value
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}</label>" << "\n"
+      str << "<input type='radio' id='input_#{id}_true' name='#{ name }' value='true' #{"checked='true'" if value}>" << "\n"
+      str << "<label type='radio_option radio_true' for='input_#{id}_true' name='#{ name }'>true</label>" << "\n"
+      str << "<input type='radio' id='input_#{id}_false' name='#{ name }' value='false' #{"checked='false'" if not value}>" << "\n"
+      str << "<label type='radio_option radio_false' for='input_#{id}_false' name='#{ name }'>false</label>" << "\n"
+      str << "</div>"
+      str
+    when :string, :float, :integer
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}#{": <span class='input_default'>(Default: #{ default })</span>" if default}</label>" << "\n"
+      str << "<input #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} #{"id='#{ id }'" if id} name='#{ name }' #{"value='#{ value }'" if value}/>" << "\n"
+      str << "</div>"
+      str
+    when :tsv, :array, :text
+      str << "<label #{"for='#{ id }" if id}'><span class='input_name'>#{ name }</span>#{": <span class='input_description'>#{ description }</span>" if description}#{": <span class='input_default'>(Default: #{ default })</span>" if default}</label>" << "\n"
+      str << "<p>"
+      str << "<input type='file' #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} #{"id='input_#{ id }_tsv_file'" if id} name='#{ name }_param_file' #{"value='#{ value }'" if value}/>" << "\n"
+      str << "<span class='tsv_textarea_note note'>(or use text area bellow)</span>"
+      str << "</p>"
+      str << "<textarea #{"class='#{klass ? klass : "#{ name } #{ type }" }'"} name='#{ name }' #{"id='input_#{ id }'" if id}></textarea>"
+      str << "</div>"
+      str
+    end
+  end
 end