rbbt-rest 1.7.19 → 1.7.20

data/share/views/public/js/rbbt.page.js

@@ -49,7 +49,6 @@ rbbt.page.list = function(){
    var parts = rbbt.page.path_parts()
    var type = parts[1]
    var list = parts[3]
-   console.log(list)
    return new EntityList({id: list, type: type})
  } 
 

data/share/views/public/js/rbbt.plots/rbbt.plots.aes.js

@@ -0,0 +1,195 @@
+rbbt.plots.aes = {}
+
+rbbt.plots.aes.map_aesthetic = function(aes, mapper, map_obj){
+  switch(mapper){
+    case false:
+    case undefined:
+    case null:
+    case 'direct':
+      return aes;
+    case 'gradient':
+      if (map_obj){
+        if (typeof aes == 'object')
+          aes = aes.map(function(value){ return map_obj[value] })
+        else
+          aes = map_obj[aes]
+      }
+      return get_gradient(aes, 'red', 'green')
+    case 'sign-gradient':
+      if (map_obj){
+        if (typeof aes == 'object')
+          aes = aes.map(function(value){ return map_obj[value] })
+        else
+          aes = map_obj[aes]
+      }
+      return get_sign_gradient(aes, 'red', 'grey', 'green')
+    case 'map':
+      if (typeof aes == 'object')
+        return aes.map(function(value){ return map_obj[value.toString()] })
+     else
+        return map_obj[aes]
+    case 'function':
+      var res = []
+      if (typeof aes == 'object')
+        for (i in aes) res.push(map_obj(aes[i]))
+      else
+        res = map_obj(aes)
+      return res
+    case 'list_function':
+      return map_obj(aes)
+  }
+}
+rbbt.plots.aes.get_properties = function(list, rules){
+  if (undefined === rules) rules == []
+  if (undefined === list.properties) list.properties = {}
+  var promises = []
+  forArray(rules, function(rule){
+    var name = rule.name
+    var extract = rule.extract
+    if (typeof extract == 'string'){ 
+      eval('extract='+extract)
+    }
+    
+    if (rule.entity_type && rule.entity_type != list.type) return 
+
+    if (rule.info){
+      var property = rule.property
+      var deferred = m.deferred()
+      var entry = rule.info
+      if (undefined === name) name = entry
+
+      var value = list.info[entry]
+      if (undefined === value && entry == 'type') value = list.type
+      if (undefined === value && entry == 'code') value = list.codes
+
+      deferred.resolve(value)
+      promise = deferred.promise
+    }
+
+    if (rule.value){
+      var property = rule.property
+      var deferred = m.deferred()
+      deferred.resolve(rule.value)
+      promise = deferred.promise
+    }
+
+    if (rule.property){
+      var property = rule.property
+      var args = rule.args
+      if (undefined === name) name = property
+      promise = rbbt.entity_array.property(list.codes, list.type, list.info, property, args)
+      if (extract){ promise = promise.then(function(res){ return res.map(extract)}) }
+    }
+
+    if (rule.workflow){
+      var workflow = rule.workflow
+      var task = rule.task
+      var args = rule.args
+      if (undefined === name) name = task
+      promise = rbbt.job(workflow, task, args, true)
+      if (extract){ promise = promise.then(function(res){ return list.codes.map(function(code){return extract.call(null, res, code)}) } )}
+    }
+
+    if (rule.parents || rule.children){
+      var kb_type 
+      var database
+      if (rule.parents){
+        kb_type = 'parent'
+        var database = rule.parents
+        if (undefined === name) name = database
+
+        promise = rbbt.entity_array.parents(list.codes, list.type, database)
+      }else{
+        kb_type = 'children'
+        var database = rule.children
+        if (undefined === name) name = database
+
+        promise = rbbt.entity_array.children(list.codes, list.type, database)
+      }
+
+      if (rule.field){
+        promise = m.sync([promise,rbbt.knowledge_base.database_info(database)]).then(function(res){
+          var data = res[0]
+          var db_info = res[1]
+          var fields = db_info.fields
+          var field_pos = fields.indexOf(rule.field)
+
+          if (field_pos < 0){
+            var msg = "Field not found: " + rule.field + ". Options: " + fields.join(", ")
+            throw new Error(msg)
+          }
+
+          var matches = {}
+          forHash(data, function(key, values){
+            var source = values[0]
+            var target = values[1]
+            if (matches[source] === undefined) matches[source] = {}
+            matches[source][target] = values[field_pos+2]
+          })
+          return matches
+        })
+      }else{
+        promise = promise.then(function(data){
+          var matches = {}
+          forHash(data, function(key, values){
+            var source,target
+            if (rule.parents){ 
+              source = values[1]
+              target = values[0]
+            }else{
+              source = values[0]
+              target = values[1]
+            }
+            if (matches[source] === undefined) matches[source] = {}
+            matches[source][target] = values.slice(2) 
+          })
+          return matches
+        })
+      }
+
+      if (extract){
+        promise = promise.then(function(matches){
+          return list.codes.map(function(e){ 
+            return extract.call(null, matches, e)
+          })
+        })
+      }
+      else{
+        promise = promise.then(function(matches){
+          return list.codes.map(function(e){ return matches[e] })
+        })
+      }
+    }
+
+    promises.push(promise.then(function(res){list.properties[name] = res}))
+  })
+
+  return m.sync(promises)
+}
+
+rbbt.plots.aes.set_aes = function(list, aes_rules){
+  if (undefined === list.aes) list.aes = {}
+  forArray(aes_rules, function(rule){
+
+    if (rule.entity_type && rule.entity_type != list.type) return 
+
+
+    var name = rule.name
+    var aes = rule.aes
+    var mapper = rule.mapper
+    var mapper_obj = rule.mapper_obj
+    var property = list.properties[name]
+
+    if (rule.value){
+      list.aes[aes] = rule.value
+      return 
+    }
+
+    if (undefined === property && list.info[name]) property = list.info[name]
+    if (undefined === property && name == 'type') property = list.type
+    if (undefined === property && name == 'code') property = list.codes
+    if (undefined === property) return
+
+    list.aes[aes] = rbbt.plots.aes.map_aesthetic(property, mapper, mapper_obj)
+  })
+}

