def report_client_exception():
post_body = request.json
querylog.log_value(session=session_id(),
date=str(datetime.datetime.now()),
client_error=post_body,
version=version(),
username=current_user(request)['username'] or None,
is_test=1 if os.getenv('IS_TEST_ENV') else None)
return 'logged', 500
def report_client_exception():
post_body = request.json
querylog.log_value(session=session_id(),
date=str(datetime.datetime.now()),
client_error=post_body,
version=version(),
username=current_user(request)['username'] or None,
is_test=1 if os.getenv('IS_TEST_ENV') else None)
# Return a 500 so the HTTP status codes will stand out in our monitoring/logging
return 'logged', 500
def test_emergency_recovery(self):
querylog.begin_global_log_record(banaan='geel')
querylog.log_value(bloem='rood')
querylog.emergency_shutdown()
recovered_queue = log_queue.LogQueue('querylog', batch_window_s=300)
recovered_queue.try_load_emergency_saves()
recovered_queue.set_transmitter(self._fake_transmitter)
self.assertEqual(self.records, [])
recovered_queue.transmit_now()
self.assertEqual(self.records[0]['banaan'], 'geel')
self.assertEqual(self.records[0]['bloem'], 'rood')
self.assertEqual(self.records[0]['terminated'], True)
def parse():
body = request.json
if not body:
return "body must be an object", 400
if 'code' not in body:
return "body.code must be a string", 400
if 'level' not in body:
return "body.level must be a string", 400
if 'sublevel' in body and not type_check(body['sublevel'], 'int'):
return "If present, body.sublevel must be an integer", 400
if 'adventure_name' in body and not type_check(body['adventure_name'],
'str'):
return "if present, body.adventure_name must be a string", 400
code = body['code']
level = int(body['level'])
sublevel = body.get('sublevel') or 0
# Language should come principally from the request body,
# but we'll fall back to browser default if it's missing for whatever
# reason.
lang = body.get('lang', requested_lang())
response = {}
username = current_user(request)['username'] or None
querylog.log_value(level=level,
lang=lang,
session_id=session_id(),
username=username)
# Check if user sent code
if not code:
response["Error"] = "no code found, please send code."
# is so, parse
else:
try:
hedy_errors = TRANSLATIONS.get_translations(
lang, 'HedyErrorMessages')
with querylog.log_time('transpile'):
result = hedy.transpile(code, level, sublevel)
response["Code"] = "# coding=utf8\nimport random\n" + result
except hedy.HedyException as E:
traceback.print_exc()
# some 'errors' can be fixed, for these we throw an exception, but also
# return fixed code, so it can be ran
if E.args[0] == "Invalid Space":
error_template = hedy_errors[E.error_code]
response[
"Code"] = "# coding=utf8\n" + E.arguments['fixed_code']
response["Warning"] = error_template.format(**E.arguments)
elif E.args[0] == "Parse":
error_template = hedy_errors[E.error_code]
# Localize the names of characters. If we can't do that, just show the original
# character.
if 'character_found' in E.arguments.keys():
E.arguments['character_found'] = hedy_errors.get(
E.arguments['character_found'],
E.arguments['character_found'])
elif 'keyword_found' in E.arguments.keys():
#if we find an invalid keyword, place it in the same location in the error message but without translating
E.arguments['character_found'] = E.arguments[
'keyword_found']
response["Error"] = error_template.format(**E.arguments)
elif E.args[0] == "Unquoted Text":
error_template = hedy_errors[E.error_code]
response["Error"] = error_template.format(**E.arguments)
else:
error_template = hedy_errors[E.error_code]
response["Error"] = error_template.format(**E.arguments)
except Exception as E:
traceback.print_exc()
print(f"error transpiling {code}")
response["Error"] = str(E)
querylog.log_value(server_error=response.get('Error'))
parse_logger.log({
'session': session_id(),
'date': str(datetime.datetime.now()),
'level': level,
'lang': lang,
'code': code,
'server_error': response.get('Error'),
'version': version(),
'username': username,
'is_test': 1 if os.getenv('IS_TEST_ENV') else None,
'adventure_name': body.get('adventure_name', None)
})
return jsonify(response)
def after_request_log_status(response):
querylog.log_value(http_code=response.status_code)
return response
def parse():
body = request.json
if not body:
return "body must be an object", 400
if 'code' not in body:
return "body.code must be a string", 400
if 'level' not in body:
return "body.level must be a string", 400
if 'sublevel' in body and not type_check (body ['sublevel'], 'int'):
return "If present, body.sublevel must be an integer", 400
if 'adventure_name' in body and not type_check (body ['adventure_name'], 'str'):
return "if present, body.adventure_name must be a string", 400
code = body ['code']
level = int(body ['level'])
sublevel = body.get ('sublevel') or 0
# Language should come principally from the request body,
# but we'll fall back to browser default if it's missing for whatever
# reason.
lang = body.get('lang', requested_lang())
querylog.log_value(level=level, lang=lang)
response = {}
username = current_user(request) ['username'] or None
querylog.log_value(level=level, lang=lang, session_id=session_id(), username=username)
# Check if user sent code
if not code:
response["Error"] = "no code found, please send code."
# is so, parse
else:
try:
hedy_errors = TRANSLATIONS.get_translations(lang, 'HedyErrorMessages')
gradual_feedback = TRANSLATIONS.get_translations(lang, 'GradualFeedback')
with querylog.log_time('transpile'):
result = hedy.transpile(code, level,sublevel)
response["Code"] = "# coding=utf8\nimport random\n" + result
if gfi_support(lang):
if not (('error_level' in session) or ('similar_code' in session)):
return 'session cookie must have error_level & similar_code set', 400
response['prev_feedback_level'] = session['error_level']
response['prev_similar_code'] = session['similar_code']
session ['error_level'] = 0 # Code is correct: reset error_level back to 0
except hedy.HedyException as E:
traceback.print_exc()
# some 'errors' can be fixed, for these we throw an exception, but also
# return fixed code, so it can be ran
if E.args[0] == "Invalid Space":
error_template = hedy_errors[E.error_code]
response["Code"] = "# coding=utf8\n" + E.arguments['fixed_code']
response["Warning"] = error_template.format(**E.arguments)
elif E.args[0] == "Parse":
error_template = hedy_errors[E.error_code]
# Localize the names of characters
if 'character_found' in E.arguments:
E.arguments['character_found'] = hedy_errors[E.arguments['character_found']]
response["Error"] = error_template.format(**E.arguments)
elif E.args[0] == "Unquoted Text":
error_template = hedy_errors[E.error_code]
response["Error"] = error_template.format(**E.arguments)
else:
error_template = hedy_errors[E.error_code]
response["Error"] = error_template.format(**E.arguments)
if gfi_support(lang):
response.update(gradual_feedback_model(code, level, gradual_feedback, lang, E, hedy_exception=True))
except Exception as E:
traceback.print_exc()
print(f"error transpiling {code}")
response["Error"] = str(E)
if gfi_support(lang):
response.update(gradual_feedback_model(code, level, gradual_feedback, lang, E, hedy_exception=False))
if gfi_support(lang):
session ['code'] = code
querylog.log_value(server_error=response.get('Error'))
parse_logger.log ({
'session': session_id(),
'date': str(datetime.datetime.now()),
'level': level,
'lang': lang,
'code': code,
'server_error': response.get('Error'),
'version': version(),
'username': username,
'feedback_level': session['error_level'] if gfi_support (lang) else None,
'GFM': True if gfi_support (lang) else False,
'is_test': 1 if os.getenv('IS_TEST_ENV') else None,
'adventure_name': body.get('adventure_name', None)
})
return jsonify(response)
def parse():
body = request.json
if not body:
return "body must be an object", 400
if 'code' not in body:
return "body.code must be a string", 400
if 'level' not in body:
return "body.level must be a string", 400
if 'adventure_name' in body and not isinstance(body['adventure_name'],
str):
return "if present, body.adventure_name must be a string", 400
code = body['code']
level = int(body['level'])
# Language should come principally from the request body,
# but we'll fall back to browser default if it's missing for whatever
# reason.
lang = body.get('lang', requested_lang())
# true if kid enabled the read aloud option
read_aloud = body.get('read_aloud', False)
response = {}
username = current_user(request)['username'] or None
querylog.log_value(level=level,
lang=lang,
session_id=session_id(),
username=username)
try:
hedy_errors = TRANSLATIONS.get_translations(lang, 'HedyErrorMessages')
with querylog.log_time('transpile'):
transpile_result = hedy.transpile(code, level)
python_code = transpile_result.code
has_turtle = transpile_result.has_turtle
response['has_turtle'] = has_turtle
if has_turtle:
response["Code"] = textwrap.dedent("""\
# coding=utf8
import random, time, turtle
t = turtle.Turtle()
t.hideturtle()
t.speed(0)
t.penup()
t.goto(50,100)
t.showturtle()
t.pendown()
t.speed(3)
""") + python_code
else:
response["Code"] = "# coding=utf8\nimport random\n" + python_code
except hedy.InvalidSpaceException as ex:
traceback.print_exc()
response = invalid_space_error_to_response(ex, hedy_errors)
except hedy.ParseException as ex:
traceback.print_exc()
response = parse_error_to_response(ex, hedy_errors)
except hedy.HedyException as ex:
traceback.print_exc()
response = hedy_error_to_response(ex, hedy_errors)
except Exception as E:
traceback.print_exc()
print(f"error transpiling {code}")
response["Error"] = str(E)
querylog.log_value(server_error=response.get('Error'))
parse_logger.log({
'session': session_id(),
'date': str(datetime.datetime.now()),
'level': level,
'lang': lang,
'code': code,
'server_error': response.get('Error'),
'version': version(),
'username': username,
'read_aloud': read_aloud,
'is_test': 1 if os.getenv('IS_TEST_ENV') else None,
'adventure_name': body.get('adventure_name', None)
})
return jsonify(response)