kgrift 1.3.108

data/KGrift/knewton_grifts/content_eid_grifts.rb

@@ -0,0 +1,41 @@
+def get_module_iid graph, eid
+  graph['nodes'].select{|n| n['temp_id'] and n['temp_id']==(graph['name']+':'+eid)}.first['id']
+end
+
+def get_full_taxon_path taxonomy, taxon_id, path=''
+  taxon = taxonomy['taxons'].select{|t| t['id']==taxon_id}.first
+  if taxon['parent_id']
+    get_full_taxon_path(taxonomy, taxon['parent_id']) + '|' + taxon['name'] + path
+  else
+    taxon['name'] + path
+  end
+end
+
+def construct_taxon_eid_map taxonomies
+  taxons = []
+  taxonomies.each do |taxonomy|
+    taxonomy_name = taxonomy['name']
+    taxonomy['taxons'].each do |taxon|
+      taxons << {
+        'iid' => taxon['id'],
+        'eid' => 'tref-' + taxonomy_name + ":" + get_full_taxon_path(taxonomy, taxon['id'])
+      }
+    end
+  end
+  taxons
+end
+
+def get_taxon_eid_to_iid_map_for_graph graph_id
+  #create LI, get taxonomies, and cleanup
+  dummy_li = create_learning_instance 'graph_id' => graph_id
+  taxonomies = get_referenced_taxonomies dummy_li['id']
+  delete_learning_instance dummy_li['id']
+  #construct map list
+  map_list = construct_taxon_eid_map taxonomies
+  #return hashmap
+  map = {}
+  map_list.each do |taxon|
+    map[taxon['eid']] = taxon['iid']
+  end
+  map
+end

data/KGrift/knewton_grifts/copy_grifts.rb

