kgrift 1.3.108

data/KGrift/knewton_grifts/goal_grifts.rb

@@ -0,0 +1,203 @@
+require 'set'
+
+def get_goals learning_instance_id, params={}
+  Log.info "Getting all goals for learning instance: '#{learning_instance_id}' , with params '#{params.keys.join(', ')}'"
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/goals?" + URI.encode_www_form(params)
+end
+
+def get_goal learning_instance_id, goal_id
+  Log.info "Getting goal '#{goal_id}' for learning instance '#{learning_instance_id}'"
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}"
+end
+alias :get_single_goal :get_goal
+
+def get_realized_goal learning_instance_id, goal_id
+  Log.info "Getting realized goal '#{goal_id}' for learning instance '#{learning_instance_id}'"
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/realized-goals/#{goal_id}"
+end
+
+def validate_goal goal_id, learning_instance_id
+  Log.info "Validating a goal with goal id #{goal_id} on learning_instance #{learning_instance_id}"
+  kapi.get "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}/validate"
+end
+
+
+# Updating a goal does a full over-writing PUT.  Anything not included from the original goal
+# will be removed
+def update_goal learning_instance_id, goal_id, overrides={}, params={}
+  Log.info "Updating a goal for learning instance: '#{learning_instance_id}' and goal: '#{goal_id}' , with params '#{params.keys.join(', ')}'"
+  kapi.put "/v0/learning-instances/#{learning_instance_id}/goals/#{goal_id}?" + URI.encode_www_form(params), overrides
+end
+
+#create goal will wait twice.
+#First it will wait for the goal post to succeed
+#We need to do this, because a learning instance must write to kraphs
+#before we can make a goal off it, and that can take up to 60 seconds
+#Second it will wait for the goal to write.  Again kraphs asynchronously
+#writes goals, so we have to wait for that to happen before our tests can depend on it
+def create_goal learning_instance_id, overrides={}, params={}
+  Log.info "Creating a goal for learning instance: '#{learning_instance_id}' , with params '#{params.keys.join(', ')}'"
+  kapi.post "/v0/learning-instances/#{learning_instance_id}/goals?" + URI.encode_www_form(params), {
+    'target_modules' => [],
+      'recommendable_modules' => [],
+      'max_recommendation_size' => 3,
+      'start_date' => '2013-04-12T17:00:00.000Z'
+  }.merge(overrides)
+end
+
+def create_goal_non_waiting learning_instance_id, overrides={}, params={}
+  Log.info "Creating a goal for learning instance: '#{learning_instance_id}' , with params '#{params.keys.join(', ')}'"
+  kapi.post "/v0/learning-instances/#{learning_instance_id}/goals?" + URI.encode_www_form(params), {
+    'target_modules' => [],
+      'recommendable_modules' => [],
+      'max_recommendation_size' => 3,
+      'start_date' => '2013-04-12T17:00:00.000Z'
+  }.merge(overrides)
+end
+
+
+#this convenience method builds out the module lists from a graph
+#which avoids building complicated payloads in tests that are not
+# explicitly concerned with the complicated bits of the payload
+def create_goal_from_graph graph, learning_instance_id=nil, overrides={}, params={}
+  Log.info "Making a goal with random modules picked from a graph"
+  nodes = graph['nodes'].clone
+  Log.info nodes
+
+  module_ids = Set.new find_all_assessment_atoms(graph)
+  modules = nodes.select{|n| module_ids.member?n['id']}
+
+  Log.info modules
+  payload_overrides = {
+    'target_modules' => [
+      { "module_id" => modules.shift['id'],
+        "target_score" => 1.0,
+        "target_date" => days_from_now(1)
+    },
+    { "module_id" => modules.shift['id'],
+      "target_score" => 1.0,
+      "target_date" => days_from_now(2)
+    },
+    ],
+    'recommendable_modules' => modules.map{|m| { "module_id" => m['id'] } }[0,5],
+    'max_recommendation_size' => 2,
+  }.merge(overrides)
+
+  unless learning_instance_id
+    learning_instance_id = create_learning_instance 'graph_id' => graph['id']
+  end
+
+  create_goal learning_instance_id, payload_overrides, params
+end
+
+def create_goals_from_graph_yaml yaml_file_path
+  #Load yaml file
+  file_data = YAML.load_file(yaml_file_path)
+
+  #Cache graph locally
+  graph = get_graph_and_cache_it file_data['graph_id']
+
+  #Loop over all goals
+  output = Hash.new()
+  goals = file_data['goals']
+  goals.each do |goal_name, goal_def|
+    Log.info "Processing goal: #{goal_name}"
+
+    #Initialize output variable
+    output[goal_name] = Hash.new()
+
+    #Extract input parameters
+    target_module_ids = goal_def.fetch('target_module_ids',[])
+    recommendable_taxon_ids = goal_def.fetch('recommendable_taxon_ids',[])
+    recommendable_module_ids = goal_def.fetch('recommendable_module_ids',[])
+
+    #Define target module
+    if target_module_ids.empty?
+      target_module_ids = []
+      target_concept = find_prerequisite_concept graph
+      target_module_ids << find_associated_assessing_bndl(graph,target_concept)
+      target_module_ids << find_associated_assessing_atom(graph,target_concept)
+    end
+    Log.info "Target modules: #{target_module_ids}"
+
+    #Construct target modules hash
+    target_modules = []
+    target_modules = target_module_ids.map do |mod|
+      {
+        'module_id' => mod,
+        'target_date' => days_from_now(30),
+        'target_score' => 0.9,
+      }
+    end
+
+    #Define recommendable taxons and modules
+    Log.info "Setting recommendable modules"
+    rec_modules = recommendable_taxon_ids.map{ |taxon_id| {'taxon_id' => taxon_id} }
+    rec_modules += recommendable_module_ids.map{ |module_id| {'module_id' => module_id} }
+    if rec_modules.empty?
+      Log.info "No recommendable modules or taxons define; setting all modules as recommendable"
+      all_modules = find_all_recommendable_module_ids graph
+      rec_modules = all_modules.map{|m| {'module_id' => m}}
+    end
+
+    #Define goal object
+    goal_obj = {
+      'target_modules' => target_modules,
+      'max_recommendation_size' => (rec_modules.length < 3 ? rec_modules.length : 3),
+      'start_date' => datetime,
+      'recommendable_modules' => rec_modules,
+    }
+    Log.info "Creating goal with parameters #{goal_obj}"
+
+    #Create learning instance and goal
+    output[goal_name]['learning_instance_id'] = (create_learning_instance 'graph_id' => graph['id'])['id']
+    output[goal_name]['goal_id'] = (create_goal output[goal_name]['learning_instance_id'], goal_obj)['id']
+  end
+
+  #Output learning instance IDs and goal IDs to screen/file
+  output_file = File.join(File.dirname(yaml_file_path), File.basename(yaml_file_path, '.yml')+'_output'+'.yml')
+  File.open(output_file, 'w') {|f| f.write(output.to_yaml) }
+end
+
+# GROUP GOALS
+
+def create_group_goal learning_instance_id, params
+  Log.debug "Creating a group goal for learning instance: #{learning_instance_id}"
+  kapi.post "/v0/learning-instances/#{learning_instance_id}/group-goals", params
+end
+
+def update_group_goal learning_instance_id, goal_id, params
+  Log.debug "Updating a group goal for learning instance: #{learning_instance_id} goal #{goal_id}"
+  kapi.put "/v0/learning-instances/#{learning_instance_id}/group-goals/#{goal_id}", params
+end
+
+def create_random_valid_group_goal_object graph, options={}
+
+  options = {
+    target_type: :lref,
+    num_targets: 1,
+  }.merge(options)
+
+  # find all all the recommendable modules that have a name
+  potential_target_values = if options[:target_type].to_sym == :mref
+                              modules = find_all_assessment_modules_full(graph)
+                              # pull the mref eids out of the nodes
+                              modules.map{|m| m['temp_id'] =~ /^.ref-/ ? m['temp_id'] : "mref-#{m['temp_id']}"  }
+                            else
+                              los = find_all_learning_objectives(graph)
+                              los.map{|lo| lo['temp_id'] =~ /^.ref-/ ? lo['temp_id'] : "lref-#{lo['temp_id']}" }
+                            end
+
+  # pick a random set of target modules/learning objectives
+  targets = potential_target_values.shuffle[0...options[:num_targets]]
+
+  # make the goal object
+  goal_obj = {
+    "name" => "TestGroupGoal #{random_string}",
+    "targets" =>  targets,
+    "scope" => {},
+  }
+
+  goal_obj
+end
+

