Merge pull request #123 from Nathan-Etave/feat/administration

PR: Merge de feat/administration dans dev

Author: etave

app/__init__.py

@@ -20,6 +20,7 @@
 from app.models.sous_dossier import SOUS_DOSSIER
 from app.models.tag import TAG
 from app.models.utilisateur import UTILISATEUR
+from app.utils import check_notitications, get_total_file_count
 
 
 crsf = CSRFProtect()
@@ -80,6 +81,11 @@ def handle_process_status_message(message):
         pubsub.subscribe(**{'process_status': handle_process_status_message})
         pubsub.run_in_thread(sleep_time=0.5)
 
+    @app.context_processor
+    def utility_processor():
+        return dict(get_total_file_count=get_total_file_count,
+                    check_notitications=check_notitications)
+
     app.register_blueprint(register_bp, url_prefix='/inscription')
     app.register_blueprint(notifications_bp, url_prefix='/notifications')
     app.register_blueprint(login_bp, url_prefix='/connexion')
@@ -93,10 +99,10 @@ def handle_process_status_message(message):
 
 def fill_db():
     if not ROLE.query.all():
+        db.session.add(ROLE(nom_Role="ADMIN"))
         db.session.add(ROLE(nom_Role="RCH4"))
         db.session.add(ROLE(nom_Role="RCH3"))
-        db.session.add(ROLE(nom_Role="RCH2"))
-        db.session.add(ROLE(nom_Role="RCH1"))
+        db.session.add(ROLE(nom_Role="RCH1/2"))
         db.session.commit()
 
     if not DOSSIER.query.all():
@@ -107,16 +113,19 @@ def fill_db():
         db.session.add(DOSSIER(nom_Dossier="Support formation", priorite_Dossier=5, couleur_Dossier="#ffccff"))
         db.session.add(DOSSIER(nom_Dossier="Mémoire", priorite_Dossier=6, couleur_Dossier="#cc99ff"))
         db.session.add(DOSSIER(nom_Dossier="Thèse", priorite_Dossier=7, couleur_Dossier="#ccccff"))
-        db.session.add(DOSSIER(nom_Dossier="À trier", priorite_Dossier=8, couleur_Dossier="#99ccff"))
-        db.session.add(DOSSIER(nom_Dossier="Confidentiel", priorite_Dossier=9, couleur_Dossier="#ccffff"))
+        db.session.add(DOSSIER(nom_Dossier="À trier", priorite_Dossier=8, couleur_Dossier="#ccffff"))
+        db.session.add(DOSSIER(nom_Dossier="Archive", priorite_Dossier=9223372036854775807, couleur_Dossier="#d3d7d8"))
         db.session.commit()
 
     if not db.session.query(A_ACCES).all():
         for dossier in DOSSIER.query.all():
             db.session.execute(A_ACCES.insert().values(id_Role=1, id_Dossier=dossier.id_Dossier))
+            db.session.execute(A_ACCES.insert().values(id_Role=2, id_Dossier=dossier.id_Dossier))
+            db.session.execute(A_ACCES.insert().values(id_Role=3, id_Dossier=dossier.id_Dossier))
+            db.session.execute(A_ACCES.insert().values(id_Role=4, id_Dossier=dossier.id_Dossier))
         db.session.commit()
 
     if not UTILISATEUR.query.all():
-        db.session.add(UTILISATEUR(nom_Utilisateur="admin", prenom_Utilisateur="admin", email_Utilisateur="admin@admin.fr", mdp_Utilisateur="$2b$12$sOih7qRKimxwqJXITajOfO.Twyg.lModCMYSrgxLpxGompCQjjM56", est_Actif_Utilisateur=True, id_Role=1))
+        db.session.add(UTILISATEUR(nom_Utilisateur="Administrateur", prenom_Utilisateur="", email_Utilisateur="admin@admin.fr", mdp_Utilisateur="$2b$12$sOih7qRKimxwqJXITajOfO.Twyg.lModCMYSrgxLpxGompCQjjM56", telephone_Utilisateur="", est_Actif_Utilisateur=True, id_Role=1))
         # password: O]SxR=rBv%
         db.session.commit()

