def create():
english = Subject.get_by_id(3)
math = Subject.get_by_id(4)
life_skills = Subject.get_by_id(5)
tutor_1 = Tutor.get_by_id(1)
tutor_2 = Tutor.get_by_id(2)
start_1 = datetime.datetime(2021, 2, 1, 10, 0)
end_1 = datetime.datetime(2021, 2, 1, 12, 0)
duration_1 = (end_1 - start_1).seconds // 60 # convert to minute
start_2 = datetime.datetime(2021, 2, 1, 11, 0)
end_2 = datetime.datetime(2021, 2, 1, 13, 0)
duration_2 = (end_2 - start_2).seconds // 60 # convert to minute
session = Tutor_session(subject=english,
tutor=tutor_1,
title="Some title",
price=100,
duration=duration_1,
start_time=start_1,
end_time=end_1,
max_student_capacity=10,
status="Confirmed",
zoom_host="",
zoom_participant="")
if session.save():
flash("session created")
else:
flash("error creating session")
return render_template('home.html', errors=session.errors)
def create():
s = Subject(
category=request.form['category']
)
if s.save():
flash("Subject created")
else:
flash("Subject not created", errors = s.errors)
def post(self):
'''POST /subjects/ -> add a new subject
'''
data = subjectResource.parser.parse_args()
subject_name = data.get('name')
subject_age = data.get('age')
subject = Subject(subject_name, subject_age)
subject.save()
return subject.json(), 201
def create_subject(name, description, user):
s = Subject()
s.name = name
s.description = description
s.user_id = user.id
session = db_session.create_session()
session.add(s)
session.commit()
return s
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_unit_route(request, unit_id):
"""
Get a specific unit given an ID.
"""
db_conn = request['db_conn']
unit = Unit.get_latest_accepted(db_conn, unit_id)
if not unit:
return abort(404)
# TODO-2 SPLITUP create new endpoints for these instead
topics = list_topics_by_entity_id(unit_id, {}, db_conn)
versions = Unit.get_versions(db_conn, unit_id)
requires = Unit.list_requires(db_conn, unit_id)
required_by = Unit.list_required_by(db_conn, unit_id)
subjects = Subject.list_by_unit_id(db_conn, unit_id)
return 200, {
'unit': unit.deliver(),
# 'unit_parameters': unit.fetch_parameters(),
'topics': [deliver_topic(topic) for topic in topics],
'versions': [version.deliver() for version in versions],
'requires': [require.deliver() for require in requires],
'required_by': [require.deliver() for require in required_by],
'belongs_to': [subject.deliver() for subject in subjects],
}
def instance_entities(data):
"""
Given a kind and some json, call insert on that kind
and return the results.
A little safer.
"""
fields = ('id', 'created', 'modified',
'entity_id', 'previous_id', 'status', 'available')
entities = []
if 'cards' in data:
for card_data in data['cards']:
kind = card_data.get('kind')
if kind in card_map:
entities.push(
card_map[kind](omit(card_data, fields))
)
if 'units' in data:
entities = entities + [
Unit(omit(unit_data, fields))
for unit_data in data['units']
]
if 'subjects' in data:
entities = entities + [
Subject(omit(subject_data, fields))
for subject_data in data['subjects']
]
return entities
def flush_entities(db_conn, descs):
"""
Given a list of kinds and entity_ids,
return a list filled out with entities.
"""
output = []
for desc in descs:
if desc['kind'] == 'card':
card = Card.get_latest_accepted(db_conn, entity_id=desc['id'])
card = flip_card_into_kind(card)
if card:
output.append(card)
elif desc['kind'] == 'unit':
output.append(Unit.get_latest_accepted(
db_conn,
entity_id=desc['id']
))
elif desc['kind'] == 'subject':
output.append(Subject.get_latest_accepted(
db_conn,
entity_id=desc['id']
))
else:
output.append(None)
return output
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 get_recommended_subjects(request):
db_conn = request['db_conn']
entity_ids = ('JAFGYFWhILcsiByyH2O9frcU', )
if config['debug']:
entity_ids = ('subjectAll', )
subjects = Subject.list_by_entity_ids(db_conn, entity_ids)
if not subjects:
return abort(404)
return 200, {'subjects': [subject.deliver() for subject in subjects]}
def get_my_recently_created_subjects(current_user, db_conn):
"""
Get the user's most recently created subjects.
"""
proposals = get_my_recent_proposals(current_user, db_conn)
subject_version_ids = get_proposal_entity_versions(proposals, 'subject')
subjects = Subject.list_by_version_ids(db_conn, subject_version_ids)
return subjects
def show_all():
subjects = Subject.select()
subject_data = []
for subject in subjects:
subject = model_to_dict(subject)
subject_data.append(subject)
return make_response(jsonify(subject_data)), 200
def get_subject_and_chapter_name(self):
obj = {}
from models.subject import Subject
from models.chapter import Chapter
subjects = Subject.all()
for s in subjects:
clist = Chapter.find_all(subject_id=s.id)
temp = []
for c in clist:
temp.append(c.__dict__)
obj[s.id] = temp
return obj
def list_user_subjects_entity(user_id, params, db_conn):
"""
Join the user's subject_ids with subject information.
Return empty list when there's no matching documents.
"""
# TODO-2 each subject -- needs review?
# TODO-2 order by last reviewed time
user_subject = get_user_subjects(user_id, db_conn)
# TODO-3 limit = params.get('limit') or 10
# TODO-3 skip = params.get('skip') or 0
return Subject.list_by_entity_ids(db_conn, user_subject['subject_ids'])
def get_subject_versions_route(request, subject_id):
"""
Get subject versions given an ID. Paginates.
"""
db_conn = request['db_conn']
versions = Subject.get_versions(db_conn,
entity_id=subject_id,
**request['params'])
return 200, {
'versions': [version.deliver(access='view') for version in versions]
}
def choose_unit_route(request, subject_id, unit_id):
"""
Updates the learner's information based on the unit they have chosen.
NEXT STATE
POST Chosen Unit
-> GET Learn Card
"""
# TODO-3 simplify this method. should it be broken up or moved to model?
db_conn = request['db_conn']
current_user = get_current_user(request)
if not current_user:
return abort(401)
unit = Unit.get_latest_accepted(db_conn, unit_id)
if not unit:
return abort(404)
# If the unit isn't in the subject...
context = get_learning_context(current_user)
subject_ids = [
subject['entity_id']
for subject in Subject.list_by_unit_id(db_conn, unit_id)
]
if context.get('subject', {}).get('entity_id') not in subject_ids:
return abort(400)
status = judge(db_conn, unit, current_user)
# Or, the unit doesn't need to be learned...
if status == "done":
return abort(400)
# Choose a card for the learner to learn
card = choose_card(db_conn, current_user, unit)
if card:
next_ = {
'method': 'GET',
'path':
'/s/cards/{card_id}/learn'.format(card_id=card['entity_id']),
}
else:
next_ = {}
set_learning_context(current_user,
unit=unit.data,
card=card.data if card else None,
next=next_)
return 200, {'next': next_}
def get_subject_route(request, subject_id):
"""
Get a specific subject given an ID.
"""
db_conn = request['db_conn']
subject = Subject.get_latest_accepted(db_conn, subject_id)
if not subject:
return abort(404)
# TODO-2 SPLITUP create new endpoints for these instead
topics = list_topics_by_entity_id(subject_id, {}, db_conn)
versions = Subject.get_versions(db_conn, entity_id=subject_id)
units = subject.list_units(db_conn)
return 200, {
'subject': subject.deliver(),
# 'subject_parameters': subject.fetch_parameters(),
'topics': [deliver_topic(topic) for topic in topics],
'versions': [version.deliver() for version in versions],
'units': [unit.deliver() for unit in units],
}
def get_latest_accepted(db_conn, kind, entity_id):
"""
Given a kind and an entity_id, pull the latest accepted
version out of the database.
"""
if kind == 'card':
card = Card.get_latest_accepted(db_conn, entity_id)
return flip_card_into_kind(card)
elif kind == 'unit':
return Unit.get_latest_accepted(db_conn, entity_id)
elif kind == 'subject':
return Subject.get_latest_accepted(db_conn, entity_id)
def new():
from models.subject import Subject
subject_list = Subject.all()
cookie = token_cookie()
template = render_template(
"chapter/edit_chapter.html",
chapter=None,
subjects=subject_list,
token=cookie['token'],
)
r = make_response(template)
r.set_cookie(cookie['token'], cookie['id'], max_age=300)
return r
def new():
from models.subject import Subject
from models.problem import Problem
subject_list = Subject.all()
problem_type = Problem.get_problem_type_list()
cookie = token_cookie()
template = render_template(
"problem/new_problem.html",
subjects=subject_list,
types=problem_type,
token=cookie['token'],
)
r = make_response(template)
r.set_cookie(cookie['token'], cookie['id'], max_age=300)
return r
def new():
from models.subject import Subject
subject_list = Subject.all()
obj = Article.get_subject_and_chapter_name()
cookie = token_cookie()
template = render_template(
"article/edit_article.html",
article=None,
subjects=subject_list,
obj=json_util.dumps(obj),
token=cookie['token'],
)
r = make_response(template)
r.set_cookie(cookie['token'], cookie['id'], max_age=300)
return r
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 test_language(db_conn, subjects_table, units_table):
"""
Expect a subject to require a language.
"""
create_unit_a(db_conn, units_table)
subject, errors = Subject.insert(
db_conn, {
'name': 'Statistics',
'body': 'A beginning course focused on probability.',
'members': [{
'id': 'A',
'kind': 'unit',
}],
})
assert len(errors) == 0
assert subject['language'] == 'en'
def add_problem_from_xls(cls, lists):
from models.subject import Subject
from models.chapter import Chapter
subject = Subject.new({
"name": lists[0][0],
})
chapter_id_flag = -1
chapter_id = -1
for item in lists:
if int(item[1]) != chapter_id_flag:
chapter = Chapter.new({
'subject_id': subject.id,
'name': item[2]
})
chapter_id = chapter.id
chapter_id_flag = int(item[1])
cls.add_problem(subject.id, chapter_id, item)
def test_tags(db_conn, subjects_table, units_table):
"""
Expect a subject to allow tags.
"""
create_unit_a(db_conn, units_table)
subject, errors = Subject.insert(
db_conn, {
'name': 'Statistics',
'body': 'A beginning course focused on probability.',
'members': [{
'id': 'A',
'kind': 'unit',
}],
'tags': ['A', 'B', 'C']
})
assert len(errors) == 0
def test_previous(db_conn, subjects_table, units_table):
"""
Expect a subject to allow a previous version id.
"""
create_unit_a(db_conn, units_table)
subject, errors = Subject.insert(
db_conn, {
'name': 'Statistics',
'body': 'A beginning course focused on probability.',
'members': [{
'id': 'A',
'kind': 'unit',
}],
'previous_id': 'fdsjKO',
})
assert len(errors) == 0
def test_body(db_conn, subjects_table, units_table):
"""
Expect a subject to require a body.
"""
create_unit_a(db_conn, units_table)
subject, errors = Subject.insert(
db_conn, {
'name': 'Statistics',
'members': [{
'id': 'A',
'kind': 'unit',
}],
})
assert len(errors) == 1
subject['body'] = 'A beginning course focused on probability.'
subject, errors = subject.save(db_conn)
assert len(errors) == 0
def test_members(db_conn, subjects_table, units_table):
"""
Expect a subject to record a list of members.
"""
create_unit_a(db_conn, units_table)
subject, errors = Subject.insert(
db_conn, {
'name': 'Statistics',
'body': 'A beginning course focused on probability.',
})
assert len(errors) == 0
subject['members'] = [{
'id': 'A',
'kind': 'unit',
}]
subject, errors = subject.save(db_conn)
assert len(errors) == 0
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_units_route(request, subject_id):
"""
Present a small number of units the learner can choose from.
NEXT STATE
GET Choose Unit
-> POST Choose Unit
"""
db_conn = request['db_conn']
# TODO-3 simplify this method. should it be part of the models?
current_user = get_current_user(request)
if not current_user:
return abort(401)
context = get_learning_context(current_user)
next_ = {
'method':
'POST',
'path':
'/s/subjects/{subject_id}/units/{unit_id}'.format(
subject_id=context.get('subject', {}).get('entity_id'),
unit_id='{unit_id}'),
}
set_learning_context(current_user, next=next_)
subject = Subject.get_latest_accepted(db_conn, subject_id)
# Pull a list of up to 5 units to choose from based on priority.
buckets = traverse(db_conn, current_user, subject)
units = buckets['learn'][:5]
# TODO-3 Time estimates per unit for mastery.
return 200, {
'next': next_,
'units': [unit.deliver() for unit in units],
# For the menu, it must return the name and ID of the subject
'subject': subject.deliver(),
'current_unit_id': context.get('unit', {}).get('entity_id'),
}
import sys, os sys.path.append(os.path.join(os.getcwd(), "..")) from models.collections import Collections from models.subject import Subject from persistence import mongoInterface mongoInterface.setup() collections = Collections() collections.save(mongoInterface) for collectionId, subjectsIds in collections.getCollections(): print "############################" print "# Preprocessing collection: " + collectionId print "############################\n" for subjectId in subjectsIds: try: subject = Subject(subjectId) subject.fetch() subject.parse() subject.save(mongoInterface) except (OSError, Exception) as e: print "Error: ", e mongoInterface.close()
def post(self, eventId, guardianId):
'''The visitor is not an authenticated guardian'''
if not SubscriptionLoginHandler.isAuthenticatedGuardian():
self.redirect('/inschrijven/')
return
'''The guardian is not authorized to the given'''
if not self.isAuthorized(eventId, guardianId):
SubscriptionLoginHandler.redirectToSubscriptionPage(self)
return
event = Event.get_by_id(int(eventId))
days = Day.gql("WHERE event = :1", event).fetch(999)
guardian = Guardian.get_by_key_name(guardianId)
students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0)
students_subjects = self.getStudentsSubjects(students)
notifications = []
templVal = {
'event': event,
'days': days,
'guardian': guardian,
'students': students_subjects,
'notifications': notifications
}
if not (event and days and guardian and students):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0)
if not subscriptionDetailsList:
notifications.append('Pagina niet gevonden.')
self.showError(templVal)
return
subscriptionDetails = subscriptionDetailsList[0]
if subscriptionDetails and subscriptionDetails.requested:
notifications.append('U kunt geen verzoeken meer indienen.')
self.showError(templVal)
return
studentKeys = [str(k.replace('subject_', '')) for k in self.request.arguments() if re.match("subject_.+", k)]
requests = []
dayPrefs = []
for s in students[:]:
if str(s.key().name()) not in studentKeys:
students.remove(s)
if not students:
notifications.append('U kunt geen verzoek indienen als u geen enkel vak geselecteerd heeft. ')
for student in students[:]:
subjectCodes = [c for c in self.request.get_all("subject_" + str(student.key().name()))]
subjects = Subject.get_by_key_name(subjectCodes)
if len(subjectCodes) > 3:
notifications.append('U kunt maximaal 3 vakken per leerling bespreken.')
if len(subjectCodes) != len(subjects):
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
for subject in subjects:
combination = Combination.gql("WHERE class_id = :1 AND subject = :2", student.class_id, subject).fetch(1,0)[0]
if not combination:
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
request = Request()
request.event = event
request.guardian = guardian
request.student = student
request.combination = combination
requests.append(request)
'''Process timepreference'''
timePref = TimePreference()
timePref.event = event
timePref.guardian = guardian
timePref.preference = 0
if not (self.request.get('time_pref') and (int(self.request.get('time_pref')) in [0,1,2])):
notifications.append('U moet een voorkeur voor tijd aangeven.')
else:
timePref.preference = int(self.request.get('time_pref'))
'''Check if dates from the form match the dates from the event '''
dayKeys = [long(k.replace('date_', '')) for k in self.request.arguments() if re.match("date_.+", k)]
dayKeysFromStore= [day.key().id() for day in days]
daysOk = True
for dayKey in dayKeys:
if dayKey not in dayKeysFromStore:
daysOk = False
notifications.append('U probeert een onmogelijke bewerking uit te voeren.')
self.showError(templVal)
return
'''Check if the daypreference are correct filled in'''
dayPrefsList = [int(self.request.get(k)) for k in self.request.arguments() if re.match("date_.+", k)]
dayPrefsList.sort()
dayPrefsOk = True
if dayPrefsList != [1,2,3]:
dayPrefsOk = False
notifications.append('U moet een eerste, een tweede en een derde voorkeur aangeven')
'''Process daypreferences'''
if daysOk and dayPrefsOk:
for day in days:
dayPref = DayPreference()
dayPref.day = day
dayPref.guardian = guardian
dayPref.rank = int(self.request.get("date_" + str(day.key().id())))
dayPrefs.append(dayPref)
if notifications:
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html')
self.response.out.write(template.render(path, templVal))
return
'''Store the requests'''
for request in requests:
request.put()
for dayPref in dayPrefs:
dayPref.put()
timePref.put()
subscriptionDetails.requested = True
subscriptionDetails.put()
SubscriptionLogoutHandler.logoutGuardian()
path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription-success.html')
self.response.out.write(template.render(path, templVal))
return
def get(self):
# Load all Guardians
path = os.path.join(os.path.dirname(__file__), 'data/voogdouder.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_guardian = Guardian(key_name=row[0].strip())
new_guardian.title=row[1].strip()
new_guardian.initials=row[2].strip()
new_guardian.preposition=row[3].strip()
new_guardian.lastname=row[4].strip()
new_guardian.streetname=row[6].strip()
new_guardian.housenumber=row[7].strip()
new_guardian.city=row[8].strip()
new_guardian.postalcode=row[9].strip()
new_guardian.email=row[12].strip()
new_guardian.save()
print "Guardian " + new_guardian.key().id_or_name() + " stored"
# Load all Students
path = os.path.join(os.path.dirname(__file__), 'data/leerlingen.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_student = Student(key_name=row[0].strip())
new_student.firstname=row[1].strip()
new_student.preposition=row[2].strip()
new_student.lastname=row[3].strip()
new_student.gender=row[4].strip()
new_student.class_id=row[5].strip()
new_student.guardian=Guardian.all().filter("__key__ >=", Key.from_path('Guardian', row[6].strip())).get()
new_student.save()
print "Student " + new_student.key().id_or_name() + " stored"
# Load all Teachers
path = os.path.join(os.path.dirname(__file__), 'data/docenten.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_teacher = Teacher(key_name=row[0].strip())
new_teacher.name=row[1].strip()
new_teacher.boxnumber=int(row[2].strip())
new_teacher.email=row[3].strip()
new_teacher.save()
print "Teacher " + new_teacher.key().id_or_name() + " stored"
# Load all Subjects
path = os.path.join(os.path.dirname(__file__), 'data/vakken.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_subject = Subject(key_name=row[0].strip())
new_subject.name=row[1].strip()
new_subject.save()
print "Subject " + new_subject.key().id_or_name() + " stored"
# Load all Students
path = os.path.join(os.path.dirname(__file__), 'data/docent_vak.txt')
my_file = open(path)
fileReader = csv.reader(my_file, delimiter=";")
for row in fileReader:
new_combination = Combination()
new_combination.class_id=row[0].strip()
new_combination.subject=Subject.all().filter("__key__ >=", Key.from_path('Subject', row[1].strip())).get()
new_combination.teacher=Teacher.all().filter("__key__ >=", Key.from_path('Teacher', row[2].strip())).get()
new_combination.save()
print "Combination " + str(new_combination.key().id_or_name()) + " stored"
self.redirect("/fix")