data/share/views/public/js/rbbt.plots/rbbt.plots.basic.js

@@ -0,0 +1,2 @@
+rbbt.plots = {}
+

data/share/views/public/js/rbbt.plots/rbbt.plots.graph.adapters.js

@@ -0,0 +1,216 @@
+rbbt.plots.graph.build_d3 = function(graph_model){
+
+  var model = rbbt.plots.graph.consolidate(graph_model)
+
+  var node_index = {}
+  for (i=0; i< model.nodes.length; i++) node_index[model.nodes[i].code] = i
+
+  for (i=0; i< model.edges.length; i++){
+    var edge = model.edges[i]
+    edge.source = node_index[edge.source]
+    edge.target = node_index[edge.target]
+  }
+
+  model.links = model.edges
+  model.edges = undefined
+  model.node_index = node_index
+
+  return model
+}
+
+rbbt.plots.graph.build_cytoscape = function(graph_model){
+  var model = rbbt.plots.graph.consolidate(graph_model)
+
+  var dataSchema = {nodes: [], edges:[]}
+
+  var node_vars = {}
+  for (i in model.nodes){
+    for (p in model.nodes[i]){
+      if (undefined !== model.nodes[i][p])
+        node_vars[p] = typeof model.nodes[i][p]
+    }
+  }
+  for (p in node_vars){
+    dataSchema.nodes.push({name: p, type: node_vars[p]})
+  }
+
+  node_vars = {}
+  for (i in model.edges){
+    for (p in model.edges[i]){
+      if (undefined !== model.edges[i][p])
+        node_vars[p] = typeof model.edges[i][p]
+    }
+  }
+  for (p in node_vars){
+    dataSchema.edges.push({name: p, type: node_vars[p]})
+  }
+
+  var cy_model = {}
+  cy_model.dataSchema = dataSchema
+  cy_model.data = model
+
+  return cy_model
+}
+
+rbbt.plots.graph.build_cytoscapejs = function(graph_model){
+  var model = rbbt.plots.graph.consolidate(graph_model)
+
+  var nodes = []
+  forArray(model.nodes, function(node){
+    var clean = clean_hash(node)
+    if (undefined === clean.id) clean.id = clean.code
+    nodes.push({data: clean})
+  })
+
+  var edges = []
+  forArray(model.edges, function(edge){
+    var clean = clean_hash(edge)
+    if (undefined === clean.id) clean.id = clean.code
+    edges.push({data: clean})
+  })
+
+  var cy_model = {}
+  cy_model.elements = {nodes: nodes, edges: edges}
+
+  return cy_model
+}
+
+rbbt.plots.graph.view_cytoscapejs = function(graph_model, elem, style, layout, extra){
+
+  var default_style = [ // the stylesheet for the graph
+  {
+    selector: 'node',
+    style: { 'background-color': 'blue', 'label': 'data(id)' }
+  },
+  
+  {
+    selector: 'node[label]',
+    style: {'label': 'data(label)' }
+  },
+
+  {
+    selector: 'node[color]',
+    style: { 'background-color': 'data(color)' }
+  },
+
+  {
+    selector: 'edge',
+    style: { 'width': 1, 'line-color': 'grey', 'target-arrow-color': '#ccc', 'target-arrow-shape': 'triangle' }
+  },
+  {
+    selector: 'edge[color]',
+    style: { 'line-color': 'data(color)'}
+  }
+  ]
+
+  var default_layout = { name: 'cose' }
+
+  if (undefined === style) style = default_style
+  if (undefined === layout) layout = default_layout
+
+  var deferred = m.deferred()
+
+  console.log(graph_model)
+  rbbt.plots.graph.update(graph_model).then(function(updated_model){
+    var cy_model = rbbt.plots.graph.build_cytoscapejs(updated_model)
+
+    require_js(['/plugins/cytoscapejs/cytoscape.js'], function(){
+      var cy_params = {
+        container: elem,
+        elements: cy_model.elements,
+        style: style,
+        layout: layout,
+      }
+
+      if (undefined !== extra) forHash(extra,function(k,v){ cy_params[k,v] })
+
+      var cy = cytoscape(cy_params)
+
+      deferred.resolve(cy)
+    })
+  },rbbt.exception.report)
+
+  return deferred.promise
+}
+
+rbbt.plots.graph.view_cytoscape = function(graph_model, elem, style, layout, extra){
+  rbbt.plots.graph.update(graph_model).then(function(updated_model){
+    var dataset = rbbt.plots.graph.build_cytoscape(updated_model)
+
+    require_js(['/js/cytoscape/js/src/AC_OETags.js', '/js/cytoscape/js/src/cytoscapeweb.js', '/js/cytoscape'], function(){
+      var tool = $('#plot').cytoscape_tool({
+        knowledge_base: 'user',
+        namespace: 'Hsa/feb2014',
+        entities: dataset.nodes,
+        network: dataset,
+        aesthetics: {},
+
+        node_click: function(event){
+          var target = event.target;
+
+          for (var i in target.data){
+            var variable_name = i;
+            var variable_value = target.data[i];
+          }
+
+          for (var i in target.data) {
+            var variable_name = i;
+            var variable_value = target.data[i];
+          }
+
+          var url = target.data.url;
+
+          rbbt.modal.controller.show_url(url)
+          return(false)
+        },
+
+        edge_click: function(event){
+          var target = event.target;
+          for (var i in target.data){
+            var variable_name = i;
+            var variable_value = target.data[i];
+          }
+
+          var pair = [target.data.source, target.data.target].join("~")
+          tool.cytoscape_tool('show_info', "user", target.data.database, pair);
+
+          return(false)
+        }
+
+      });
+
+      require_js('/js/controls/context_menu', function(){
+        cytoscape_context_menu(tool)
+      })
+
+      require_js('/js/controls/placement', function(){
+        cytoscape_placement(tool)
+      })
+
+      require_js('/js/controls/save', function(){
+        cytoscape_save(tool)
+      })
+      tool.cytoscape_tool('draw');
+    })
+  })
+}
+
+rbbt.plots.graph.view_d3js_graph = function(graph_model, elem, node_obj){
+  rbbt.plots.graph.update(graph_model).then(function(updated_model){
+    console.log(updated_model)
+    var dataset = rbbt.plots.graph.build_d3(updated_model)
+
+    if (undefined === node_obj){
+      node_obj = function(node){
+        var g = node.append('g').attr('class', function(d){ if(undefined === d.shape) d.shape = 'circle'; return "node " + d.shape})
+        d3.selectAll('.node.circle').append('circle').attr('fill',function(d){return d.color}).attr('r', 20)
+        d3.selectAll('.node.rect').append('rect').attr('fill',function(d){return d.color}).attr('width', 40).attr('height', 40).attr('x', -20).attr('y', -20)
+        g.append('text').attr('x',-20).attr('y',-20).text(function(d){if(undefined === d.label) d.label = d.code; return d.label}).fill('black')
+        return g
+      }
+    }
+
+    rbbt.plots.d3js_graph(dataset, elem, node_obj)
+
+  })
+}

