def get(self, subject_id=None):
'''
GET /subjects/ -> get all subjects
GET /subjects/{id}/ -> get subject with id=id
'''
if subject_id is not None:
try:
return Subject.get(id=subject_id).json()
except:
abort(404)
else:
return [
subject.json()
for subject in Subject.get()
]
def get_version(db_conn, kind, id_):
if kind == 'card':
card = Card.get(db_conn, id=id_)
return flip_card_into_kind(card)
elif kind == 'unit':
return Unit.get(db_conn, id=id_)
elif kind == 'subject':
return Subject.get(db_conn, id=id_)
def test_traverse(db_conn, units_table, users_table, responses_table,
subjects_table):
"""
Expect to take a list of units and traverse them correctly.
Basic test.
"""
add_test_subject(db_conn,
users_table, units_table, responses_table, subjects_table)
subject = Subject.get(db_conn, entity_id='subject')
user = get_user({'id': 'user'}, db_conn)
buckets = traverse(db_conn, user, subject)
assert buckets['diagnose'][0]['entity_id'] == 'divide'
assert buckets['learn'][0]['entity_id'] == 'multiply'
assert buckets['review'][0]['entity_id'] == 'subtract'
def add_subject_route(request, user_id, subject_id):
"""
Add a subject to the learner's list of subjects.
"""
db_conn = request['db_conn']
current_user = get_current_user(request)
if not current_user:
return abort(401)
if user_id != current_user['id']:
return abort(403)
subject = Subject.get(db_conn, entity_id=subject_id)
if not subject:
return abort(404)
user_subject = get_user_subjects(user_id, db_conn)
if user_subject and subject_id in user_subject['subject_ids']:
return 400, {
'errors': [{
'name': 'subject_id',
'message': 'Subject is already added.',
}],
'ref':
'kPZ95zM3oxFDGGl8vBdR3J3o',
}
# TODO-2 move some of this logic to the database file
if user_subject:
user_subject, errors = append_user_subjects(user_id, subject_id,
db_conn)
else:
user_subject, errors = insert_user_subjects(
{
'user_id': user_id,
'subject_ids': [subject_id],
}, db_conn)
if errors:
return 400, {'errors': errors, 'ref': 'zCFUbLBTg9n2DnTkQYbqO4X9'}
return 200, {'subjects': user_subject['subject_ids']}
def get_subject_tree_route(request, subject_id):
"""
Render the tree of units that exists within a subject.
Contexts:
- Search subject, preview units in subject
- Pre diagnosis
- Learner view progress in subject
- Subject complete
NEXT STATE
GET View Subject Tree
-> GET Choose Subject ...when subject is complete
-> GET Choose Unit ...when in learn or review mode
-> GET Learn Card ...when in diagnosis
(Unit auto chosen)
TODO-2 merge with get_subject_units_route
TODO-2 simplify this method
"""
db_conn = request['db_conn']
subject = Subject.get(db_conn, entity_id=subject_id)
if not subject:
return abort(404)
units = subject.list_units(db_conn)
# For the menu, it must return the name and ID of the subject
output = {
'subjects': subject.deliver(),
'units': [u.deliver() for u in units],
}
current_user = get_current_user(request)
if not current_user:
return 200, output
context = get_learning_context(current_user) if current_user else {}
buckets = traverse(db_conn, current_user, subject)
output['buckets'] = {
'diagnose': [u['entity_id'] for u in buckets['diagnose']],
'review': [u['entity_id'] for u in buckets['review']],
'learn': [u['entity_id'] for u in buckets['learn']],
'done': [u['entity_id'] for u in buckets['done']],
}
# If we are just previewing, don't update anything
if subject_id != context.get('subject', {}).get('entity_id'):
return 200, output
# When in diagnosis, choose the unit and card automagically.
if buckets['diagnose']:
unit = buckets['diagnose'][0]
card = choose_card(db_conn, current_user, unit)
next_ = {
'method': 'GET',
'path':
'/s/cards/{card_id}/learn'.format(card_id=card['entity_id']),
}
set_learning_context(current_user,
next=next_,
unit=unit.data,
card=card.data)
# When in learn or review mode, lead me to choose a unit.
elif buckets['review'] or buckets['learn']:
next_ = {
'method': 'GET',
'path':
'/s/subjects/{subject_id}/units'.format(subject_id=subject_id),
}
set_learning_context(current_user, next=next_)
# If the subject is complete, lead the learner to choose another subject.
else:
next_ = {
'method':
'GET',
'path':
'/s/users/{user_id}/subjects'.format(user_id=current_user['id']),
}
set_learning_context(current_user, next=next_, unit=None, subject=None)
output['next'] = next_
return 200, output
def test_list_units(db_conn, units_table, subjects_table):
"""
Expect to get a list of units contained within the subject.
Recursive.
"""
units_table.insert([{
'entity_id': 'B',
'name': 'B',
'created': r.now(),
'modified': r.now(),
'status': 'accepted',
'require_ids': ['A', 'N']
}, {
'entity_id': 'V',
'name': 'V',
'created': r.now(),
'modified': r.now(),
'status': 'accepted',
'require_ids': ['Q']
}, {
'entity_id': 'Q',
'name': 'Q',
'created': r.now(),
'modified': r.now(),
'status': 'accepted',
}, {
'entity_id': 'A',
'name': 'A',
'created': r.now(),
'modified': r.now(),
'status': 'accepted',
}, {
'entity_id': 'N',
'name': 'N',
'created': r.now(),
'modified': r.now(),
'status': 'accepted',
'require_ids': ['Q', 'A']
}]).run(db_conn)
subjects_table.insert([{
'entity_id':
'T',
'name':
'TRex',
'body':
'TRex',
'created':
r.now(),
'modified':
r.now(),
'status':
'accepted',
'members': [{
'kind': 'unit',
'id': 'B',
}, {
'kind': 'unit',
'id': 'V',
}]
}, {
'entity_id':
'S',
'name':
'Saurus',
'body':
'Saurus',
'created':
r.now(),
'modified':
r.now(),
'status':
'accepted',
'members': [{
'kind': 'subject',
'id': 'T',
}, {
'kind': 'unit',
'id': 'Q',
}]
}]).run(db_conn)
subject = Subject.get(db_conn, entity_id='S')
cards = subject.list_units(db_conn)
card_ids = set(card['entity_id'] for card in cards)
assert card_ids == {'B', 'V', 'Q', 'N'}