app/administration/routes.py

@@ -5,7 +5,8 @@
 from app.administration import bp
 from app.tasks import process_file
 from unidecode import unidecode
-from flask import render_template, request, current_app, Response
+from flask import render_template, request, current_app, Response, jsonify
+from flask_login import current_user
 from werkzeug.utils import secure_filename
 from flask_login import login_required
 from app.decorators import admin_required
@@ -52,14 +53,27 @@ def upload():
     folder_id = json_data.get("folderId")
     file_data = json_data.get("data")
     filename = unidecode(secure_filename(json_data.get("filename"))).lower()
-    user_tags = ' '.join(json_data.get("tags").replace(' ', ';').split(';'))
+    existing_file = FICHIER.query.filter_by(nom_Fichier=filename).first()
+    force = json_data.get("force")
+    if existing_file is not None:
+        if force:
+            delete_file(str(existing_file.id_Fichier))
+        else:
+            return jsonify({'filename': filename,
+                            'existingFolder': existing_file.DOSSIER_.nom_Dossier,
+                            'attemptedFolder': DOSSIER.query.get(folder_id).nom_Dossier,
+                            'existingFileAuthorFirstName': existing_file.AUTEUR.prenom_Utilisateur,
+                            'existingFileAuthorLastName': existing_file.AUTEUR.nom_Utilisateur,
+                            'existingFileDate': existing_file.date_Fichier.strftime('%d/%m/%Y à %H:%M')}), 409
+    user_tags = unidecode(' '.join(json_data.get("tags").replace(' ', ';').split(';'))).lower()
     storage_directory = os.path.join(current_app.root_path, "storage")
     if not os.path.exists(f"{storage_directory}/{folder_id}"):
         os.makedirs(f"{storage_directory}/{folder_id}")
     file = FICHIER(
         id_Dossier=folder_id,
         nom_Fichier=filename,
         extension_Fichier=filename.split(".")[-1],
+        id_Utilisateur=current_user.id_Utilisateur,
     )
     db.session.add(file)
     db.session.commit()
@@ -98,33 +112,6 @@ def connect():
     )
 
 
-@socketio.on("trash_file", namespace="/administration")
-def trash_file(data):
-    try:
-        file_id = data.get("fileId")
-        folder_id = data.get("folderId")
-        with InterProcessLock(f"{current_app.root_path}/whoosh.lock"):
-            Whoosh().delete_document(file_id)
-        file = FICHIER.query.get(file_id)
-        db.session.delete(file)
-        os.remove(
-            os.path.join(
-                current_app.root_path,
-                "storage",
-                folder_id,
-                f"{file_id}.{file.extension_Fichier}",
-            )
-        )
-        db.session.commit()
-        socketio.emit("file_deleted", data, namespace="/administration")
-    except Exception as e:
-        socketio.emit(
-            "file_deletion_failed",
-            {**data, "error": str(e)},
-            namespace="/administration",
-        )
-
-
 @socketio.on("search_files", namespace="/administration")
 def search_files(data):
     search_query = data.get("query")
@@ -203,8 +190,11 @@ def create_folder(data):
     parent_folder_id = data.get('parentFolderId')
     folder_roles = data.get('folderRoles')
     folder_color = data.get('folderColor')
