def api_put_speech_part_type(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
try:
modified_data = []
for speech_part_type in data:
a = SpeechPartType.query.filter(
SpeechPartType.id == speech_part_type.get('id')).one()
a.label = speech_part_type.get("label")
a.lang_code = speech_part_type.get("lang_code")
a.description = speech_part_type.get("description")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
print(str(e), speech_part_type)
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("SpeechPartType not found")
def api_put_tradition(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
modified_data = []
try:
for tradition in data:
a = Tradition.query.filter(
Tradition.id == tradition.get('id', None)).one()
a.label = tradition.get("label")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("Tradition not found")
def api_delete_documents_transcriptions_alignments_images(
api_version, doc_id, anno_id):
"""
:param api_version:
:param doc_id:
:param user_id:
:return:
"""
transcription = get_reference_transcription(doc_id)
if transcription is None:
return make_404()
manifest_url = Image.query.filter(
Image.doc_id == doc_id).first().manifest_url
alignments = AlignmentImage.query.filter(
AlignmentImage.transcription_id == transcription.id,
AlignmentImage.user_id == transcription.user_id,
AlignmentImage.manifest_url == manifest_url,
AlignmentImage.zone_id == anno_id).all()
if len(alignments) > 0:
try:
for al in alignments:
db.session.delete(al)
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def api_put_district(api_version, country_id):
c = Country.query.filter(Country.id == country_id).first()
if c is None:
return make_404("Country does not exist")
try:
data = request.get_json()
if "data" in data:
data = data["data"]
modified_data = []
try:
for district in data:
a = District.query.filter(
District.country_id == country_id,
District.id == district.get('id', None)).one()
a.label = district.get("label")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("District not found")
def api_put_acte_type(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
try:
modified_data = []
for acte_type in data:
a = ActeType.query.filter(ActeType.id == acte_type.get('id')).one()
a.label = acte_type.get("label")
a.description = acte_type.get("description")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("ActeType not found")
def api_delete_speechparts_alignments(api_version, doc_id, user_id):
from app.api.transcriptions.routes import get_reference_transcription
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if forbid:
return forbid
transcription = get_reference_transcription(doc_id)
if transcription is None:
return make_404(details="Transcription not found")
try:
# TRUNCATE
for old_al in AlignmentDiscours.query.filter(
AlignmentDiscours.transcription_id == transcription.id,
AlignmentDiscours.user_id == user_id).all():
db.session.delete(old_al)
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200(data=[])
def api_documents_manifest(api_version, doc_id):
try:
manifest = make_manifest(api_version, doc_id)
manifest["@id"] = request.base_url
return manifest
except Exception as e:
return make_400(str(e))
def api_put_institution(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
modified_data = []
try:
for institution in data:
a = Institution.query.filter(
Institution.id == institution.get('id')).one()
a.ref = institution.get("ref")
a.name = institution.get("name")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("Institution not found")
def api_documents_delete_annotation(api_version, doc_id, zone_id):
"""
:param api_version:
:param doc_id:
:param zone_id:
:return:
"""
try:
img = Image.query.filter(Image.doc_id == doc_id).first()
anno_to_delete = ImageZone.query.filter(
ImageZone.zone_id == zone_id,
ImageZone.manifest_url == img.manifest_url,
ImageZone.canvas_idx == img.canvas_idx,
ImageZone.img_idx == img.img_idx
).first()
print('anno to delete', anno_to_delete)
if anno_to_delete is None:
raise Exception('annotation %s not found ' % zone_id)
db.session.delete(anno_to_delete)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_400(details="Cannot delete the annotation %s : %s" % (zone_id, str(e)))
return make_200()
def api_put_country(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
try:
modified_data = []
for country in data:
a = Country.query.filter(
Country.id == country.get('id', None)).one()
a.label = country.get("label")
a.ref = country.get("ref")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("Country not found")
def api_put_language(api_version):
try:
data = request.get_json()
if "data" in data:
data = data["data"]
modified_data = []
try:
for language in data:
a = Language.query.filter(
Language.code == language.get('code', None)).one()
a.label = language.get("label")
db.session.add(a)
modified_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_409(str(e))
return make_200([d.serialize() for d in modified_data])
else:
return make_400("no data")
except NoResultFound:
return make_404("Language not found")
def invite_user(api_version):
json = request.get_json(force=True)
email = json.get('email', None)
role = json.get('role', 'student')
if email is None:
print("Email unknown")
return make_401("Email unknown")
username = email.split('@')[0]
password = ''.join(choice(string.ascii_letters)
for i in range(5)) + str(randint(1, 100)).zfill(3)
msg = Message('Contribute to Adele',
sender=current_app.config['MAIL_USERNAME'],
recipients=[email])
msg.body = "Vous avez été invité(e) à contribuer au projet Adele (" \
"https://dev.chartes.psl.eu/adele/profile).\nIdentifiant: %s\nMot de passe: %s\nN'oubliez pas de " \
"changer votre mot de passe après votre première connexion !" % (email, password)
print(email, role)
print(msg.body)
try:
new_user = User(username=username,
password=generate_password_hash(password),
email=email,
first_name=username,
last_name=username,
active=True,
email_confirmed_at=datetime.datetime.now())
print('checkpassword:'******'student', 'teacher', 'admin'):
role = 'student'
if role == 'admin':
new_user.roles = Role.query.filter(Role.id >= 1).all()
elif role == 'student':
new_user.roles = Role.query.filter(Role.id == 2).all()
elif role == 'teacher':
new_user.roles = Role.query.filter(Role.id >= 2).all()
db.session.add(new_user)
db.session.commit()
except Exception as e:
print(f'cannot invite user ({username}, {email}): {str(e)}')
db.session.rollback()
return make_400("Cannot invite user: %s" % str(e))
mail.send(msg)
return make_200(msg)
def clone_commentary(doc_id, user_id, type_id):
com_to_be_cloned = Commentary.query.filter(
Commentary.user_id == user_id, Commentary.doc_id == doc_id,
Commentary.type_id == type_id).first()
if not com_to_be_cloned:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(
current_app,
Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
teacher = current_app.get_current_user()
teacher_com = Commentary.query.filter(Commentary.user_id == teacher.id,
Commentary.type_id == type_id,
Commentary.doc_id == doc_id).first()
if teacher_com is None:
teacher_com = Commentary(doc_id=doc_id,
user_id=teacher.id,
content=com_to_be_cloned.content)
else:
# replace the teacher's com content
teacher_com.content = com_to_be_cloned.content
# remove the old teacher's notes
# for note in teacher_com.notes:
# # MUST delete commentary_has_note and not the note itself
# # (since the latest might be used somewhere else)!
for chn in CommentaryHasNote.query.filter(
CommentaryHasNote.commentary_id == teacher_com.id).all():
db.session.delete(chn)
# clone notes
for chn_to_be_cloned in com_to_be_cloned.commentary_has_note:
note = Note(type_id=chn_to_be_cloned.note.type_id,
user_id=teacher.id,
content=chn_to_be_cloned.note.content)
db.session.add(note)
db.session.flush()
teacher_com.transcription_has_note.append(
CommentaryHasNote(ptr_start=chn_to_be_cloned.ptr_start,
ptr_end=chn_to_be_cloned.ptr_end,
note_id=note.id,
commentary_id=teacher_com.id), )
db.session.add(teacher_com)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def api_post_acte_type(api_version):
data = request.get_json()
if "data" in data:
data = data["data"]
created_data = []
try:
for acte_type in data:
a = ActeType(**acte_type)
db.session.add(a)
created_data.append(a)
db.session.commit()
except Exception as e:
db.session.rollback()
return make_400(str(e))
return make_200([d.serialize() for d in created_data])
else:
return make_400("no data")
def api_post_translation_alignments(api_version, doc_id, user_id):
"""
NB: Posting alignment has a 'TRUNCATE AND REPLACE' effect
"""
from app.api.transcriptions.routes import get_reference_transcription
from app.api.translations.routes import get_translation
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if forbid:
return forbid
transcription = get_reference_transcription(doc_id)
if transcription is None:
return make_404(details="Transcription not found")
translation = get_translation(doc_id=doc_id, user_id=user_id)
if translation is None:
return make_404(details="Translation not found")
data = request.get_json()
data = data.get("data", [])
ptrs = []
try:
# TRUNCATE
for old_al in AlignmentTranslation.query.filter(
AlignmentTranslation.transcription_id == transcription.id,
AlignmentTranslation.translation_id == translation.id).all():
db.session.delete(old_al)
# INSERT
for (ptr_transcription_start, ptr_transcription_end,
ptr_translation_start, ptr_translation_end) in data:
new_al = AlignmentTranslation(
transcription_id=transcription.id,
translation_id=translation.id,
ptr_transcription_start=ptr_transcription_start,
ptr_transcription_end=ptr_transcription_end,
ptr_translation_start=ptr_translation_start,
ptr_translation_end=ptr_translation_end)
db.session.add(new_al)
ptrs.append(
(new_al.ptr_transcription_start, new_al.ptr_transcription_end,
new_al.ptr_translation_start, new_al.ptr_translation_end))
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200(data=ptrs)
def clone_translation_alignments(doc_id, old_user_id, user_id):
old_tr = Transcription.query.filter(
Transcription.user_id == old_user_id,
Transcription.doc_id == doc_id).first()
old_tl = Translation.query.filter(Translation.user_id == old_user_id,
Translation.doc_id == doc_id).first()
new_tr = Transcription.query.filter(
Transcription.user_id == user_id,
Transcription.doc_id == doc_id).first()
new_tl = Translation.query.filter(Translation.user_id == user_id,
Translation.doc_id == doc_id).first()
if not old_tr or not old_tl or not new_tr or not new_tl:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(
current_app,
Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
# clone translation alignments
old_alignments = AlignmentTranslation.query.filter(
AlignmentTranslation.transcription_id == old_tr.id,
AlignmentTranslation.translation_id == old_tl.id,
).all()
new_alignments = [
AlignmentTranslation(
transcription_id=new_tr.id,
translation_id=new_tl.id,
ptr_transcription_start=ol.ptr_transcription_start,
ptr_transcription_end=ol.ptr_transcription_end,
ptr_translation_start=ol.ptr_translation_start,
ptr_translation_end=ol.ptr_translation_end)
for ol in old_alignments
]
db.session.bulk_save_objects(new_alignments)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def api_delete_editor(api_version, editor_id=None):
if editor_id is None:
editors = Editor.query.all()
else:
editors = Editor.query.filter(Editor.id == editor_id).all()
for a in editors:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def api_delete_tradition(api_version, tradition_id=None):
if tradition_id is None:
traditions = Tradition.query.all()
else:
traditions = Tradition.query.filter(Tradition.id == tradition_id).all()
for a in traditions:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def api_delete_language(api_version, language_code=None):
if language_code is None:
languages = Language.query.all()
else:
languages = Language.query.filter(Language.code == language_code).all()
for a in languages:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def clone_transcription(doc_id, user_id):
print("cloning transcription (doc %s) from user %s" % (doc_id, user_id))
tr_to_be_cloned = Transcription.query.filter(Transcription.user_id == user_id,
Transcription.doc_id == doc_id).first()
if not tr_to_be_cloned:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(current_app, Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
teacher = current_app.get_current_user()
teacher_tr = Transcription.query.filter(Transcription.user_id == teacher.id,
Transcription.doc_id == doc_id).first()
if teacher_tr is None:
teacher_tr = Transcription(doc_id=doc_id, user_id=teacher.id, content=tr_to_be_cloned.content)
else:
# replace the teacher's tr content
teacher_tr.content = tr_to_be_cloned.content
# remove the old teacher's notes
for note in teacher_tr.notes:
db.session.delete(note)
# teacher_tr.notes = []
# clone notes
for thn_to_be_cloned in tr_to_be_cloned.transcription_has_note:
note = Note(type_id=thn_to_be_cloned.note.type_id, user_id=teacher.id,
content=thn_to_be_cloned.note.content)
db.session.add(note)
db.session.flush()
teacher_tr.transcription_has_note.append(
TranscriptionHasNote(ptr_start=thn_to_be_cloned.ptr_start,
ptr_end=thn_to_be_cloned.ptr_end,
note_id=note.id,
transcription_id=teacher_tr.id),
)
db.session.add(teacher_tr)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def api_delete_speech_part_type(api_version, speech_part_type_id=None):
if speech_part_type_id is None:
speech_part_types = SpeechPartType.query.all()
else:
speech_part_types = SpeechPartType.query.filter(
SpeechPartType.id == speech_part_type_id).all()
for a in speech_part_types:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def api_delete_acte_type(api_version, acte_type_id=None):
if acte_type_id is None:
acte_types = ActeType.query.all()
else:
acte_types = ActeType.query.filter(ActeType.id == acte_type_id).all()
for a in acte_types:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def api_delete_institution(api_version, institution_id=None):
if institution_id is None:
institutions = Institution.query.all()
else:
institutions = Institution.query.filter(
Institution.id == institution_id).all()
for a in institutions:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
def delete_document_transcription(doc_id, user_id):
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(current_app, user_id)
if forbid:
return forbid
is_not_allowed = forbid_if_not_in_whitelist(current_app, Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
closed = is_closed(doc_id)
if closed:
return closed
doc = Document.query.filter(Document.id == doc_id).first()
if doc is None:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(current_app, doc)
if is_not_allowed:
return is_not_allowed
# forbid students to delete a transcription when there is a valid transcription
# user = current_app.get_current_user()
# if not user.is_teacher and get_doc(doc_id).is_transcription_validated:
# return make_403()
tr = get_transcription(doc_id=doc_id, user_id=user_id)
if tr is None:
return make_404()
try:
for thn in tr.transcription_has_note:
if thn.note.user_id == int(user_id):
exist_in_translation = TranslationHasNote.query.filter(
TranslationHasNote.note_id == thn.note.id
).first()
if not exist_in_translation:
db.session.delete(thn.note)
db.session.delete(tr)
doc = unvalidate_all(doc)
db.session.add(doc)
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200(data=doc.validation_flags)
def api_delete_country(api_version, country_id=None):
if country_id is None:
countries = Country.query.all()
else:
countries = Country.query.filter(Country.id == country_id).all()
for a in countries:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
def clone_alignment_image(doc_id, old_user_id, user_id):
old_tr = Transcription.query.filter(
Transcription.user_id == old_user_id,
Transcription.doc_id == doc_id).first()
new_tr = Transcription.query.filter(
Transcription.user_id == user_id,
Transcription.doc_id == doc_id).first()
if not old_tr or not new_tr:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(
current_app,
Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
old_alignments = AlignmentImage.query.filter(
AlignmentImage.transcription_id == old_tr.id,
AlignmentImage.user_id == old_user_id).all()
new_alignments = [
AlignmentImage(transcription_id=new_tr.id,
user_id=user_id,
zone_id=ol.zone_id,
manifest_url=ol.manifest_url,
canvas_idx=ol.canvas_idx,
img_idx=ol.img_idx,
ptr_transcription_start=ol.ptr_transcription_start,
ptr_transcription_end=ol.ptr_transcription_end)
for ol in old_alignments
]
db.session.bulk_save_objects(new_alignments)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def clone_speechparts(doc_id, old_user_id, user_id):
old_tr = Transcription.query.filter(
Transcription.user_id == old_user_id,
Transcription.doc_id == doc_id).first()
new_tr = Transcription.query.filter(
Transcription.user_id == user_id,
Transcription.doc_id == doc_id).first()
if not old_tr or not new_tr:
return make_404()
is_not_allowed = forbid_if_not_in_whitelist(
current_app,
Document.query.filter(Document.id == doc_id).first())
if is_not_allowed:
return is_not_allowed
# clone speechparts
old_alignments = AlignmentDiscours.query.filter(
AlignmentDiscours.transcription_id == old_tr.id,
AlignmentDiscours.user_id == old_user_id,
).all()
new_alignments = [
AlignmentDiscours(transcription_id=new_tr.id,
user_id=user_id,
speech_part_type_id=ol.speech_part_type_id,
note=ol.note,
ptr_start=ol.ptr_start,
ptr_end=ol.ptr_end) for ol in old_alignments
]
db.session.bulk_save_objects(new_alignments)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200()
def api_delete_user(api_version, user_id):
try:
target_user = User.query.filter(User.id == user_id).one()
user = current_app.get_current_user()
if target_user.is_admin and not user.is_admin:
return make_403()
try:
db.session.delete(target_user)
db.session.commit()
return make_200(data=[])
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
except NoResultFound:
return make_404()
def api_post_users_roles(api_version, user_id):
"""
{
"data": [
{
"name": "admin"
},
{
"name": "teacher"
}
]
}
:param api_version:
:param user_id:
:return:
"""
data = request.get_json()
if "data" in data:
data = data["data"]
user = current_app.get_current_user()
target_user = User.query.filter(User.id == user_id).first()
for role_name in [r.get("name", None) for r in data]:
if not role_name in target_user.roles:
if role_name == "admin" and not user.is_admin:
return make_403()
else:
role = Role.query.filter(Role.name == role_name).first()
if role:
target_user.roles.append(role)
db.session.add(target_user)
try:
db.session.commit()
return make_200(data=[r.serialize() for r in target_user.roles])
except Exception as e:
db.session.rollback()
return make_400(str(e))
else:
return make_409()
def api_delete_district(api_version, country_id, district_id=None):
c = Country.query.filter(Country.id == country_id).first()
if c is None:
return make_404("Country does not exist")
if district_id is None:
districts = District.query.filter(
District.country_id == country_id).all()
else:
districts = District.query.filter(District.country_id == country_id,
District.id == district_id).all()
for a in districts:
db.session.delete(a)
try:
db.session.commit()
return make_200([])
except Exception as e:
db.session.rollback()
return make_400(str(e))