data/KGrift/knewton_grifts/graph_and_taxonomy_grifts.rb

@@ -0,0 +1,136 @@
+
+
+# New get taxonomies endpoint
+def get_taxonomies_for_graph (graph_id, overrides={})
+  Log.info "Getting taxonomies for graph id: '#{graph_id}'."
+  resp = nil
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    resp = kapi.get "/v0/taxonomies/graph-id/#{graph_id}"
+  end
+  resp
+end
+
+# get get a taxonomy by graph id + taxonomy id
+def get_taxonomy_for_graph (graph_id, taxonomy_id, overrides={})
+  Log.info "Getting taxonomy '#{taxonomy_id}' for graph id: '#{graph_id}'."
+  ts = get_taxonomies_for_graph graph_id
+  ts.find{ |t| t['id'] == taxonomy_id}
+end
+
+def get_graph_summary id, overrides={}
+  Log.info "getting graph by id: '#{id}'"
+  kapi.get "/v0/graphs/#{id}/summary"
+end
+
+def get_all_graphs overrides={}
+  Log.info "Getting all graphs with params '#{overrides.keys.join(', ')}'"
+  kapi.get '/v0/graphs?' + URI.encode_www_form(overrides)
+end
+
+def get_all_graphs_for_partner partner_id, overrides={}
+  overrides.merge!'partner_id' => partner_id
+  get_all_graphs overrides
+end
+
+def get_internal_graph_id partner_id, graph_name
+  graphs = get_all_graphs_for_partner partner_id
+  graph = graphs.find{|g| g['name'] == graph_name}
+  raise "Couldn't find graph for partner #{partner_id} with name #{graph_name}" unless graph
+  graph['name']
+end
+
+def translate_graph_gref_into_internal_id partner_id, gref
+  partner_graphs = get_all_graphs_for_partner partner_id
+  wanted_name = gref.sub(/^gref-/,'')
+  found = partner_graphs.find{|g| g['name'] == wanted_name}
+  raise "No such graph with name '#{wanted_name}' for partner: #{partner_id}" unless found
+  found['id']
+end
+
+def get_graph id, overrides={}
+  Log.info "getting graph by id: '#{id}'"
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.get "/v0/graphs/#{id}", timeout: 18000
+  end
+end
+
+GRAPH_CACHE_DIR = File.join(Dir.home,'.kgrift/graph_cache')
+def get_graph_and_cache_it id, overrides={}
+  FileUtils::mkdir_p GRAPH_CACHE_DIR
+  cache_file_name = File.join(GRAPH_CACHE_DIR, id + '.json')
+  if File.exist?(cache_file_name)
+    return JSON.parse(IO.read(cache_file_name))
+  else
+    graph = get_graph id, overrides
+    File.open(cache_file_name, 'w'){|f| f.write JSON.pretty_generate(graph)}
+    return graph
+  end
+end
+
+def get_graphs_map_of_assessing_bundles_for_post_requisite_concepts_and_cache_it graph, overrides={}
+  id = graph['id']
+  FileUtils::mkdir_p GRAPH_CACHE_DIR
+  cache_file_name = File.join(GRAPH_CACHE_DIR, id + '_postreqs_to_assessing_bndls.json')
+  if File.exist?(cache_file_name)
+    return JSON.parse(IO.read(cache_file_name))
+  else
+    assessing_bundles_for_postreq = get_map_of_assessing_bundles_for_post_requisite_concepts graph
+    File.open(cache_file_name, 'w'){|f| f.write JSON.pretty_generate(assessing_bundles_for_postreq)}
+    return assessing_bundles_for_postreq
+  end
+end
+
+def graph_yaml id
+  graph = get_graph_and_cache_it id
+  File.open("#{id}.yml", 'w') {|f| f.write graph.to_yaml}
+end
+
+def get_graph_by_name name, overrides={}
+  Log.info "getting graph by name: '#{name}'"
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.get "/v0/graphs?name=#{URI.encode name}"
+  end
+end
+
+def graph_exists? id, overrides={}
+  Log.info "Checking if graph exists with ID: #{id}"
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.head "/v0/graphs/#{id}"
+  end
+  return true
+rescue RequestException => e
+  return false if e.code == 404
+  raise e
+end
+
+def do_as_knewton_partner use_current_user=false, &blk
+  if use_current_user
+    yield
+  else
+    as_account :knerd do
+      yield
+    end
+  end
+end
+
+
+def get_node graph_id, node_id, overrides={}
+  Log.info "Getting a node from graph: #{graph_id} -> #{node_id}"
+  kapi.get "/v0/graphs/#{graph_id}/nodes/#{node_id}"
+end
+
+def get_learning_objective_node graph_id, learning_objective_id, overrides={}
+  Log.info "Getting a learning objective node from graph: #{graph_id} -> #{learning_objective_id}"
+  kapi.get "/v0/graphs/#{graph_id}/learningObjectives/#{learning_objective_id}"
+end
+
+def get_edge graph_id, start_node_id, end_node_id, edge_type, overrides={}
+  Log.info "Getting an edge from graph: #{graph_id} -> #{start_node_id}_#{edge_type}_#{end_node_id}"
+  kapi.get "/v0/graphs/#{graph_id}/edges/#{start_node_id}_#{edge_type}_#{end_node_id}"
+end
+
+def get_edges graph_id, node_id, overrides={}
+  Log.info "Getting a edges from graph #{graph_id}, starting from #{node_id}"
+  kapi.get "/v0/graphs/#{graph_id}/nodes/#{node_id}/edges"
+end
+