-    last_priority = db.session.query(db.func.max(DOSSIER.priorite_Dossier)).scalar()
-    folder = DOSSIER(nom_Dossier=folder_name, priorite_Dossier=last_priority + 1, couleur_Dossier=folder_color)
+    folder_priority = data.get('folderPriority')
+    folders_to_update = DOSSIER.query.filter(DOSSIER.priorite_Dossier >= folder_priority).filter(DOSSIER.id_Dossier != 10).all()
+    for folder_to_update in folders_to_update:
+        folder_to_update.priorite_Dossier += 1
+    folder = DOSSIER(nom_Dossier=folder_name, priorite_Dossier=folder_priority, couleur_Dossier=folder_color)
     db.session.add(folder)
     try:
         db.session.commit()
@@ -244,11 +234,25 @@ def modify_folder(data):
     folder_name = data.get('folderName')
     parent_folder_id = data.get('parentFolderId')
     folder_roles = data.get('folderRoles')
+    folder_priority = data.get('folderPriority')
     folder_color = data.get('folderColor')
     folder = DOSSIER.query.get(folder_id)
     folder.nom_Dossier = folder_name
     folder.couleur_Dossier = folder_color
+    if folder.priorite_Dossier != int(folder_priority):
+        if int(folder_priority) > folder.priorite_Dossier:
+            folders_to_update = DOSSIER.query.filter(DOSSIER.priorite_Dossier > folder.priorite_Dossier).filter(DOSSIER.priorite_Dossier <= int(folder_priority)).filter(DOSSIER.id_Dossier != 10).all()
+            for folder_to_update in folders_to_update:
+                folder_to_update.priorite_Dossier -= 1
+        else:
+            folders_to_update = DOSSIER.query.filter(DOSSIER.priorite_Dossier >= int(folder_priority)).filter(DOSSIER.priorite_Dossier < folder.priorite_Dossier).filter(DOSSIER.id_Dossier != 10).all()
+            for folder_to_update in folders_to_update:
+                folder_to_update.priorite_Dossier += 1
+        folder.priorite_Dossier = folder_priority
     try:
+        if parent_folder_id == folder_id:
+            socketio.emit('folder_not_modified', {'error': 'Un classeur ne peut pas être son propre parent.'}, namespace='/administration')
+            return
         if parent_folder_id != 0:
             db.session.execute(SOUS_DOSSIER.delete().where(SOUS_DOSSIER.c.id_Dossier_Enfant == folder_id))
             db.session.execute(SOUS_DOSSIER.insert().values(id_Dossier_Parent=parent_folder_id, id_Dossier_Enfant=folder_id))
@@ -277,4 +281,103 @@ def modify_folder(data):
         socketio.emit('folder_not_modified', {'error': str(e)}, namespace='/administration')
         return
     db.session.commit()
