def programs_page (request):
username = current_user(request) ['username']
if not username:
return "unauthorized", 403
from_user = request.args.get('user') or None
if from_user and not is_admin (request):
return "unauthorized", 403
texts=TRANSLATIONS.data [requested_lang ()] ['Programs']
ui=TRANSLATIONS.data [requested_lang ()] ['ui']
adventures = load_adventure_for_language(requested_lang ())['adventures']
result = db_get_many ('programs', {'username': from_user or username}, True)
programs = []
now = timems ()
for item in result:
measure = texts ['minutes']
date = round ((now - item ['date']) / 60000)
if date > 90:
measure = texts ['hours']
date = round (date / 60)
if date > 36:
measure = texts ['days']
date = round (date / 24)
programs.append ({'id': item ['id'], 'code': item ['code'], 'date': texts ['ago-1'] + ' ' + str (date) + ' ' + measure + ' ' + texts ['ago-2'], 'level': item ['level'], 'name': item ['name'], 'adventure_name': item.get ('adventure_name'), 'public': item.get ('public')})
return render_template('programs.html', lang=requested_lang(), menu=render_main_menu('programs'), texts=texts, ui=ui, auth=TRANSLATIONS.data [requested_lang ()] ['Auth'], programs=programs, username=username, current_page='programs', from_user=from_user, adventures=adventures)
def save_program(user):
body = request.json
if not type_check(body, 'dict'):
return 'body must be an object', 400
if not object_check(body, 'code', 'str'):
return 'code must be a string', 400
if not object_check(body, 'name', 'str'):
return 'name must be a string', 400
if not object_check(body, 'level', 'int'):
return 'level must be an integer', 400
# We execute the saved program to see if it would generate an error or not
error = None
try:
hedy_errors = TRANSLATIONS.get_translations(requested_lang(),
'HedyErrorMessages')
result = hedy.transpile(body['code'], body['level'])
except hedy.HedyException as E:
error_template = hedy_errors[E.error_code]
error = error_template.format(**E.arguments)
except Exception as E:
error = str(E)
name = body['name']
# We check if a program with a name `xyz` exists in the database for the username. If it does, we exist whether `xyz (1)` exists, until we find a program `xyz (NN)` that doesn't exist yet.
# It'd be ideal to search by username & program name, but since DynamoDB doesn't allow searching for two indexes at the same time, this would require to create a special index to that effect, which is cumbersome.
# For now, we bring all existing programs for the user and then search within them for repeated names.
existing = db_get_many('programs', {'username': user['username']}, True)
name_counter = 0
for program in existing:
if re.match('^' + re.escape(name) + '( \(\d+\))*', program['name']):
name_counter = name_counter + 1
if name_counter:
name = name + ' (' + str(name_counter) + ')'
db_set(
'programs', {
'id': uuid.uuid4().hex,
'session': session_id(),
'date': timems(),
'lang': requested_lang(),
'version': version(),
'level': body['level'],
'code': body['code'],
'name': name,
'server_error': error,
'username': user['username']
})
program_count = 0
if 'program_count' in user:
program_count = user['program_count']
db_set('users', {
'username': user['username'],
'program_count': program_count + 1
})
return jsonify({})
def save_program(user):
body = request.json
if not type_check(body, 'dict'):
return 'body must be an object', 400
if not object_check(body, 'code', 'str'):
return 'code must be a string', 400
if not object_check(body, 'name', 'str'):
return 'name must be a string', 400
if not object_check(body, 'level', 'int'):
return 'level must be an integer', 400
if 'adventure_name' in body:
if not object_check(body, 'adventure_name', 'str'):
return 'if present, adventure_name must be a string', 400
name = body['name']
# We check if a program with a name `xyz` exists in the database for the username.
# It'd be ideal to search by username & program name, but since DynamoDB doesn't allow searching for two indexes at the same time, this would require to create a special index to that effect, which is cumbersome.
# For now, we bring all existing programs for the user and then search within them for repeated names.
programs = db_get_many('programs', {'username': user['username']}, True)
program = {}
overwrite = False
for program in programs:
if program['name'] == name:
overwrite = True
break
stored_program = {
'id': program.get('id') if overwrite else uuid.uuid4().hex,
'session': session_id(),
'date': timems(),
'lang': requested_lang(),
'version': version(),
'level': body['level'],
'code': body['code'],
'name': name,
'username': user['username']
}
if 'adventure_name' in body:
stored_program['adventure_name'] = body['adventure_name']
if overwrite:
db_update('programs', stored_program)
else:
db_create('programs', stored_program)
program_count = 0
if 'program_count' in user:
program_count = user['program_count']
db_update('users', {
'username': user['username'],
'program_count': program_count + 1
})
return jsonify({'name': name})
def load_adventure_assignments_per_level(lang, level):
loaded_programs = {}
# If user is logged in, we iterate their programs that belong to the current level. Out of these, we keep the latest created program for both the level mode (no adventure) and for each of the adventures.
if current_user(request)['username']:
user_programs = db_get_many(
'programs', {'username': current_user(request)['username']}, True)
for program in user_programs:
if program['level'] != level:
continue
program_key = 'level' if not program.get(
'adventure_name') else program['adventure_name']
if not program_key in loaded_programs:
loaded_programs[program_key] = program
elif loaded_programs[program_key]['date'] < program['date']:
loaded_programs[program_key] = program
assignments = []
adventures = load_adventure_for_language(lang)['adventures']
for short_name, adventure in adventures.items():
if not level in adventure['levels']:
continue
assignments.append({
'short_name':
short_name,
'name':
adventure['name'],
'image':
adventure.get('image', None),
'default_save_name':
adventure['default_save_name'],
'text':
adventure['levels'][level].get('story_text', 'No Story Text'),
'start_code':
adventure['levels'][level].get('start_code', ''),
'loaded_program':
'' if not loaded_programs.get(short_name) else
loaded_programs.get(short_name)['code'],
'loaded_program_name':
'' if not loaded_programs.get(short_name) else
loaded_programs.get(short_name)['name']
})
# We create a 'level' pseudo assignment to store the loaded program for level mode, if any.
assignments.append({
'short_name':
'level',
'loaded_program':
'' if not loaded_programs.get('level') else
loaded_programs.get('level')['code'],
'loaded_program_name':
'' if not loaded_programs.get('level') else
loaded_programs.get('level')['name']
})
return assignments
def adventure_page(adventure_name, level):
user = current_user (request)
level = int (level)
adventures = load_adventure_for_language (requested_lang ())
# If requested adventure does not exist, return 404
if not adventure_name in adventures ['adventures']:
return 'No such Hedy adventure!', 404
adventure = adventures ['adventures'] [adventure_name]
# If no level is specified (this will happen if the last element of the path (minus the query parameter) is the same as the adventure_name)
if re.sub (r'\?.+', '', request.url.split ('/') [len (request.url.split ('/')) - 1]) == adventure_name:
# If user is logged in, check if they have a program for this adventure
# If there are many, note the highest level for which there is a saved program
desired_level = 0
if user ['username']:
existing_programs = db_get_many ('programs', {'username': user ['username']}, True)
for program in existing_programs:
if 'adventure_name' in program and program ['adventure_name'] == adventure_name and program ['level'] > desired_level:
desired_level = program ['level']
# If the user has a saved program for this adventure, redirect them to the level with the highest adventure
if desired_level != 0:
return redirect(request.url.replace ('/' + adventure_name, '/' + adventure_name + '/' + str (desired_level)), code=302)
# If user is not logged in, or has no saved programs for this adventure, default to the lowest level available for the adventure
if desired_level == 0:
for key in adventure ['levels'].keys ():
if type_check (key, 'int') and (desired_level == 0 or desired_level > key):
desired_level = key
level = desired_level
# If requested level is not in adventure, return 404
if not level in adventure ['levels']:
abort(404)
initialize_gfi_session(requested_lang())
adventure_assignments = load_adventure_assignments_per_level(requested_lang(), level)
g.prefix = '/hedy'
return hedyweb.render_assignment_editor(
request=request,
course=HEDY_COURSE[requested_lang()],
level_number=level,
assignment_number=1,
menu=render_main_menu('hedy'),
translations=TRANSLATIONS,
version=version(),
adventure_assignments=adventure_assignments,
# The relevant loaded program will be available to client-side js and it will be loaded by js.
loaded_program='',
loaded_program_name='',
adventure_name=adventure_name)
def programs_page(request):
username = current_user(request)['username']
if not username:
return "unauthorized", 403
lang = requested_lang()
query_lang = request.args.get('lang') or ''
if query_lang:
query_lang = '?lang=' + query_lang
texts = TRANSLATIONS.data[lang]['Programs']
result = db_get_many('programs', {'username': username}, True)
programs = []
now = timems()
for item in result:
measure = texts['minutes']
date = round((now - item['date']) / 60000)
if date > 90:
measure = texts['hours']
date = round(date / 60)
if date > 36:
measure = texts['days']
date = round(date / 24)
programs.append({
'id':
item['id'],
'code':
item['code'],
'date':
texts['ago-1'] + ' ' + str(date) + ' ' + measure + ' ' +
texts['ago-2'],
'level':
item['level'],
'name':
item['name']
})
return render_template('programs.html',
lang=requested_lang(),
menu=render_main_menu('programs'),
texts=texts,
auth=TRANSLATIONS.data[lang]['Auth'],
programs=programs,
username=username,
current_page='programs',
query_lang=query_lang)
def list_programs(user):
return {
'programs': db_get_many('programs', {'username': user['username']},
True)
}
def adventure_page(adventure_name, level):
user = current_user(request)
level = int(level)
adventures = load_adventure_for_language(requested_lang())
# If requested adventure does not exist, return 404
if not adventure_name in adventures['adventures']:
return 'No such Hedy adventure!', 404
adventure = adventures['adventures'][adventure_name]
loaded_program = ''
# If no level is specified (take last item of path and remove query parameter, if any, then compare to adventure_name)
if re.sub(r'\?.+', '',
request.url.split('/')[len(request.url.split('/')) -
1]) == adventure_name:
# If user is logged in, check if they have a program for this adventure
# If there are many, note the highest level for which there is a saved program
desired_level = 0
if user['username']:
existing_programs = db_get_many('programs',
{'username': user['username']},
True)
for program in existing_programs:
if 'adventure_name' in program and program[
'adventure_name'] == adventure_name and program[
'level'] > desired_level:
desired_level = program['level']
# If the user has a saved program for this adventure, redirect them to the level with the highest adventure
if desired_level != 0:
return redirect(request.url.replace(
'/' + adventure_name,
'/' + adventure_name + '/' + str(desired_level)),
code=302)
# If user is not logged in, or has no saved programs for this adventure, default to the lowest level available for the adventure
if desired_level == 0:
for key in adventure['levels'].keys():
if type_check(key, 'int') and (desired_level == 0
or desired_level > key):
desired_level = key
level = desired_level
# If a level is specified and user is logged in, check if there's a stored program available for this level
elif user['username']:
existing_programs = db_get_many('programs',
{'username': user['username']}, True)
for program in existing_programs:
if 'adventure_name' in program and program[
'adventure_name'] == adventure_name and program[
'level'] == level:
loaded_program = program['code']
# If requested level is not in adventure, return 404
if not level in adventure['levels']:
abort(404)
return hedyweb.render_adventure(adventure_name=adventure_name,
adventure=adventure,
course=HEDY_COURSE[requested_lang()],
request=request,
lang=requested_lang(),
level_number=level,
menu=render_main_menu('hedy'),
translations=TRANSLATIONS,
version=version(),
loaded_program=loaded_program)