data/KGrift/knewton_grifts/graph_create_grifts.rb

@@ -0,0 +1,34 @@
+"""
+This file is all about creating graphs and taxonomies.
+
+This is based on the POST /v0/book_and_taxonomies endpoint that Bivins implements.
+This allows for making a graph and taxonomies in a way that is not Klique.
+This is mostly intended for use by Bivins localmode integration tests.
+
+Generally most tests should not use the create_book_and_taxonomies method, instead
+they should use the KnewtonGraph object that allows for making test graphs through
+Klique, from spreadsheets.
+
+"""
+
+# SUPPORTED / CURRENT METHODS
+
+def create_book_and_taxonomies book_and_taxonomies, partner_id=nil
+  params = partner_id.nil? ? {} : { 'partner_id' => partner_id }
+  kapi.post '/v0/graphs/book_and_taxonomies?' + URI.encode_www_form(params),
+   book_and_taxonomies
+end
+
+def basic_book_and_taxonomies_post_object unicode=false
+  file_base = unicode ? 'unicode_test_graph_definition.yml' : 'basic_test_graph_definition.yml'
+  graph_definition_file = File.join(File.dirname(File.dirname(__FILE__)), 'internal_test_graphs', file_base)
+  obj = YAML.load_file graph_definition_file
+  obj['graph']['name'] = "#{obj['graph']['name']}_#{random_string}"
+  obj
+end
+
+def create_basic_book_and_taxonomies partner_id=nil, unicode=false
+  response = create_book_and_taxonomies basic_book_and_taxonomies_post_object(unicode), partner_id
+  # return the graph id
+  response['objectId']
+end