-    socketio.emit('folder_modified', {'folderId': folder_id, 'folderName': folder_name, 'folderColor': folder_color}, namespace='/administration')
+    socketio.emit('folder_modified', {'folderId': folder_id, 'folderName': folder_name, 'folderColor': folder_color}, namespace='/administration')
+
+@socketio.on('delete_folder', namespace='/administration')
+def delete_folder(data):
+    folder = DOSSIER.query.get(data.get('folderId'))
+    if folder.id_Dossier == 10:
+        socketio.emit('folder_not_deleted', {'error': 'Le classeur d\'archive ne peut pas être supprimé.'}, namespace='/administration')
+        return
+    if len(folder.DOSSIER_) > 0:
+        socketio.emit('folder_not_deleted', {'error': 'Le classeur contient des sous-classeurs.'}, namespace='/administration')
+        return
+    if len(folder.FICHIER) > 0:
+        socketio.emit('folder_not_deleted', {'error': 'Le classeur contient des fichiers.'}, namespace='/administration')
+        return
+    try:
+        db.session.execute(SOUS_DOSSIER.delete().where(SOUS_DOSSIER.c.id_Dossier_Enfant == folder.id_Dossier))
+        db.session.execute(SOUS_DOSSIER.delete().where(SOUS_DOSSIER.c.id_Dossier_Parent == folder.id_Dossier))
+        db.session.commit()
+    except Exception as e:
+        db.session.rollback()
+        socketio.emit('folder_not_deleted', {'error': str(e)}, namespace='/administration')
+        return
+    try:
+        db.session.execute(A_ACCES.delete().where(A_ACCES.c.id_Dossier == folder.id_Dossier))
+        db.session.commit()
+    except Exception as e:
+        db.session.rollback()
+        socketio.emit('folder_not_deleted', {'error': str(e)}, namespace='/administration')
+        return
+    deleted_priority = folder.priorite_Dossier
+    db.session.delete(folder)
+    db.session.commit()
+    folders_to_update = DOSSIER.query.filter(DOSSIER.priorite_Dossier > deleted_priority).filter(DOSSIER.id_Dossier != 10).all()
+    for folder_to_update in folders_to_update:
+        folder_to_update.priorite_Dossier -= 1
+    db.session.commit()
+    socketio.emit('folder_deleted', {'folderId': folder.id_Dossier}, namespace='/administration')
+
+
+@socketio.on('archive_folders', namespace='/administration')
+def archive_folders(data):
+    folder_ids = data.get('folderIds')
+    try:
+        for folder_id in folder_ids:
+            database_folder = DOSSIER.query.get(folder_id)
+            if folder_id == '10':
+                pass
+            elif database_folder.DOSSIER != [] and database_folder.DOSSIER[0].id_Dossier == 10:
+                pass
+            elif database_folder.DOSSIER != [] and str(database_folder.DOSSIER[0].id_Dossier) in folder_ids:
+                pass
+            else:
+                if database_folder.DOSSIER != []:
+                    db.session.execute(SOUS_DOSSIER.delete().where(SOUS_DOSSIER.c.id_Dossier_Enfant == folder_id))
+                db.session.execute(SOUS_DOSSIER.insert().values(id_Dossier_Parent=10, id_Dossier_Enfant=folder_id))
+        db.session.commit()
+    except Exception as e:
+        db.session.rollback()
+        socketio.emit('folders_not_archived', {'error': str(e)}, namespace='/administration')
+        return
+    socketio.emit('folders_archived', {'folderIds': folder_ids}, namespace='/administration')
+
+@socketio.on('delete_files', namespace='/administration')
+def delete_files(data):
+    file_ids = data.get('fileIds')
+    try:
+        for file_id in file_ids:
+            with InterProcessLock(f"{current_app.root_path}/whoosh.lock"):
+                Whoosh().delete_document(file_id)
+            database_file = FICHIER.query.get(file_id)
+            db.session.delete(database_file)
+            os.remove(
+                os.path.join(
+                    current_app.root_path,
+                    "storage",
+                    str(database_file.id_Dossier),
+                    f"{file_id}.{database_file.extension_Fichier}",
+                )
+            )
+        db.session.commit()
+    except Exception as e:
+        db.session.rollback()
+        socketio.emit('files_not_deleted', {'error': str(e)}, namespace='/administration')
+        return
+    socketio.emit('files_deleted', {'fileIds': file_ids}, namespace='/administration')
+
+def delete_file(file_id):
+    with InterProcessLock(f"{current_app.root_path}/whoosh.lock"):
+        Whoosh().delete_document(file_id)
+    database_file = FICHIER.query.get(file_id)
+    db.session.delete(database_file)
+    os.remove(
+        os.path.join(
+            current_app.root_path,
+            "storage",
+            str(database_file.id_Dossier),
+            f"{file_id}.{database_file.extension_Fichier}",
+        )
+    )
+    db.session.commit()

app/file_handler/routes.py

@@ -1,12 +1,17 @@
+import time
+import os
 from app.file_handler import bp
-from flask import send_from_directory, abort, current_app, request
+from flask import send_from_directory, abort, current_app, request, send_file
 from app.models.fichier import FICHIER
 from flask_login import current_user, login_required
 from app import socketio
 from app.extensions import db
 from app.models.favoris import FAVORIS
