def check_task_access(task_id: str) -> bool:
user_session = SessionsDBManager().get_session(
session.get('session_id', None),
session.get('consumer_key', None),
)
if check_admin():
return True
else:
return task_id in user_session['tasks'] or is_testing_active()
def emit(self, record):
if not record.msg or is_testing_active():
return
LogsDBManager().add_log(timestamp=datetime.now(),
serviceName=self.service_name,
levelname=record.levelname,
levelno=record.levelno,
message=self.format(record),
pathname=record.pathname,
filename=record.filename,
funcName=record.funcName,
lineno=record.lineno)
def grade_passback(self, task_attempt_db, training_id, is_retry):
params_for_passback = task_attempt_db.params_for_passback
consumer_secret = ConsumersDBManager().get_secret(
params_for_passback['oauth_consumer_key'])
training_count = task_attempt_db.training_count
if training_count == 0:
normalized_score = 0
else:
scores = list(task_attempt_db.training_scores.values())
total_score = sum(
[score if score is not None else 0 for score in scores])
normalized_score = total_score / training_count
response = ToolProvider.from_unpacked_request(
secret=consumer_secret,
params=params_for_passback,
headers=None,
url=None).post_replace_result(score=normalized_score)
logger.info('task_attempt_id = {}, scores = {}'.format(
task_attempt_db.pk, task_attempt_db.training_scores))
if is_testing_active(
) or response.code_major == 'success' and response.severity == 'status':
TaskAttemptsDBManager().set_pass_back_status(
task_attempt_db, training_id, PassBackStatus.SUCCESS)
logger.info(
'Score was successfully passed back: score = {}, task_attempt_id = {}, training_id = {},'
'training_count = {}'.format(normalized_score,
task_attempt_db.pk, training_id,
training_count))
else:
TaskAttemptsDBManager().set_pass_back_status(
task_attempt_db, training_id, PassBackStatus.FAILED)
logger.warning(
'Score pass back failed: score = {}, training_count = {}, task_attempt_id = {}.\n'
'{} {} {}'.format(
normalized_score,
training_count,
task_attempt_db.pk,
training_id,
response.description,
response.response_code,
response.code_major,
))
if not is_retry:
TaskAttemptsToPassBackDBManager(
).add_task_attempt_to_pass_back(
task_attempt_db.pk,
training_id,
is_retry=True,
)
logger.warning(
'Resubmitted task attempt with task_attempt_id = {} and training_id = {}'
.format(task_attempt_db.pk, training_id))
def init():
"""
Route for session initialization. Enabled only if is_testing_active returns True.
:return: Empty dictionary
"""
from app.utils import is_testing_active
if not is_testing_active():
return {}, 200
session['session_id'] = Config.c.testing.session_id
session['full_name'] = Config.c.testing.lis_person_name_full
session['consumer_key'] = Config.c.testing.oauth_consumer_key
session['task_id'] = Config.c.testing.custom_task_id
session['criteria_pack_id'] = Config.c.testing.custom_criteria_pack_id
session[
'feedback_evaluator_id'] = Config.c.testing.custom_feedback_evaluator_id
session['formats'] = list(
set(Config.c.testing.custom_formats.split(','))
& ALLOWED_EXTENSIONS) or [DEFAULT_EXTENSION]
from app.mongo_odm import TasksDBManager, TaskAttemptsDBManager
session['task_attempt_id'] = str(TaskAttemptsDBManager().add_task_attempt(
username=session['session_id'],
task_id=session['task_id'],
params_for_passback={
'lis_outcome_service_url':
Config.c.testing.lis_outcome_service_url,
'lis_result_sourcedid': Config.c.testing.lis_result_source_did,
'oauth_consumer_key': Config.c.testing.oauth_consumer_key,
},
training_count=3,
).pk)
TasksDBManager().add_task_if_absent(
Config.c.testing.custom_task_id,
Config.c.testing.custom_task_description,
int(Config.c.testing.custom_attempt_count),
float(Config.c.testing.custom_required_points),
Config.c.testing.custom_criteria_pack_id,
)
return {}, 200
def check_auth() -> Optional[Sessions]:
if not is_testing_active():
return _check_auth()
else:
return _check_auth_testing()
def check_access(filters: dict) -> bool:
if not is_testing_active():
return _check_access(filters)
else:
return _check_access_testing(filters)