data/KGrift/knewton_grifts/graph_query_grifts.rb

@@ -0,0 +1,448 @@
+
+def get_node_by_id graph, node_id
+  graph['nodes'].find{|n| n['id'] == node_id}
+end
+
+def get_node_by_name graph, node_name
+  graph['nodes'].find{|n| n['name'] == node_name}
+end
+
+def get_nodes_by_name_expr graph, node_name_expr
+  graph['nodes'].select{|n| n['name'] =~ node_name_expr}
+end
+
+def find_random_atom_id graph
+  graph['nodes'].select{|n| n['type']=='module' and n['subtype']=='atom'}.sample['id']
+end
+
+# this will ensure module_id is an internal id
+def internalize_module_id graph, module_id
+  if module_id =~ /^mref-/
+    found = graph['nodes'].find{|n| n['temp_id'] == module_id}
+    raise "No module with mref '#{module_id}' in graph: #{graph['id']}" unless found
+    found['id']
+  else
+    module_id
+  end
+end
+
+#returns one of concept, atom, bndl, pool, unknown
+def get_node_type graph, module_id
+  node = get_node_by_id graph, module_id
+  node_type = case node['type']
+              when 'concept'
+                'concept'
+              when 'module'
+                node['subtype']
+              else
+                raise "Unable to determine node type for node: #{module_id} - graph: #{graph['id']}"
+              end
+  Log.debug "get_node_type: type: #{node_type} - node: #{module_id} - graph: #{graph['id']}"
+  return node_type
+end
+
+def find_all_recommendable_modules graph
+  graph['nodes'].select{|node| node['type']=='module' and (node['subtype']=='atom' or node['subtype']=='bndl')}
+end
+
+def find_all_recommendable_module_ids graph
+  find_all_recommendable_modules(graph).map{|node| node['id']}
+end
+
+def find_all_learning_objectives graph
+  graph['nodes'].select{|n| n['type'] == 'learning_objective'}
+end
+
+def find_all_module_ids_contained_by_learning_objective_list graph, lref_list
+  all_learning_objectives = find_all_learning_objectives(graph)
+  expected_mrefs = lref_list.map do |lref|
+    lo_id = all_learning_objectives.find{|lo| lo['temp_id'] == lref[5..-1]}['id']
+    atom_ids = find_atoms_contained_by_bndl @graph, lo_id
+    atom_mrefs = atom_ids.map{|iid| get_node_by_id(@graph, iid)['temp_id']}
+    atom_mrefs
+  end.flatten.uniq
+  expected_mrefs
+end
+
+def find_all_taxon_ids graph
+  nodes = graph['nodes'].select{|node| node['type']=='module' and (node['subtype']=='atom' or node['subtype']=='bndl')}
+  nodes.map{|node| node['taxon_ids']}.flatten.uniq
+end
+
+def find_all_assessment_atoms graph
+  pool_ids = Set.new(graph['edges'].select{|edge| edge['type']=='assessed_by'}.map{|edge| edge['end']})
+  graph['edges'].select{|edge| pool_ids.include? edge['start']}.map{|edge| edge['end']}.uniq
+end
+
+def find_all_assessment_modules graph
+  @assess_mods_cache ||= Hash.new do |cache, graph|
+    cache[graph] = begin
+                     Log.debug "Calculating assessment modules for graph: #{graph['id']}"
+                     pool_ids = graph['nodes'].select{|n| n['subtype']=='pool'}.map{|n| n['id']}
+                     assessment_pool_ids = graph['edges'].select{|e| e['type']=='assessed_by' and
+                                                                 pool_ids.include?(e['end'])
+                     }.map{|e| e['end']}
+                     assessment_atom_ids = graph['edges'].select{|e| assessment_pool_ids.include?(e['start']) and
+                                                                 e['type']=='contains'
+                     }.map{|e| e['end']}.uniq
+                     assessment_bndl_ids = graph['edges'].select{|e| assessment_atom_ids.include?(e['end']) and not
+                                                                 pool_ids.include?(e['start']) and
+                                                                   e['type']=='contains'
+                     }.map{|e| e['start']}.uniq
+                     # we need to filter out learning_objectives... so we do this
+                     assessment_bndl_ids.select!{|nid| node = graph['nodes'].find{|n| n['id'] == nid}; node['subtype'] == 'bndl'}
+                     assessment_atom_ids+assessment_bndl_ids
+                   end
+  end
+  @assess_mods_cache[graph]
+end
+
+# above find_all_assessment_modules returns just modules IDs
+# this method returns full module objects
+def find_all_assessment_modules_full graph
+  mod_ids = find_all_assessment_modules(graph)
+  mod_ids.map{|mid| graph['nodes'].find{|n| n['id'] == mid}}
+end
+
+def find_all_instructional_modules graph
+  pool_ids = graph['nodes'].select{|n| n['subtype']=='pool'}.map{|n| n['id']}
+  instructional_pool_ids = graph['edges'].select{|e| e['type']=='taught_by' and
+                                                 pool_ids.include?(e['end'])
+  }.map{|e| e['end']}
+  instructional_atom_ids = graph['edges'].select{|e| instructional_pool_ids.include?(e['start']) and
+                                                 e['type']=='contains'
+  }.map{|e| e['end']}.uniq
+  instructional_bndl_ids = graph['edges'].select{|e| instructional_atom_ids.include?(e['end']) and not
+                                                 pool_ids.include?(e['start']) and
+                                                   e['type']=='contains'
+  }.map{|e| e['start']}.uniq
+  return instructional_atom_ids+instructional_bndl_ids
+end
+
+def find_atoms_contained_by_bndl graph, bndl_id
+  graph['edges'].
+    select{|e| e['start'] == bndl_id and e['type'] == 'contains' }.
+    map{|e| e['end']}
+end
+
+def find_all_bndl_ids graph
+  graph['nodes'].select{|node| node['type']=='module' and node['subtype']=='bndl'}.map{|node| node['id']}
+end
+
+def find_all_concept_ids graph
+  graph['nodes'].select{|node| node['type'] == 'concept'}.map{|node| node['id']}
+end
+
+def find_all_atom_ids graph
+  graph['nodes'].select{|node| node['subtype']=='atom' }.map{|node| node['id']}
+end
+
+def find_random_concept graph
+  graph['nodes'].select{|n| n['type']=='concept'}.sample['id']
+end
+
+
+def find_concept_by_name graph, name
+  graph['nodes'].select{|node| node['type'] == 'concept'}.select{|node| node['name'] == name}.first
+end
+
+def find_next_concept graph, concept_id
+  prereq_edges = graph['edges'].select{|e| e['type'] == 'prerequisite' and e['start'] == concept_id}
+  return nil if prereq_edges.empty?
+  prereq_edges.first['end']
+end
+
+def find_post_requisite_concepts graph
+  Log.debug "finding post requisites for graph: #{graph['id']}"
+  #get all concepts
+  concepts = graph['nodes'].select{|n| n['type'] == 'concept'}
+
+  #filter it to concepts for which no edge starts with them,
+  #but have edges that end with them
+  pre_req_edges = graph['edges'].select{|e| e['type']=='prerequisite'}
+  post_req_concepts = concepts.select{|c| !pre_req_edges.any?{|e| e['start']==c['id']} and pre_req_edges.any?{|e| e['end']==c['id']} }
+  post_req_concepts.map{|c| c['id']}
+end
+
+def find_post_requisite_concept graph
+  #pick a random one and return it
+  find_post_requisite_concepts(graph).sample
+end
+
+def find_prerequisite_concept graph
+  #get all concepts
+  concepts = graph['nodes'].select{|n| n['type'] == 'concept'}
+
+  #filter it to concepts for which no edge starts with them,
+  #but have edges that end with them
+  pre_req_edges = graph['edges'].select{|e| e['type']=='prerequisite'}
+  post_req_concepts = concepts.select{|c|
+    pre_req_edges.any?{|e| e['start']==c['id']} and
+      !pre_req_edges.any?{|e| e['end']==c['id']} }
+  #pick a random one and return it
+  post_req_concepts.sample['id']
+end
+
+def find_associated_assessing_bndls graph, concept_id
+  Log.debug "Finding assessing bundles for concept #{concept_id}"
+  #find the 'assessed_by' edge
+  assessed_by_pool_id = graph['edges'].find{|e| e['type']=='assessed_by' and e['start'] == concept_id}['end']
+
+  #find everything contained by the assessed by edge
+  assessing_atom_ids= graph['edges'].select{|e| e['type']=='contains' and e['start'] == assessed_by_pool_id}.map{|e| e['end']}
+
+  #find all the edges that contain an assessing atom
+  edges_that_end_in_assessing_atom = graph['edges'].select{|e| e['type'] == 'contains' and assessing_atom_ids.include?(e['end'])}
+
+  assessing_bndls = edges_that_end_in_assessing_atom.map{|e| e['start']}.select{|nid| graph['nodes'].find{|n| n['id']==nid}['subtype']=='bndl'}
+
+  assessing_bndls.uniq!
+  Log.debug "Concept: #{concept_id} has assessing bundles: #{assessing_bndls.join(', ')}"
+  assessing_bndls
+end
+
+def find_associated_assessing_bndl graph, concept_id
+  find_associated_assessing_bndls(graph, concept_id).sample
+end
+
+def get_map_of_assessing_bundles_for_post_requisite_concepts graph
+  Log.debug "Building map of all assessing bundles for all postrequisite concepts in  #{graph['id']}"
+  assessing_bundles_for_postreq = {}
+  postreqs = find_post_requisite_concepts graph
+  postreqs.each do |postreq|
+    bundles = find_associated_assessing_bndls graph, postreq
+    assessing_bundles_for_postreq[postreq] = bundles
+  end
+  Log.debug "Done building map of all assessing bundles for all postrequisite concepts in  #{graph['id']}"
+  assessing_bundles_for_postreq
+end
+
+# Returns a list containing all concepts that are attached through assessed_by or taught_by pools.
+# takes atoms or bundles.  when given a bundle it looks up all the atoms contained and looks for
+#
+def find_associated_concept_ids graph, module_id
+
+  atom_ids = case(get_node_by_id(graph, module_id)['subtype'])
+             when 'atom'
+               [module_id]
+             when 'bndl'
+               find_atoms_contained_by_bndl(graph, module_id)
+             else
+               raise "Not an atom or bndl"
+             end
+
+  # Get the pools that contain the atom
+  pool_ids = graph['edges'].select{|e| e['type'] == 'contains' and atom_ids.include?(e['end'])}.map{|e| e['start']}.uniq
+
+  # Some edges here may be nil, so make the map to start node a separate step to avoid errors.
+  edges_to_concepts = pool_ids.map{|p| graph['edges'].select{|e| (e['type'] == 'assessed_by' or e['type'] == 'taught_by') and e['end'] == p}}.flatten.uniq
+
+  # Get the concepts that are assessed or taught by the pools -- ignore any pools that didn't map to concepts
+  concepts = edges_to_concepts.select{|p| p != nil}.map{|p| p['start']}.uniq
+end
+
+#Gets full information for the first concept an atom is a member of
+def find_associated_concept graph, atom_id
+  get_node_by_id graph, (find_associated_concept_ids graph, atom_id).first
+end
+
+def find_associated_atoms graph, concept_id
+  Log.info "Finding all atoms for concept #{concept_id}"
+  (find_associated_assessing_atoms graph, concept_id).concat(find_associated_instructional_atoms graph, concept_id)
+end
+
+def find_associated_assessing_atoms graph, concept_id
+  Log.info "Finding assessing atoms for concept #{concept_id}"
+
+  #find the 'assessed_by' edge
+  assessed_by_pool_id = graph['edges'].find{|e| e['type']=='assessed_by' and e['start'] == concept_id}['end']
+
+  #find everything contained by the assessed by edge
+  assessing_atom_ids= graph['edges'].select{|e| e['type']=='contains' and e['start'] == assessed_by_pool_id}.map{|e| e['end']}.uniq
+end
+
+def find_associated_assessing_atom graph, concept_id
+  (find_associated_assessing_atoms graph, concept_id).sample
+end
+
+def find_associated_instructional_bndls graph, concept_id
+  Log.info "Finding instructional bundles for concept #{concept_id}"
+
+  #find the 'taught_by' edge
+  taught_by_pool_id = graph['edges'].find{|e| e['type']=='taught_by' and e['start'] == concept_id}['end']
+
+  #find everything contained by the taught by edge
+  teaching_atom_ids= graph['edges'].select{|e| e['type']=='contains' and e['start'] == taught_by_pool_id}.map{|e| e['end']}
+
+  #find all the edges that contain an teaching atom
+  edges_that_end_in_teaching_atom = graph['edges'].select{|e| e['type'] == 'contains' and teaching_atom_ids.include?(e['end'])}
+
+  teaching_bndls = edges_that_end_in_teaching_atom.map{|e| e['start']}.select{|nid| graph['nodes'].find{|n| n['id']==nid}['subtype']=='bndl'}
+
+  teaching_bndls.uniq
+end
+
+def find_associated_instructional_atoms graph, concept_id
+  Log.info "Finding instructional atoms for concept #{concept_id}"
+
+  #find the 'taught_by' edge
+  taught_by_pool_id = graph['edges'].find{|e| e['type']=='taught_by' and e['start'] == concept_id}['end']
+
+  #find everything contained by the taught by edge
+  teaching_atom_ids= graph['edges'].select{|e| e['type']=='contains' and e['start'] == taught_by_pool_id}.map{|e| e['end']}.uniq
+end
+
+
+#return ['instructional'] or ['assessment'] or ['instructional','assessment']
+def get_content_types graph, module_id
+
+  node_type = get_node_type graph, module_id
+  atom_ids = case node_type
+             when 'atom'
+               [module_id]
+             when 'bndl'
+               graph['edges'].select{|e| e['type'] == 'contains' and e['start'] == module_id}.map{|e| e['end']}
+             end
+
+  bndl_ids = find_all_bndl_ids graph
+
+  pool_ids = graph['edges'].select{|e| e['type'] == 'contains' and atom_ids.include?(e['end']) }.map{|e| e['start']}.select{|n| not bndl_ids.include?(n)}
+
+  types = []
+  if graph['edges'].any?{|e| e['type'] == 'assessed_by' and pool_ids.include?(e['end'])}
+    types << 'assessment'
+  end
+  if graph['edges'].any?{|e| e['type'] == 'taught_by' and pool_ids.include?(e['end'])}
+    types << 'instructional'
+  end
+
+  types
+end
+
+
+def build_out_paths paths, path_so_far, prereq_edges
+  cur_concept = path_so_far.last
+  next_concepts = prereq_edges.select{|e| e['start'] == cur_concept}.map{|e| e['end']}
+  if next_concepts.empty?
+    paths << path_so_far
+  else
+    next_concepts.each{|c| build_out_paths paths, path_so_far + [c], prereq_edges}
+  end
+end
+
+def get_graph_concept_paths graph
+  #find the starting concepts
+  prereq_edges = graph['edges'].select{|e| e['type'] == 'prerequisite'}
+  concept_ids = graph['nodes'].select{|n| n['type'] == 'concept'}.map{|n| n['id']}
+  starts = concept_ids.select{|c| not prereq_edges.any?{|e| e['end'] == c}}
+
+  #recursively build out the paths to ending concepts
+  paths = []
+  starts.each { |start| build_out_paths paths, [start], prereq_edges}
+  paths
+end
+
+def get_longest_concept_path graph
+  paths = get_graph_concept_paths graph
+  paths.group_by(&:size).max.last.last
+
+end
+
+def find_node_by_ref_label graph, label
+  nodes = graph['nodes'].select{ |n| n['temp_id'].split('-')[1] == label }
+  nodes[0]['temp_id']
+end
+
+def humanize_recommendation graph, rec
+  rec['module_names'] = rec['module_ids'].map{ |mid|
+    graph['nodes'].find{|n| n['id'] == mid}['name']
+  }
+  rec
+end
+
+def get_node_with_concept_and_content_type graph, module_id
+  node = get_node_by_id graph, module_id
+  content_type = get_content_types graph, module_id
+  if content_type.length == 1
+    content_type = content_type.first
+  end
+  concept = find_associated_concept graph, module_id
+  node['concept'] = concept
+  node['content_type'] = content_type
+
+  node
+end
+
+#helper function for finding a concept's child atoms and bundles
+def get_associated_modules_by_type graph, concept_id, content_type
+  #find associated pool (prioritize assessment pools if multiple)
+  pool_id = nil
+  pools = []
+  graph['edges'].select{|e| e['start']==concept_id}.each do |e|
+    if e['type']==content_type and
+      !graph['nodes'].select{|n| n['id']==e['end'] and n['subtype']=='bndl'}.any?
+      pool_id = e['end']
+    end
+    pools << e['end']
+  end
+
+  #find associated atoms and bundles
+  atoms = graph['edges'].select{|e| e['start']==pool_id}.map{|e| e['end']}
+  bndls = graph['edges'].select{|e| atoms.include?(e['end']) and
+                                !pools.include?(e['start'])
+  }.map{|e| e['start']}.uniq
+  return atoms + bndls
+end
+
+def get_taxon_eids_from_taxonomy taxonomy
+  # find the taxon eids... which is a bit harder than modules
+  #tref_prefix = "tref-#{taxonomy['name']}:"
+  tref_prefix = "tref-"
+  taxon_eids = taxonomy['taxons'].map do |taxon|
+    tref_suffix = taxon['name']
+    while taxon['parent_id']
+      taxon = taxonomy['taxons'].find{|t| t['id'] == taxon['parent_id']}
+      tref_suffix = "#{taxon['name']}|#{tref_suffix}"
+    end
+    tref_prefix + tref_suffix
+  end
+  taxon_eids
+end
+
+
+# batch_event_payload is a helper grift for making the body
+# for POST /v0/registrations/{reg id}/batch-events
+# it takes a list of module IDs (iid or eid)
+# it figures out for each module if a graded or ungraded event is appropriate
+# and makes the list of events accordingly
+def create_batch_events_payload graph, module_ids
+
+  internal_module_ids = module_ids.map {|mid| internalize_module_id graph, mid }
+
+  module_content_types = internal_module_ids.map{|iid| get_content_types graph, iid }
+
+  batch_events_payload = []
+
+  module_ids.each_with_index do |mod_id, i|
+    event = {
+      'module_id' => mod_id,
+      'duration' => 12345,
+      'is_complete' => true,
+      'interaction_end_time' => days_from_now(-1),
+    }
+    if module_content_types[i] == ['instructional']
+      event.merge!({
+        'type' => 'ungraded-events',
+      })
+    else
+      event.merge!({
+        'type' => 'graded-events',
+        'score' => 1.0,
+        'is_correct' => true,
+      })
+    end
+    batch_events_payload << event
+  end
+
+  batch_events_payload
+end