@@ -0,0 +1,151 @@
+GRIFTER_INSTANCES_BY_ENVIRONMENT = {}
+
+def get_grifter_instance_for_env env
+  if env
+    unless GRIFTER_INSTANCES_BY_ENVIRONMENT[env]
+      new_grifter_config = {environment: env}
+      new_grifter_config[:config_file] = grifter_configuration[:config_file] if grifter_configuration[:config_file]
+      GRIFTER_INSTANCES_BY_ENVIRONMENT[env] = Grifter.new new_grifter_config
+    end
+    GRIFTER_INSTANCES_BY_ENVIRONMENT[env]
+  else
+    self
+  end
+end
+
+
+def copy_learning_instance options={}
+  options = {
+    'goal_target_score_override' => nil,
+    'goal_days_from_now_override' => nil,
+    'force_metrics' => false
+  }.merge(options)
+
+  source_environment = get_grifter_instance_for_env options['source_environment']
+
+  original_learning_instance = nil
+  original_partner_id = nil
+  source_environment.instance_eval do
+    set_account :knerd
+    # we'll get the learning instance in this special way so we can also get the partner id of it
+    # in case the graph_id is an eid, we'll need the partner id to translate it into an iid
+    original_learning_instance = get_learning_instance options['learning_instance_id'], additional_headers: { 'X-Include-Partner-Id' => 'true' }
+    original_partner_id = kapi.last_response['X-Partner-Id']
+  end
+
+  # figure out the graph id we want to use in our new learning instance
+  graph_id = if options['graph_id']
+    options['graph_id']
+  elsif original_learning_instance['graph_id'] =~ /^gref-/
+    source_environment.instance_eval do
+      set_account :knerd
+      translate_graph_gref_into_internal_id original_partner_id, original_learning_instance['graph_id']
+    end
+  else
+    original_learning_instance['graph_id']
+  end
+
+  new_learning_instance = create_learning_instance 'name' => "test learning instance for interesting goals made #{Time.now}",
+    'graph_id' => graph_id
+
+  if options['goal_id']
+    goal_id_list = [ options['goal_id'] ]
+  elsif options['goal_id_list']
+    goal_id_list = options['goal_id_list']
+  end
+
+  if goal_id_list
+    new_goal_list = []
+    for goal_id in goal_id_list
+      goal_to_copy = source_environment.instance_eval do
+                get_goal original_learning_instance['id'], goal_id
+      end
+      # the API will create a new id for this new goal
+      goal_to_copy.delete('id')
+      # if this is an MTMPTS/LO goal, delete the target_ids too
+      for target_module in goal_to_copy['target_modules']
+        if target_module.include?('target_id')
+            target_module.delete('target_id')
+        end
+      end
+      if options['goal_target_score_override']
+        goal_to_copy['target_modules'].each {|tm| tm['target_score'] = options['goal_target_score_override'] }
+      end
+      if options['goal_days_from_now_override']
+        goal_target_date_override = days_from_now options['goal_days_from_now_override']
+        goal_to_copy['target_modules'].each {|tm| tm['target_date'] = goal_target_date_override }
+      end
+      if options['force_metrics']
+        goal_to_copy['metrics_enabled'] = true
+      end
+      new_goal = create_goal new_learning_instance['id'], goal_to_copy
+      new_goal_list << new_goal
+    end
+  else
+    new_goal_list = [ nil ]  # previously-- if goal_id wasn't passed in, goal => nil was returned
+  end
+  if new_goal_list.length > 1
+  {
+    'learning_instance' => new_learning_instance,
+    'goal_list' => new_goal_list,
+  }
+  else
+  {
+    'learning_instance' => new_learning_instance,
+    'goal' => new_goal_list[0],
+  }
+  end
+end
+
+
+def prepare_graph_copy graph_id, options={}
+
+  options = {
+    remove_taxon_ids: true
+  }
+
+  graph = get_graph_and_cache_it graph_id
+
+  Log.info "Copying graph: #{graph['id']}"
+
+  orig_id = graph.delete 'id'
+  graph['name'] = "Copy of #{orig_id}(#{graph['name']})"
+
+
+  id_to_temp_id = {}
+  graph['nodes'].each_with_index do |node, i|
+    temp_id = get_mref_eid(i.to_s)
+    node['temp_id'] = temp_id
+    id_to_temp_id[node.delete('id')] = temp_id
+
+    node['name'] = "#{node['subtype']}-#{random_string(8)}" unless node['name']
+
+    if options[:remove_taxon_ids]
+      node.delete 'taxon_ids'
+    end
+
+  end
+
+  graph['edges'].each do |edge|
+    edge['start_temp_id'] = id_to_temp_id[edge.delete('start')]
+    edge['end_temp_id'] = id_to_temp_id[edge.delete('end')]
+  end
+
+  filename = "copy_#{orig_id}.json"
+  Log.info "Writing #{filename}"
+  File.open filename, 'w' do |f|
+    f.write(JSON.pretty_generate(graph))
+  end
+
+end
+
+
+def post_graph_from_file filename
+  graph_obj = YAML.load_file filename
+
+  p graph_obj['name']
+  graph = create_graph graph_obj
+
+  Log.info "Created graph: #{graph['id']}"
+  graph['id']
+end

data/KGrift/knewton_grifts/deprecated_graph_and_taxonomy_grifts.rb

