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))