def api_documents_transcriptions_alignments_discours(api_version,
doc_id,
user_id=None):
"""
If user_id is None: get the reference translation (if any) to find the alignment
:param api_version:
:param doc_id:
:param user_id:
:return:
"""
transcription = get_reference_transcription(doc_id)
if transcription is None:
return make_404()
if user_id is None:
user_id = transcription.user_id
else:
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if forbid:
return forbid
alignments = AlignmentDiscours.query.filter(
AlignmentDiscours.transcription_id == transcription.id,
AlignmentDiscours.user_id == user_id).all()
if len(alignments) == 0:
return make_404()
return make_200(data=[al.serialize() for al in alignments])
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 view_document_commentaries(api_version, doc_id, user_id=None):
if user_id is not None:
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if forbid:
return forbid
coms = get_commentaries(doc_id, user_id)
else:
coms = get_reference_commentaries(doc_id)
if coms is None or len(coms) == 0:
return make_404()
_coms = [c.serialize() for c in coms]
_coms_content = [
add_notes_refs_to_text(c["content"], c["notes"]) for c in _coms
]
commentaries = zip(_coms, _coms_content)
return make_200(
data=[{
"doc_id": com["doc_id"],
"user_id": com["user_id"],
"type": com["type"],
"content": Markup(annotated) if annotated is not None else "",
"notes":
{"{:010d}".format(n["id"]): n["content"]
for n in com["notes"]}
} for com, annotated in commentaries])
def api_get_alignment_translation_from_user(api_version, doc_id, user_id):
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="No transcription available")
translation = get_translation(doc_id=doc_id, user_id=user_id)
if translation is None:
return make_404(details="No translation available")
alignments = AlignmentTranslation.query.filter(
AlignmentTranslation.transcription_id == transcription.id,
AlignmentTranslation.translation_id == translation.id).all()
ptrs = [(a.ptr_transcription_start, a.ptr_transcription_end,
a.ptr_translation_start, a.ptr_translation_end)
for a in alignments]
return make_200(data=ptrs)
def view_document_translation(api_version, doc_id, user_id=None):
if user_id is not None:
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(current_app, user_id)
if forbid:
return forbid
tr = get_translation(doc_id, user_id)
else:
tr = get_reference_translation(doc_id)
if tr is None:
return make_404()
if user_id is None:
user_id = tr.user_id
_tr = tr.serialize_for_user(user_id)
from app.api.transcriptions.routes import add_notes_refs_to_text
_content = add_notes_refs_to_text(_tr["content"], _tr["notes"])
return make_200({
"doc_id": tr.doc_id,
"user_id": tr.user_id,
"content": Markup(_content) if tr.content is not None else "",
"notes": {"{:010d}".format(n["id"]): n["content"] for n in _tr["notes"]}
})
def api_documents_translations_from_user(api_version, doc_id, user_id=None):
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(current_app, user_id)
if forbid:
return forbid
tr = get_translation(doc_id, user_id)
if tr is None:
return make_404()
return make_200(data=tr.serialize_for_user(user_id))
def api_users_roles(api_version, user_id):
access_is_forbidden = forbid_if_nor_teacher_nor_admin_and_wants_user_data(current_app, user_id)
if access_is_forbidden:
return access_is_forbidden
target_user = User.query.filter(User.id == user_id).first()
if target_user is not None:
return make_200(data=[r.serialize() for r in target_user.roles])
else:
return make_404()
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 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 commit_document_validation(doc):
is_not_allowed = forbid_if_not_in_whitelist(current_app, doc)
if is_not_allowed:
db.session.rollback()
return is_not_allowed
access_forbidden = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, doc.user_id)
if access_forbidden:
db.session.rollback()
return access_forbidden
try:
db.session.add(doc)
db.session.commit()
return make_200(data={"validation_flags": doc.validation_flags})
except Exception as e:
db.session.rollback()
print(e)
return make_400(str(e))
def delete_commentary(doc_id, user_id, type_id):
user = current_app.get_current_user()
# only teacher and admin can see everything
access_is_forbidden = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if access_is_forbidden:
return access_is_forbidden
if not (user.is_teacher
or user.is_admin) and type_id is not None and user_id is None:
user_id = user.id
if type_id is None:
type_id = Commentary.type_id
if user_id is None:
if user.is_teacher:
user_id = Commentary.user_id
else:
user_id = user.id
commentaries = Commentary.query.filter(
Commentary.doc_id == doc_id, Commentary.user_id == user_id,
Commentary.type_id == type_id).all()
for c in commentaries:
db.session.delete(c)
try:
db.session.commit()
# change validation step
return make_200(
data={
# "validation_step": doc.validation_step,
# "validation_step_label": get_validation_step_label(doc.validation_step)
})
except (Exception, KeyError) as e:
db.session.rollback()
return make_400(str(e))
def api_commentary_from_user(api_version, doc_id, user_id):
print(current_app.get_current_user())
forbid = forbid_if_nor_teacher_nor_admin_and_wants_user_data(
current_app, user_id)
if forbid:
return forbid
# teachers can still post notes in validated transcription
#current_user = current_app.get_current_user()
#if not current_user.is_teacher and get_doc(doc_id).is_transcription_validated:
# return make_403()
commentaries = Commentary.query.filter(
Commentary.doc_id == doc_id,
Commentary.user_id == user_id,
).all()
if len(commentaries) == 0:
return make_404()
return make_200(data=[c.serialize() for c in commentaries])
def api_post_documents_transcriptions_alignments_discours(
api_version, doc_id, user_id):
"""
{
"data": [
{
"speech_part_type_id" : 1,
"ptr_start": 1,
"ptr_end": 20,
"note": "aaa"
},
{
"speech_part_type_id" : 2,
"ptr_start": 21,
"ptr_end": 450,
"note": "bb"
}
]
}
:param user_id:
:param api_version:
:param doc_id:
:return:
"""
"""
NB: Posting alignment has a 'TRUNCATE AND REPLACE' effect
"""
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")
data = request.get_json()
data = data.get("data", [])
ptrs = []
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)
# INSERT
for d in data:
new_al = AlignmentDiscours(
transcription_id=transcription.id,
speech_part_type_id=d["speech_part_type_id"],
ptr_start=d["ptr_start"],
ptr_end=d["ptr_end"],
user_id=user_id,
note=d.get('note', None))
db.session.add(new_al)
ptrs.append({
'id': new_al.id,
'ptr_start': new_al.ptr_start,
'ptr_end': new_al.ptr_end,
'note': new_al.note,
'speech_part_type_id': new_al.speech_part_type_id
})
db.session.commit()
except Exception as e:
db.session.rollback()
print(str(e))
return make_400(str(e))
return make_200(data=ptrs)