+from app.utils import FileDownloader
+from app.decorators import admin_required
+from threading import Timer
 
-@bp.route('/dossier/<int:folder_id>/fichier/<int:file_id>', methods=['GET'])
+@bp.route('/classeur/<int:folder_id>/fichier/<int:file_id>', methods=['GET'])
 @login_required
 def file(folder_id, file_id):
     file = FICHIER.query.get(file_id)
@@ -32,4 +37,21 @@ def get_files_details(data):
         dict_file['id_Dossier'] = file.DOSSIER_.id_Dossier
         dict_file['is_favorite'] = file.id_Fichier in favoris_ids
         files.append(dict_file)
-    socketio.emit('files_details', files, namespace='/file_handler')
+    socketio.emit('files_details', files, namespace='/file_handler')
+
+
+@bp.route('/download/archive', methods=['POST'])
+@login_required
+@admin_required
+def download_archive():
+    zip_path = FileDownloader().create_zip(request.json['fileIds'])
+    delete_file_after_delay(43200, zip_path)
+    return send_file(zip_path, 'archive.zip', as_attachment=True)
+
+def delete_file_after_delay(delay, path):
+    def delete_file():
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+    Timer(delay, delete_file).start()

app/models/fichier.py

@@ -1,24 +1,29 @@
 from typing import List, Optional
-from sqlalchemy import Integer, String, ForeignKeyConstraint, Index
+from sqlalchemy import Integer, String, ForeignKeyConstraint, Index, DateTime
 from sqlalchemy.orm import relationship, mapped_column, Mapped
 from app.extensions import db
 
 class FICHIER(db.Model):
     __tablename__ = 'FICHIER'
     __table_args__ = (
         ForeignKeyConstraint(['id_Dossier'], ['DOSSIER.id_Dossier'], name='fk_Fichier_Dossier'),
-        Index('fk_Fichier_Dossier', 'id_Dossier')
+        ForeignKeyConstraint(['id_Utilisateur'], ['UTILISATEUR.id_Utilisateur'], name='fk_Fichier_Utilisateur'),
+        Index('fk_Fichier_Dossier', 'id_Dossier'),
+        Index('fk_Fichier_Utilisateur', 'id_Utilisateur')
     )
 
     id_Fichier = mapped_column(Integer, primary_key=True)
     id_Dossier = mapped_column(Integer)
     nom_Fichier = mapped_column(String(255))
     extension_Fichier = mapped_column(String(255))
+    date_Fichier = mapped_column(DateTime, default=db.func.current_timestamp())
+    id_Utilisateur = mapped_column(Integer)
 
     def to_dict(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
     DOSSIER_: Mapped[Optional['DOSSIER']] = relationship('DOSSIER', back_populates='FICHIER')
     UTILISATEUR_: Mapped[List['UTILISATEUR']] = relationship('UTILISATEUR', secondary='FAVORIS', back_populates='FICHIER_')
+    AUTEUR: Mapped[Optional['UTILISATEUR']] = relationship('UTILISATEUR', back_populates='FICHIER_')
     A_TAG: Mapped[List['A_TAG']] = relationship('A_TAG', uselist=True, back_populates='FICHIER_')
     NOTIFICATION: Mapped[List['NOTIFICATION']] = relationship('NOTIFICATION', uselist=True, back_populates='FICHIER_')

app/models/utilisateur.py

@@ -27,7 +27,7 @@ def to_dict(self):
         return {c.name: getattr(self, c.name) for c in self.__table__.columns}
 
     def is_admin(self):
-        return self.id_Role == 1
+        return self.id_Role != 4
 
     FICHIER_: Mapped[List['FICHIER']] = relationship('FICHIER', secondary='FAVORIS', back_populates='UTILISATEUR_')
     ROLE_: Mapped[Optional['ROLE']] = relationship('ROLE', back_populates='UTILISATEUR')