def registration_system():
current_user = get_jwt_identity()
if current_user[1] != 'Expert':
return jsonify("Access denied"), 403
system = manager.create_system_of_conclusions(request.json,
current_user[0])
return jsonify(manager.system_format_json_expert(system)), 200
def get_request_to_annotation(request_id):
current_user = get_jwt_identity()
annotated, text = annotation_manager.get_result_annotation(request_id)
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
return jsonify(annotation_manager.annotation_format_json(text,
annotated)), 200
def login_user():
user_id, token = manager_users.sign_in(request.json)
if user_id == -2:
return jsonify("The user does not exist"), 400
elif user_id == -1:
return jsonify("Wrong password"), 400
return jsonify({'token': token, 'id': user_id}), 200
def registration_testing_texts():
current_user = get_jwt_identity()
if current_user[1] != 'Researcher':
return jsonify("Access denied"), 403
text, annotation = models_manager.register_text_for_assessment(
request.json['text'], request.json['true_text'], current_user[0], 0)
return jsonify(models_manager.annotation_format_json(text,
annotation)), 200
def delete_text(text_id):
current_user = get_jwt_identity()
text = manager_texts.get_text(text_id)
if text is None:
return jsonify("The text does not exist"), 403
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
return {'success': 0 if manager_texts.delete_text(text) else 1}, 200
def delete_system(system_id):
current_user = get_jwt_identity()
if current_user[1] != 'Expert':
return jsonify("Access denied"), 403
system = manager.get_system(system_id)
if system.user_id != current_user[0] or system is None:
return jsonify("Access denied"), 403
return jsonify({'success': 1 if manager.delete_system(system) else 0}), 200
def get_all_texts():
current_user = get_jwt_identity()
if current_user[1] != "Admin":
return jsonify("Access denied"), 403
return jsonify([
manager_texts.text_format_json(text)
for text in manager_texts.get_list_all_texts()
]), 200
def update_text(text_id):
current_user = get_jwt_identity()
text = manager_texts.get_text(text_id)
if text is None:
return jsonify("The text does not exist"), 403
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
return manager_texts.text_format_json(
manager_texts.update_text(request.json, text)), 200
def get_cluster(request_id):
current_user = get_jwt_identity()
request_clustering, analysis = clustering_manager.get_clustering_analysis(
request_id)
if request_clustering.user_id != current_user[0]:
return jsonify("Access denied"), 403
return jsonify(
clustering_manager.clustering_request_format_json(
request_clustering, analysis)), 200
def get_testing_texts_all():
current_user = get_jwt_identity()
if current_user[1] != 'Researcher':
return jsonify("Access denied"), 403
texts = models_manager.get_list_texts_for_assessment(current_user[0])
return jsonify([
annotation_manager.annotation_format_json(text, text.annotate)
for text in texts
]), 200
def update_info_user(user_id):
current_user = get_jwt_identity()
if user_id != current_user[0] and current_user[1] != 'Admin':
return jsonify("Access denied"), 403
user = manager_users.get_user(user_id)
if user is None:
return jsonify("The user does not exist"), 403
return manager_users.user_format_json(
manager_users.update_user(user_id, request.json, user)), 200
def get_system(system_id):
current_user = get_jwt_identity()
if current_user[1] != 'Expert':
return jsonify("Access denied"), 403
system = manager.get_system(system_id)
if system is None:
return jsonify("Access denied"), 403
if system.user_id != current_user[0]:
return jsonify("Access denied"), 403
return jsonify(manager.system_format_json_expert(system)), 200
def update_role(user_id):
current_user = get_jwt_identity()
if current_user[1] != 'Admin':
return jsonify("Access denied"), 403
if not (request.json['role'] in ['User', 'Expert', 'Researcher', 'Admin']):
return jsonify("Error role"), 401
return {
'success':
0 if manager_users.update_role(user_id, request.json['role']) else 1
}, 200
def get_info_user(user_id):
current_user = get_jwt_identity()
if user_id != current_user[0] and current_user[1] != 'Admin':
return jsonify("Access denied"), 403
user_info = manager_users.get_user(user_id)
if user_info is None:
return jsonify("The user does not exist"), 403
user_format_dict = manager_users.user_format_json(user_info)
user_format_dict['role'] = current_user[1]
return user_format_dict, 200
def delete_test_text(text_test_id):
current_user = get_jwt_identity()
if current_user[1] != 'Researcher':
return jsonify("Access denied"), 403
text = models_manager.get_text_for_assessment(text_test_id)
if text is None:
return jsonify("The text does not exist"), 403
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
return models_manager.delete_text(text), 200
def update_system(system_id):
current_user = get_jwt_identity()
if current_user[1] != 'Expert':
return jsonify("Access denied"), 403
system = manager.get_system(system_id)
if system is None:
return jsonify("Access denied"), 403
if system.user_id != current_user[0]:
return jsonify("Access denied"), 403
return jsonify(
manager.system_format_json_expert(
manager.update_system_of_conclusions(system, request.json))), 200
def registering_request_to_annotation():
current_user = get_jwt_identity()
text = annotation_manager.get_text(request.json["text_id"])
if text is None:
return jsonify("The text does not exist"), 403
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
del text
run_create_annotation = Thread(
target=annotation_manager.request_for_annotation,
args=(request.json["text_id"], ))
run_create_annotation.start()
return jsonify({'success': 1}), 200
def update_test_text(text_test_id):
current_user = get_jwt_identity()
if current_user[1] != 'Researcher':
return jsonify("Access denied"), 403
text = models_manager.get_text_for_assessment(text_test_id)
if text is None:
return jsonify("The text does not exist"), 403
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
text_update, annotation = models_manager.update_text_for_assessment(
request.json, text)
return jsonify(
models_manager.annotation_format_json(text_update, annotation)), 200
def get_history_conclusion_for_system(system_id):
current_user = get_jwt_identity()
history = manager.get_history_request_system_of_conclusions(
current_user[0], system_id)
return jsonify([
manager.history_format_json(history_num) for history_num in history
]), 200
def get_word_cloud(request_id):
request_clustering = clustering_manager.request_for_topic_modeling(
request_id)
if request_clustering is None:
return jsonify("Access denied"), 403
return clustering_manager.clustering_request_format_json(
request_clustering, []), 200
def get_clusters():
current_user = get_jwt_identity()
return jsonify([
clustering_manager.clustering_request_format_json(request_, [])
for request_ in clustering_manager.get_all_request_clustering(
current_user[0])
]), 200
def get_annotation_texts():
current_user = get_jwt_identity()
result = annotation_manager.get_list_request_for_annotation(
current_user[0])
print(result)
return jsonify([
annotation_manager.annotation_format_json(text, text.annotate)
for text in result
]), 200
def delete_request_clustering(request_id):
current_user = get_jwt_identity()
request_clustering = clustering_manager.get_request_clastering(request_id)
if request_clustering.id != current_user[0]:
return jsonify("Access denied"), 403
return {
'success':
0 if clustering_manager.delete_request_clustering(request_clustering)
else 1
}, 200
def get_text(text_id):
current_user = get_jwt_identity()
text = manager_texts.get_text(text_id)
if text.user_id != current_user[0]:
return jsonify("Access denied"), 403
return jsonify(manager_texts.text_format_json(text)), 200
def get_conclusion(system_id):
current_user = get_jwt_identity()
recommendation = manager.make_fuzzy_conclusion(current_user[0], system_id,
request.json['input'])
return jsonify({'recommendation': recommendation}), 200
def delete_request_to_annotation(request_id):
return jsonify({
'success':
0 if annotation_manager.delete_request_annotation(request_id) else 1
}), 200
def delete_user(user_id):
current_user = get_jwt_identity()
if user_id != current_user[0] and current_user[1] != 'Admin':
return jsonify("Access denied"), 403
return {'success': 0 if manager_users.delete_user(user_id) else 1}, 200
def get_quality_model():
current_user = get_jwt_identity()
if current_user[1] != 'Researcher':
return jsonify("Access denied"), 403
return jsonify({'quality':
models_manager.get_quality(0, current_user[0])}), 200
def registration_user():
user = manager_users.create_user(request.json)
if user is None:
return jsonify("Bad request"), 400
return jsonify(manager_users.user_format_json(user)), 201
def get_all_user_texts():
current_user = get_jwt_identity()
return jsonify([{
"id": text.id,
"text": text.text
} for text in manager_texts.get_list_of_texts(current_user[0])]), 200