@@ -0,0 +1,353 @@
+# DEPRECATED METHODS
+# DELETE THESE ONCE OLYMPIK MIGRATION IS DONE
+# TE-1225
+
+
+def create_graph overrides={}, params={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Creating graph"
+  response = nil
+  temp_id_one = get_mref_eid('1')
+  temp_id_two = get_mref_eid('2')
+  do_as_knewton_partner overrides.delete('use_current_user') do
+      response = kapi.post '/v0/graphs?' + URI.encode_www_form(params), {
+          'name' => random_graph_name,
+          'nodes' => [
+            {'temp_id' => temp_id_one, 'type' => 'concept', 'name' => 'n1', 'subtype' => nil },
+            {'temp_id' => temp_id_two, 'type' => 'concept', 'name' => 'n2', 'subtype' => nil },
+          ],
+          'edges' =>
+            [
+              {
+                'start_temp_id' => temp_id_one,
+                'end_temp_id' => temp_id_two,
+                'type' => 'prerequisite',
+                'custom_data' => {'custom_key' => 'custom_value'},
+              }
+            ]
+        }.merge(overrides)
+  end
+  Log.info "Waiting for titanik to create graph"
+  wait_for_code 200 do
+    get_graph_and_cache_it response["id"]
+  end
+  response
+end
+
+def create_basic_concept_graph uri_params={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  concept1 = get_mref_eid("concept1")
+
+  bndl1 = get_mref_eid("bndl1")
+  bndl2 = get_mref_eid("bndl2")
+  bndl3 = get_mref_eid("bndl3")
+
+  atom1 = get_mref_eid("atom1")
+  atom2 = get_mref_eid("atom2")
+  atom3 = get_mref_eid("atom3")
+  atom4 = get_mref_eid("atom4")
+
+  pool1 = get_mref_eid("pool1")
+  pool2 = get_mref_eid("pool2")
+
+  name = 'Single Concept Graph ' + random_string
+  graph_params = {
+    'name' => name,
+    'temp_id' => 'mref-'+name,
+    'nodes' => [
+      { 'temp_id' => concept1, 'type' => 'concept', 'subtype' => nil,    'name' => 'Transgressive Placemaking'          },
+
+      { 'temp_id' => bndl1,    'type' => 'module',  'subtype' => 'bndl', 'name' => 'History of Tresspassing'            },
+      { 'temp_id' => bndl2,    'type' => 'module',  'subtype' => 'bndl', 'name' => 'Ethics of Tresspassing'             },
+      { 'temp_id' => bndl3,    'type' => 'module',  'subtype' => 'bndl', 'name' => 'Laws of Tresspassing'               },
+
+      { 'temp_id' => atom1,    'type' => 'module',  'subtype' => 'atom', 'name' => 'Emergence of private property'      },
+      { 'temp_id' => atom2,    'type' => 'module',  'subtype' => 'atom', 'name' => 'Quiz #1 - Tresspasing concepts'     },
+      { 'temp_id' => atom3,    'type' => 'module',  'subtype' => 'atom', 'name' => 'Natural rights vs Legal righhts'    },
+      { 'temp_id' => atom4,    'type' => 'module',  'subtype' => 'atom', 'name' => 'Quiz #2 - Tresspassing Laws'        },
+
+      { 'temp_id' => pool1,    'type' => 'module',  'subtype' => 'pool', 'name' => 'secret pool 1'        },
+      { 'temp_id' => pool2,    'type' => 'module',  'subtype' => 'pool', 'name' => 'secret pool 2'        },
+    ],
+    'edges' => [
+      #one pool teaches, one pool assesses
+      { 'start_temp_id' => concept1, 'end_temp_id' => pool1, 'type' => 'taught_by'     },
+      { 'start_temp_id' => concept1, 'end_temp_id' => pool2, 'type' => 'assessed_by'   },
+
+      { 'start_temp_id' => pool1, 'end_temp_id' => atom1, 'type' => 'contains'   },
+      { 'start_temp_id' => pool1, 'end_temp_id' => atom2, 'type' => 'contains'   },
+      { 'start_temp_id' => pool1, 'end_temp_id' => atom3, 'type' => 'contains'   },
+
+      { 'start_temp_id' => pool2, 'end_temp_id' => atom2, 'type' => 'contains'   },
+      { 'start_temp_id' => pool2, 'end_temp_id' => atom3, 'type' => 'contains'   },
+      { 'start_temp_id' => pool2, 'end_temp_id' => atom4, 'type' => 'contains'   },
+
+      { 'start_temp_id' => bndl1, 'end_temp_id' => atom1, 'type' => 'contains'   },
+      { 'start_temp_id' => bndl1, 'end_temp_id' => atom2, 'type' => 'contains'   },
+
+      { 'start_temp_id' => bndl2, 'end_temp_id' => atom2, 'type' => 'contains'   },
+      { 'start_temp_id' => bndl2, 'end_temp_id' => atom3, 'type' => 'contains'   },
+
+      { 'start_temp_id' => bndl3, 'end_temp_id' => atom3, 'type' => 'contains'   },
+      { 'start_temp_id' => bndl3, 'end_temp_id' => atom4, 'type' => 'contains'   },
+    ],
+  }
+
+
+  create_graph graph_params, uri_params
+end
+
+
+# DEPRECATED
+# this is the old graph_generator_grifts.rb
+
+
+def create_test_graph options={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  graph_obj = generate_test_graph_object options
+  graph = create_graph graph_obj
+
+  graph['id']
+end
+
+#we used to have a real create_random_graph method
+#it didnt make realistic graphs
+#now it makes realistic graphs
+def create_random_graph options={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  graph_obj = generate_test_graph_object options
+  graph = create_graph graph_obj
+  graph
+end
+
+def generate_test_graph_object options={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  options = {
+    concept_depth: 3,
+    num_starting_concepts: 1,
+    num_post_requisites_per_concept: 2,
+  }.merge(options)
+
+  graph = {
+    'name' => "Generated test graph #{datetime}",
+    'nodes' => [],
+    'edges' => [],
+  }
+
+  concept_num = 1
+  prereqconcepts = []
+  options[:num_starting_concepts].times do
+    new_concept_tempid = add_concept_to_graph graph, [], options.merge({concept_num: concept_num})
+    prereqconcepts << new_concept_tempid
+    concept_num += 1
+  end
+
+  (options[:concept_depth] - 1).times do
+    new_concepts = []
+    prereqconcepts.each do |prereqconcept|
+      options[:num_post_requisites_per_concept].times do
+        new_concept_tempid = add_concept_to_graph graph, [prereqconcept], options.merge({concept_num: concept_num})
+        new_concepts << new_concept_tempid
+        concept_num += 1
+      end
+    end
+    prereqconcepts = new_concepts
+  end
+
+  return graph
+end
+
+def add_concept_to_graph graph, prereq_temp_ids=[], options={}
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  options = {
+    num_instructional_bundles_per_concept: 1,
+    num_atoms_per_instructional_bundle: 1,
+    num_assessment_bundles_per_concept: 1,
+    num_atoms_per_assessment_bundle: 3,
+    concept_num: random_string(8),
+  }.merge(options)
+
+  concept_name = get_mref_eid("concept-#{options[:concept_num]}")
+  assessing_pool_name = get_mref_eid('assessing_pool-'+concept_name)
+  teaching_pool_name = get_mref_eid('teaching_pool-'+concept_name)
+
+  concept = {
+    'nodes' => [
+      { 'temp_id' => concept_name, 'type' => 'concept', 'subtype' => nil,    'name' => concept_name },
+      { 'temp_id' => teaching_pool_name,    'type' => 'module',  'subtype' => 'pool', 'name' => 'teaching_pool' },
+      { 'temp_id' => assessing_pool_name,    'type' => 'module',  'subtype' => 'pool', 'name' => 'assessing_pool' },
+    ],
+    'edges' => prereq_temp_ids.map{|prereq| { 'start_temp_id' => prereq, 'end_temp_id' => concept_name, 'type' => 'prerequisite'}} +
+    [
+      { 'start_temp_id' => concept_name, 'end_temp_id' => teaching_pool_name, 'type' => 'taught_by'     },
+      { 'start_temp_id' => concept_name, 'end_temp_id' => assessing_pool_name, 'type' => 'assessed_by'   },
+    ],
+  }
+
+  options[:num_instructional_bundles_per_concept].times do |bndl_num|
+    bndl_name = concept_name + "-instructional-bundle-#{bndl_num}"
+    concept['nodes'] << {'temp_id' => bndl_name, 'type' => 'module', 'subtype' => 'bndl', 'name' => bndl_name }
+
+    options[:num_atoms_per_instructional_bundle].times do |atom_num|
+      atom_name = get_mref_eid(bndl_name + "-atom-#{atom_num}")
+      concept['nodes'] << {'temp_id' => atom_name, 'type' => 'module', 'subtype' => 'atom', 'name' => atom_name }
+      concept['edges'] << {'start_temp_id' => teaching_pool_name, 'end_temp_id' => atom_name, 'type' => 'contains' }
+      concept['edges'] << {'start_temp_id' => bndl_name, 'end_temp_id' => atom_name, 'type' => 'contains' }
+    end
+  end
+
+  options[:num_assessment_bundles_per_concept].times do |bndl_num|
+    bndl_name = concept_name + "-assessment-bundle-#{bndl_num}"
+    concept['nodes'] << {'temp_id' => bndl_name, 'type' => 'module', 'subtype' => 'bndl', 'name' => bndl_name }
+
+    options[:num_atoms_per_assessment_bundle].times do |atom_num|
+      atom_name = get_mref_eid(bndl_name + "-atom-#{atom_num}")
+      concept['nodes'] << {'temp_id' => atom_name, 'type' => 'module', 'subtype' => 'atom', 'name' => atom_name }
+      concept['edges'] << {'start_temp_id' => assessing_pool_name, 'end_temp_id' => atom_name, 'type' => 'contains' }
+      concept['edges'] << {'start_temp_id' => bndl_name, 'end_temp_id' => atom_name, 'type' => 'contains' }
+    end
+  end
+
+  graph['nodes'] += concept['nodes']
+  graph['edges'] += concept['edges']
+
+  return concept_name
+end
+
+
+# DEPRECATED TAXONOMY GET METHODS
+# the old taxonomy_grifts.rb
+
+def get_taxonomy (id, overrides={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Getting taxonomy by id: '#{id}'."
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.get "/v0/taxonomies/#{id}"
+  end
+end
+
+def get_taxonomies_for_partner_id(partner_id, overrides={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Getting taxonomies for partner id: '#{partner_id}'."
+
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.get "/v0/taxonomies?"+ URI.encode_www_form({"partner_id" => partner_id})
+  end
+end
+
+def get_referenced_taxonomies(learning_instance_id, overrides={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Getting referenced taxonomies by learning instance id: '#{learning_instance_id}'."
+
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.get "/v0/taxonomies?"+ URI.encode_www_form({"learning_instance_id" => learning_instance_id})
+  end
+end
+
+
+
+def create_taxonomy (overrides={}, params={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Creating taxonomy."
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    kapi.post '/v0/taxonomies?' + URI.encode_www_form(params), {
+        'name' => random_taxonomy_name,
+        'type' => 'role'
+    }.merge(overrides)
+  end
+end
+
+
+def create_taxon (taxonomy_id, overrides={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  Log.info "Creating taxon on taxonomy with id: '#{taxonomy_id}'."
+  response = nil
+  do_as_knewton_partner overrides.delete('use_current_user') do
+    response = kapi.post "/v0/taxonomies/#{taxonomy_id}/taxons", {
+        'name' => 'footaxon',
+    }.merge(overrides)
+  end
+  Log.info "Waiting for Titanik to create taxon"
+  eventually do
+    taxonomy = get_taxonomy taxonomy_id
+    (taxonomy.find{|r| response['id']}).should_not == nil
+  end
+  response
+end
+
+def create_basic_taxonomy (overrides={}, params={})
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  basic_json = {
+      'name' => 'taxidermy',
+      'type' => 'role',
+      'taxons' => [
+          {'path' => 'basics|methods|material|basics|clay'},
+          {'path' => 'basics|methods|material|chemicals|dextrin'},
+          {'path' => 'basics|methods|tools|fleshing|throat_scraper_cone'},
+          {'path' => 'animals|fish|blobfish'}
+      ]
+  }
+  response = create_taxonomy(basic_json.merge(overrides), params)
+  kapi.last_response.status.should == 201
+  Log.info "Waiting for titanik to create taxonomy"
+  eventually do
+    begin
+      get_taxonomy response["id"]
+      kapi.last_response.status.should == 200
+    rescue Grifter::RequestException
+      # ignored
+    end
+    kapi.last_response.status.should == 200
+  end
+  response
+end
+
+def create_basic_taxon_graph
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  taxonomy = create_basic_taxonomy
+  taxon_id1 = taxonomy['taxons'][0]['id']
+  taxon_id2 = taxonomy['taxons'][2]['id']
+
+  footempid1 = get_tref_eid("footempid1")
+  footempid2 = get_tref_eid("footempid2")
+  footempid3 = get_tref_eid("footempid3")
+  footempid4 = get_tref_eid("footempid4")
+  footempid5 = get_tref_eid("footempid5")
+  conceptparty = get_tref_eid("conceptparty")
+  poolparty = get_tref_eid("poolparty")
+
+  create_graph 'nodes' => [
+    {'temp_id' => footempid1, 'type' => 'module', 'name' => 'fooname1', 'subtype' => 'atom', 'taxon_ids' => [taxon_id1], 'is_taxon_recommendable' => true},
+    {'temp_id' => footempid2, 'type' => 'module', 'name' => 'fooname2', 'subtype' => 'atom', 'taxon_ids' => [taxon_id2], 'is_taxon_recommendable' => true},
+    {'temp_id' => footempid3, 'type' => 'module', 'name' => 'fooname3', 'subtype' => 'atom', 'taxon_ids' => [taxon_id2], 'is_taxon_recommendable' => true},
+    {'temp_id' => footempid4, 'type' => 'module', 'name' => 'fooname4', 'subtype' => 'atom', 'taxon_ids' => [taxon_id2], 'is_taxon_recommendable' => true},
+    {'temp_id' => footempid5, 'type' => 'module', 'name' => 'fooname5', 'subtype' => 'atom', 'taxon_ids' => [taxon_id2], 'is_taxon_recommendable' => true},
+    {'temp_id' => conceptparty, 'type' => 'concept', 'name' => 'some concept'},
+    {'temp_id' => poolparty, 'type' => 'module', 'subtype' => 'pool', 'name' => 'some pool', 'is_taxon_recommendable' => true},
+  ],
+  'edges' => [
+    { 'type' => 'contains', 'start_temp_id' => poolparty, 'end_temp_id' => footempid1},
+    { 'type' => 'contains', 'start_temp_id' => poolparty, 'end_temp_id' => footempid2},
+    { 'type' => 'contains', 'start_temp_id' => poolparty, 'end_temp_id' => footempid3},
+    { 'type' => 'contains', 'start_temp_id' => poolparty, 'end_temp_id' => footempid4},
+    { 'type' => 'contains', 'start_temp_id' => poolparty, 'end_temp_id' => footempid5},
+    { 'type' => 'assessed_by', 'start_temp_id' => conceptparty, 'end_temp_id' => poolparty},
+  ]
+end
+
+def get_all_graph_taxonomies graph
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  graph['nodes'].select{ |node| node['type']=='module' and
+                                (node['subtype']=='atom' or node['subtype']=='bndl')
+                       }.map{ |node| node['taxon_ids'] }.flatten.uniq
+end
+
+def get_modules_by_taxonomy graph, taxon_id
+  Log.warn "DEPRECATED GRIFT CALLED: #{__method__}"
+  #select all modules by taxon id
+  all_module_ids = graph['nodes'].select{|node| node['type']=='module' and
+                                                (node['subtype']=='atom' or node['subtype']=='bndl') and
+                                                node['taxon_ids'].include?(taxon_id)
+                                        }.map{|node| node['id'] }
+  return all_module_ids
+end