data/share/views/public/js/rbbt.plots/rbbt.plots.graph.js

@@ -0,0 +1,138 @@
+rbbt.plots.graph = {}
+
+rbbt.plots.graph.get_entities = function(graph_model){
+
+  if (undefined !== graph_model.entities) return graph_model
+
+  var entities = {}
+  forHash(graph_model.associations, function(database, list){
+    var source_type = list.source_type
+    var source_entities = {}
+    source_entities.codes = unique(list.info.source)
+    source_entities.info = list.source_info
+    source_entities.type = list.source_type
+
+    var target_type = list.target_type
+    var target_entities = {}
+    target_entities.codes = unique(list.info.target)
+    target_entities.info = list.target_info
+    target_entities.type = list.target_type
+
+    if (entities[source_entities.type])
+      entities[source_entities.type].codes = unique(entities[source_entities.type].codes.concat(source_entities.codes))
+    else
+      entities[source_entities.type] = source_entities
+
+    if (entities[target_entities.type])
+      entities[target_entities.type].codes = unique(entities[target_entities.type].codes.concat(target_entities.codes))
+    else
+      entities[target_entities.type] = target_entities
+  })
+
+  graph_model.entities = entities
+
+  return graph_model
+}
+
+rbbt.plots.graph.update_aes = function(graph_model){
+  var data_promises = []
+  forHash(graph_model.entities, function(type, list){
+    data_promises.push(
+
+      rbbt.plots.aes.get_properties(list, graph_model.rules).
+        then(function(){
+      rbbt.plots.aes.set_aes(list, graph_model.aes_rules)
+        })
+
+    )
+  })
+
+  forHash(graph_model.associations, function(db, list){
+    data_promises.push(
+
+      rbbt.plots.aes.get_properties(list, graph_model.edge_rules).
+        then(function(){
+      rbbt.plots.aes.set_aes(list, graph_model.edge_aes_rules)
+        })
+
+    )
+  })
+  return m.sync(data_promises).then(function(){return graph_model})
+}
+
+//{{{ CONSOLIDATION
+
+rbbt.plots.graph.consolidate_list = function(list){
+  var nodes = []
+
+  var codes = list.codes
+  var info = list.info
+  var aes = list.aes
+  var properties = list.properties
+
+  for (i in codes){
+    var node = {}
+    node.code = codes[i]
+    node.id = codes[i]
+    forHash(aes, function(name, values){
+      var value
+      if (typeof values == 'object') value = values[i]
+        else value = values
+          node[name]  = value
+    })
+    nodes.push(node)
+  }
+
+  return nodes
+}
+
+rbbt.plots.graph.consolidate_associations = function(list){
+  var nodes = []
+
+  var codes = list.codes
+  var info = list.info
+  var aes = list.aes
+  var properties = list.properties
+  var values = list.properties
+
+  for (i in codes){
+    var node = {}
+    node.code = codes[i]
+    forHash(aes, function(name, values){
+      var value
+      if (typeof values == 'object') value = values[i]
+        else value = values
+          node[name]  = value
+    })
+    nodes.push(node)
+  }
+
+  return nodes
+}
+
+rbbt.plots.graph.consolidate = function(graph_model){
+  var model = {}
+
+  var nodes = []
+
+  forHash(graph_model.entities, function(type, list){
+    var list_nodes = rbbt.plots.graph.consolidate_list(list)
+    for (i in list_nodes) nodes.push(list_nodes[i])
+  })
+
+  var edges = []
+  forHash(graph_model.associations, function(database, list){
+    var list_edges = rbbt.plots.graph.consolidate_associations(list,database)
+    for (i in list_edges) edges.push(list_edges[i])
+  })
+
+  model.nodes = nodes
+  model.edges = edges
+
+  return model
+}
+
+rbbt.plots.graph.update = function(graph_model){
+  graph_model = rbbt.plots.graph.get_entities(graph_model)
+  return rbbt.plots.graph.update_aes(graph_model)
+}