def get_category_data(id):
category = tesla_db.learners.get_send_category(id)
if category is None:
api_response(TESLA_API_STATUS_CODE.REQUEST_NOT_FOUND, http_code=404)
data = decode_data(category.data)
return api_response(TESLA_API_STATUS_CODE.SUCCESS, {
'id': category.id,
'description': category.description,
'data': data
})
def get_vle_data(id):
vle = tesla_db.vle.get_vle(id)
if vle is None:
return api_response(TESLA_API_STATUS_CODE.REQUEST_NOT_FOUND,
http_code=404)
return api_response(
TESLA_API_STATUS_CODE.SUCCESS, {
'id': vle.id,
'vle_id': vle.vle_id,
'url': vle.url,
'token': vle.token,
'name': vle.name
})
def rt_stats():
stats = {
'learners': {
'total': tesla_db.learners.get_num_learners(),
'ic_ok': tesla_db.learners.get_num_learners_valid_ic(),
'no_ic': tesla_db.learners.get_num_learners_no_ic(),
'ic_rejected': tesla_db.learners.get_num_learners_rejected_ic(),
'ic_outdated': tesla_db.learners.get_num_learners_outdated_ic()
},
'requests': {
'enrolment': {
'pending': tesla_db.requests.get_num_requests_pending(True),
'processed':
tesla_db.requests.get_num_requests_processed(True),
'failed': tesla_db.requests.get_num_requests_failed(True)
},
'verification': {
'pending': tesla_db.requests.get_num_requests_pending(False),
'processed':
tesla_db.requests.get_num_requests_processed(False),
'failed': tesla_db.requests.get_num_requests_failed(False)
}
}
}
return api_response(TESLA_API_STATUS_CODE.SUCCESS, {
'timestamp': datetime.now(),
'stats': stats
})
def activity_stats(activity_id):
stats = {
#'num_learners': 0tesla_db.statistics.num_learners_course(course_id),
#'num_instruments': tesla_db.statistics.num_activities_course(course_id)
}
return api_response(TESLA_API_STATUS_CODE.SUCCESS, {'stats': stats})
def course_stats(course_id):
stats = {
'num_learners': tesla_db.statistics.num_learners_course(course_id),
'num_activities': tesla_db.statistics.num_activities_course(course_id)
}
return api_response(TESLA_API_STATUS_CODE.SUCCESS, {'stats': stats})
def get_learner_data_summary(tesla_id):
summary = {
'tesla_id': tesla_id,
'courses': tesla_db.learners.count_learner_courses(tesla_id),
'activities': tesla_db.learners.count_learner_activities(tesla_id)
}
return api_response(TESLA_API_STATUS_CODE.SUCCESS, summary)
def course_activity(course_id, activity_id):
if request.method == "DELETE":
tesla_db.courses.delete_activity(course_id, activity_id)
if request.method == "POST":
tesla_db.courses.add_activity(course_id, activity_id)
return api_response(TESLA_API_STATUS_CODE.SUCCESS)
def management_environment(type, id):
permitted_types = ["module", "service"]
if type not in permitted_types:
return api_response(TESLA_API_STATUS_CODE.BAD_REQUEST,
data={"message": "invalid type"},
http_code=400)
config_from_service_keys = []
all_config = {"dependencies": {}, "config": []}
config_icons = {}
if type == 'module':
config_obj = get_config_repository().get_module_config(id)
services_dependencies = []
if config_obj.get_module_dependencies() is not None:
services_dependencies = config_obj.get_module_dependencies(
)['services']
for service_dependency in services_dependencies:
configs_service_dependency = config_obj.get_service_config(
service_dependency)
if service_dependency not in all_config['dependencies'].keys():
all_config['dependencies'][service_dependency] = []
config_icons[service_dependency] = EnvClassify().get_icon(
type="service", service_name=service_dependency)
for (config_service_dependency_key, config_service_dependency_value
) in configs_service_dependency.items():
config_from_service_keys.append(config_service_dependency_key)
aux = EnvClassify().get_info(type="service",
service_name=service_dependency,
key=config_service_dependency_key)
aux['value'] = config_service_dependency_value
all_config['dependencies'][service_dependency].append(aux)
else:
config_obj = get_config_repository().get_service_config(id)
configs = config_obj.get_config()
for (key, value) in configs.items():
if key not in config_from_service_keys:
aux = EnvClassify().get_info(type=type, service_name=id, key=key)
aux['value'] = value
all_config['config'].append(aux)
return render_template('configuration/modal_environment.html',
all_config=all_config,
config_icons=config_icons,
type=type,
id=id)
def get_course_data(id):
course = tesla_db.courses.get_course(id)
if course is None:
return api_response(TESLA_API_STATUS_CODE.REQUEST_NOT_FOUND,
http_code=404)
parent_id = -1
if course.parent_id is not None:
parent_id = course.parent_id
return api_response(
TESLA_API_STATUS_CODE.SUCCESS, {
'id': course.id,
'description': course.description,
'code': course.code,
'start': course.start,
'end': course.end,
'vle_id': course.vle_id,
'vle_course_id': course.vle_course_id,
'parent_id': parent_id
})
def delete_learner(tesla_id):
# Create a new task
new_task = tesla_db.tasks.create_task(type="DELETE_LEARNER_DATA",
user_id=current_user.id)
tasks.delete_learner_data.apply_async([new_task.id, tesla_id], priority=5)
# Create a message to the user
tesla_db.users.create_message(
user_id=current_user.id,
type=TESLA_MESSAGE_TYPE.TASK_CREATED,
subject=gettext('New task created'),
content=gettext(
"A new task to delete all data from user %(value)s has been created. This can take several hours depending on the system load. You will be notified.",
value=tesla_id))
return api_response(TESLA_API_STATUS_CODE.SUCCESS)
def management_environment_save(type, id):
permitted_types = ["module", "service"]
if type not in permitted_types:
return api_response(TESLA_API_STATUS_CODE.BAD_REQUEST,
data={"message": "invalid type"},
http_code=400)
config_from_service_keys = []
if type == 'module':
config_obj = get_config_repository().get_module_config(id)
services_dependencies = config_obj.get_module_dependencies(
)['services']
for service_dependency in services_dependencies:
service_dependency_aux = {}
configs_service_dependency = config_obj.get_service_config(
service_dependency)
for (config_service_dependency_key, config_service_dependency_value
) in configs_service_dependency.items():
config_from_service_keys.append(config_service_dependency_key)
value = request.form.get('dependencies[' +
str(service_dependency) + "][" +
str(config_service_dependency_key) +
"]")
service_dependency_aux[config_service_dependency_key] = value
config_obj.set_service_config(service_dependency,
service_dependency_aux)
else:
config_obj = get_config_repository().get_service_config(id)
configs = config_obj.get_config()
for (key, value) in configs.items():
if key not in config_from_service_keys:
value = request.form.get("general[" + str(key) + "]")
config_obj.set_value(key, value)
flash('Data saved', 'success')
return redirect(url_for('system.configuration'))
def get_learner_categories(tesla_id):
categories = tesla_db.learners.get_send_user(tesla_id)
instruments = set()
options = set()
cat = []
for c in categories:
data = decode_data(c.data)
c.data = data
instruments.update(data['instruments'])
options.update(data['options'])
cat.append(c.id)
return api_response(
TESLA_API_STATUS_CODE.SUCCESS, {
"categories": cat,
"instruments": list(instruments),
"options": list(options)
})
def instrument_status():
instruments = tesla_db.instruments.get_instrument_status()
ret_val = []
for inst in instruments:
service_info = None
if inst.InstrumentQueue.service_info is not None:
service_info = json.loads(inst.InstrumentQueue.service_info)
updated = inst.InstrumentQueue.created
if inst.InstrumentQueue.updated is not None:
updated = inst.InstrumentQueue.updated
ret_val.append({
'acronym': inst.Instrument.acronym,
'pending': inst.InstrumentQueue.pending_tasks,
'd1': inst.InstrumentQueue.tendency1,
'd2': inst.InstrumentQueue.tendency2,
'workers': inst.InstrumentQueue.consumers,
'active': inst.Instrument.active,
'service': inst.InstrumentQueue.service,
'service_info': service_info,
'updated': updated
})
return api_response(TESLA_API_STATUS_CODE.SUCCESS, {'status': ret_val})
