Create rapport_generator.py

helpers/rapport_generator.py

@@ -0,0 +1,390 @@
+## class to generate the DOCX report
+import json
+
+from docx import Document
+from docx.shared import Pt, RGBColor, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.section import WD_SECTION
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from typing import Dict, Any, List, Union  # Ajout des imports typing nécessaires
+import logging
+
+class RapportGenerator:
+    def __init__(self, json_file: str):
+        self.doc = Document()
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+        self.json_data = self.load_json(json_file)
+        self._setup_document()
+
+    def load_json(self, json_file: str) -> Dict:
+        """Charge le fichier JSON"""
+        try:
+            with open(json_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            self.logger.error(f"Erreur lors de la lecture du JSON: {str(e)}")
+            raise
+
+    def _setup_document(self):
+        """Configure le document"""
+        sections = self.doc.sections
+        for section in sections:
+            section.bottom_margin = Inches(1)
+        self._create_page_number()
+
+    def _create_page_number(self):
+        """Crée le numéro de page dans le pied de page"""
+        section = self.doc.sections[0]
+        footer = section.footer
+        paragraph = footer.paragraphs[0]
+        paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+
+        run = paragraph.add_run()
+        self._create_element(run, 'PAGE')
+        run = paragraph.add_run(" / ")
+        run = paragraph.add_run()
+        self._create_element(run, 'NUMPAGES')
+
+    def _create_element(self, run, text):
+        """Crée un élément de champ Word"""
+        fldChar1 = OxmlElement('w:fldChar')
+        fldChar1.set(qn('w:fldCharType'), 'begin')
+        run._r.append(fldChar1)
+
+        instrText = OxmlElement('w:instrText')
+        instrText.text = text
+        run._r.append(instrText)
+
+        fldChar2 = OxmlElement('w:fldChar')
+        fldChar2.set(qn('w:fldCharType'), 'end')
+        run._r.append(fldChar2)
+
+    def _add_title(self, text: str, level: int = 1):
+        """Ajoute un titre avec style et taille appropriés"""
+        heading = self.doc.add_heading(level=level)
+        heading.alignment = WD_ALIGN_PARAGRAPH.LEFT
+        run = heading.add_run(text.strip())  # Ajout de strip()
+        font_sizes = {0: 18, 1: 16, 2: 14, 3: 12}
+        run.font.size = Pt(font_sizes.get(level, 12))
+
+    def _format_key(self, key: str) -> str:
+        """Formate la clé en supprimant les suffixes _DEMANDEUR et _DEFENDEUR"""
+        key = key.replace("_", " ").title()
+        key = key.replace(" Demandeur", "")
+        key = key.replace(" Defendeur", "")
+        return key
+
+    def _get_safe_value(self, data: Dict, key: str, default: str = '') -> str:
+        """Récupère une valeur en toute sécurité du dictionnaire"""
+        if isinstance(data, dict):
+            return str(data.get(key, default))
+        return default
+
+    def _format_person_info(self, data: Dict, is_lawyer: bool = False) -> Dict[str, str]:
+        """Formate les informations d'une personne"""
+        info = {}
+
+        if not isinstance(data, dict):
+            return info
+
+        if is_lawyer:
+            # Informations de l'avocat
+            civilite = self._get_safe_value(data, 'CIVILITE_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'CIVILITE_AVOCAT_DEFENDEUR')
+            prenom = self._get_safe_value(data, 'PRENOM_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'PRENOM_AVOCAT_DEFENDEUR')
+            nom = self._get_safe_value(data, 'NOM_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'NOM_AVOCAT_DEFENDEUR')
+
+            info['Nom'] = f"{civilite} {prenom} {nom}".strip()
+            info['Barreau'] = self._get_safe_value(data, 'BARREAU_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'BARREAU_AVOCAT_DEFENDEUR')
+            info['Bureau d\'avocats'] = self._get_safe_value(data, 'BUREAU_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'BUREAU_AVOCAT_DEFENDEUR')
+
+            adresse = data.get('ADRESSE_AVOCAT_DEMANDEUR', {}) if isinstance(data.get('ADRESSE_AVOCAT_DEMANDEUR'), dict) else {}
+            if not adresse:
+                adresse = data.get('ADRESSE_AVOCAT_DEFENDEUR', {}) if isinstance(data.get('ADRESSE_AVOCAT_DEFENDEUR'), dict) else {}
+
+            info['Adresse Complete'] = self._get_safe_value(adresse, 'ADRESSE_COMPLETE_AVOCAT_DEMANDEUR') or self._get_safe_value(adresse, 'ADRESSE_COMPLETE_AVOCAT_DEFENDEUR')
+            info['Email'] = self._get_safe_value(data, 'EMAIL_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'EMAIL_AVOCAT_DEFENDEUR')
+            info['Telephone'] = self._get_safe_value(data, 'TELEPHONE_AVOCAT_DEMANDEUR') or self._get_safe_value(data, 'TELEPHONE_AVOCAT_DEFENDEUR')
+        else:
+            # Informations de la partie
+            civilite = self._get_safe_value(data, 'CIVILITE_DEMANDEUR') or self._get_safe_value(data, 'CIVILITE_DEFENDEUR')
+            prenom = self._get_safe_value(data, 'PRENOM_DEMANDEUR') or self._get_safe_value(data, 'PRENOM_DEFENDEUR')
+            nom = self._get_safe_value(data, 'NOM_DEMANDEUR') or self._get_safe_value(data, 'NOM_DEFENDEUR')
+
+            info['Nom'] = f"{civilite} {prenom} {nom}".strip()
+            info['Organisme'] = self._get_safe_value(data, 'ORGANISME_DEMANDEUR') or self._get_safe_value(data, 'ORGANISME_DEFENDEUR')
+
+            adresse = data.get('ADRESSE_DEMANDEUR', {}) if isinstance(data.get('ADRESSE_DEMANDEUR'), dict) else {}
+            if not adresse:
+                adresse = data.get('ADRESSE_DEFENDEUR', {}) if isinstance(data.get('ADRESSE_DEFENDEUR'), dict) else {}
+
+            info['Adresse Complete'] = self._get_safe_value(adresse, 'ADRESSE_COMPLETE_DEMANDEUR') or self._get_safe_value(adresse, 'ADRESSE_COMPLETE_DEFENDEUR')
+            info['Email'] = self._get_safe_value(data, 'EMAIL_DEMANDEUR') or self._get_safe_value(data, 'EMAIL_DEFENDEUR')
+            info['Telephone'] = self._get_safe_value(data, 'TELEPHONE_DEMANDEUR') or self._get_safe_value(data, 'TELEPHONE_DEFENDEUR')
+
+        return {k: v for k, v in info.items() if v and v != "Non spécifié"}
+
+    def _process_special_fields(self, key: str, value: Any) -> bool:
+        """Traite les champs spéciaux (HISTORIQUE et MISSION)"""
+        if key in ["HISTORIQUE", "MISSION"]:
+            self._add_title(key.upper().strip(), 1)
+
+            # Vérifier si la valeur est une liste
+            if isinstance(value, list):
+                for item in value:
+                    p = self.doc.add_paragraph()
+                    p.add_run(str(item).strip())
+            else:
+                # Si c'est une chaîne simple ou autre type
+                p = self.doc.add_paragraph()
+                p.add_run(str(value).strip())
+
+            # Ajouter un espace après HISTORIQUE seulement
+            if key == "HISTORIQUE":
+                self.doc.add_paragraph()
+
+            return True
+        return False
+
+    def _process_parties(self, title: str, items: Union[str, List], level: int):
+        """Traite les parties (demandeurs/défendeurs)"""
+        self._add_title(title, level)
+
+        # Si aucune partie n'est spécifiée
+        if isinstance(items, str) and items == "Non spécifié":
+            p = self.doc.add_paragraph(style='List Bullet')
+            p.add_run("Non spécifié")
+            return
+
+        # Traitement de chaque partie
+        if isinstance(items, list):
+            for idx, item in enumerate(items, 1):
+                if not isinstance(item, dict):
+                    continue
+
+                # Sous-titre pour chaque partie
+                partie_title = f"{title.rstrip('S')} {idx}"
+                self._add_title(partie_title, level + 1)
+
+                # Formatage du nom complet
+                civilite = self._get_safe_value(item, f'CIVILITE_{title.rstrip("S")}', '')
+                prenom = self._get_safe_value(item, f'PRENOM_{title.rstrip("S")}', '')
+                nom = self._get_safe_value(item, f'NOM_{title.rstrip("S")}', '')
+                nom_complet = f"{civilite} {prenom} {nom}".strip()
+
+                # Ajout du nom
+                if nom_complet and nom_complet != "Non spécifié":
+                    p = self.doc.add_paragraph(style='List Bullet')
+                    p.add_run("Nom: ").bold = True
+                    p.add_run(nom_complet)
+
+                # Récupération de l'adresse
+                adresse = item.get(f'ADRESSE_{title.rstrip("S")}', {})
+                if isinstance(adresse, dict):
+                    adresse_complete = adresse.get(f'ADRESSE_COMPLETE_{title.rstrip("S")}', '')
+                    if adresse_complete and adresse_complete != "Non spécifié":
+                        p = self.doc.add_paragraph(style='List Bullet')
+                        p.add_run("Adresse Complete: ").bold = True
+                        p.add_run(adresse_complete)
+
+                # Ajout du téléphone
+                telephone = self._get_safe_value(item, f'TELEPHONE_{title.rstrip("S")}', '')
+                if telephone and telephone != "Non spécifié":
+                    p = self.doc.add_paragraph(style='List Bullet')
+                    p.add_run("Téléphone: ").bold = True
+                    p.add_run(telephone)
+
+                # Ajout de l'email
+                email = self._get_safe_value(item, f'EMAIL_{title.rstrip("S")}', '')
+                if email and email != "Non spécifié":
+                    p = self.doc.add_paragraph(style='List Bullet')
+                    p.add_run("Email: ").bold = True
+                    p.add_run(email)
+
+                # Traitement des avocats
+                avocat_key = f'AVOCAT_{title.rstrip("S")}'
+                avocats = item.get(avocat_key, [])
+
+                if isinstance(avocats, list) and avocats and avocats != "Non spécifié":
+                    for avocat_idx, avocat in enumerate(avocats, 1):
+                        if isinstance(avocat, dict):
+                            # Sous-titre pour chaque avocat
+                            self._add_title(f"Avocat {avocat_idx}", level + 2)
+
+                            # Nom de l'avocat
+                            civilite_avocat = self._get_safe_value(avocat, f'CIVILITE_AVOCAT_{title.rstrip("S")}', '')
+                            prenom_avocat = self._get_safe_value(avocat, f'PRENOM_AVOCAT_{title.rstrip("S")}', '')
+                            nom_avocat = self._get_safe_value(avocat, f'NOM_AVOCAT_{title.rstrip("S")}', '')
+                            nom_complet_avocat = f"{civilite_avocat} {prenom_avocat} {nom_avocat}".strip()
+
+                            if nom_complet_avocat and nom_complet_avocat != "Non spécifié":
+                                p = self.doc.add_paragraph(style='List Bullet')
+                                p.add_run("Nom: ").bold = True
+                                p.add_run(nom_complet_avocat)
+
+                            # Barreau
+                            barreau = self._get_safe_value(avocat, f'BARREAU_AVOCAT_{title.rstrip("S")}', '')
+                            if barreau and barreau != "Non spécifié":
+                                p = self.doc.add_paragraph(style='List Bullet')
+                                p.add_run("Barreau: ").bold = True
+                                p.add_run(barreau)
+
+                            # Bureau d'avocats
+                            bureau = self._get_safe_value(avocat, f'BUREAU_AVOCAT_{title.rstrip("S")}', '')
+                            if bureau and bureau != "Non spécifié":
+                                p = self.doc.add_paragraph(style='List Bullet')
+                                p.add_run("Bureau d'avocats: ").bold = True
+                                p.add_run(bureau)
+
+                            # Adresse de l'avocat
+                            adresse_avocat = avocat.get(f'ADRESSE_AVOCAT_{title.rstrip("S")}', {})
+                            if isinstance(adresse_avocat, dict):
+                                adresse_complete_avocat = adresse_avocat.get(f'ADRESSE_COMPLETE_AVOCAT_{title.rstrip("S")}', '')
+                                if adresse_complete_avocat and adresse_complete_avocat != "Non spécifié":
+                                    p = self.doc.add_paragraph(style='List Bullet')
+                                    p.add_run("Adresse Complete: ").bold = True
+                                    p.add_run(adresse_complete_avocat)
+
+                            # Téléphone de l'avocat
+                            tel_avocat = self._get_safe_value(avocat, f'TELEPHONE_AVOCAT_{title.rstrip("S")}', '')
+                            if tel_avocat and tel_avocat != "Non spécifié":
+                                p = self.doc.add_paragraph(style='List Bullet')
+                                p.add_run("Téléphone: ").bold = True
+                                p.add_run(tel_avocat)
+
+                            # Email de l'avocat
+                            email_avocat = self._get_safe_value(avocat, f'EMAIL_AVOCAT_{title.rstrip("S")}', '')
+                            if email_avocat and email_avocat != "Non spécifié":
+                                p = self.doc.add_paragraph(style='List Bullet')
+                                p.add_run("Email: ").bold = True
+                                p.add_run(email_avocat)
+
+                # Ajouter un espace entre chaque partie
+                if idx < len(items):
+                    self.doc.add_paragraph()
+
+    def _add_table_of_contents(self):
+        """Ajoute une table des matières au document"""
+        paragraph = self.doc.add_paragraph()
+        run = paragraph.add_run("TABLE DES MATIÈRES")
+        run.bold = True
+        run.font.size = Pt(14)
+
+        self.doc.add_paragraph()
+        paragraph = self.doc.add_paragraph()
+
+        # Ajouter le champ TOC
+        run = paragraph.add_run()
+        fldChar1 = OxmlElement('w:fldChar')
+        fldChar1.set(qn('w:fldCharType'), 'begin')
+        run._r.append(fldChar1)
+
+        instrText = OxmlElement('w:instrText')
+        instrText.set(qn('xml:space'), 'preserve')
+        instrText.text = 'TOC \\o "1-3" \\h \\z \\u'
+        run._r.append(instrText)
+
+        fldChar2 = OxmlElement('w:fldChar')
+        fldChar2.set(qn('w:fldCharType'), 'separate')
+        run._r.append(fldChar2)
+
+        # Ajouter un espace pour la mise à jour
+        run = paragraph.add_run()
+
+        fldChar4 = OxmlElement('w:fldChar')
+        fldChar4.set(qn('w:fldCharType'), 'end')
+        run._r.append(fldChar4)
+
+        self.doc.add_page_break()
+
+    def _format_person_info_simple(self, data: Dict, prefix: str) -> str:
+        """Formate les informations d'une personne (magistrat ou greffier)"""
+        prenom = data.get(f'PRENOM_{prefix}', '').strip()
+        nom = data.get(f'NOM_{prefix}', '').strip()
+        titre = data.get(f'TITRE_{prefix}', '').strip()
+        return f"{prenom} {nom}, {titre}".strip()
+
+    def _format_monetary_value(self, data: Dict, prefix: str) -> str:
+        """Formate les valeurs monétaires"""
+        valeur = str(data.get(f'VALEUR_{prefix}', 0)).strip()
+        monnaie = data.get(f'MONNAIE_{prefix}', '€').strip()
+        return f"{valeur} {monnaie}".strip()
+
+    def generate_report(self):
+        """Génère le rapport complet"""
+        try:
+            # Titre principal
+            title = self.doc.add_heading("Données extraites d'une ordonnance de référé", 0)
+            title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+            # Informations générales
+            self._add_title("INFORMATIONS GÉNÉRALES", 1)
+            if isinstance(self.json_data.get("INFORMATIONS_GENERALES"), dict):
+                info_gen = self.json_data["INFORMATIONS_GENERALES"]
+
+                # Liste des champs à traiter
+                fields_to_process = [
+                    # Champs simples
+                    ("DATE_ORDONNANCE_REFERE", "Date Ordonnance Refere"),
+                    ("VILLE_TRIBUNAL", "Ville Tribunal"),
+                    ("NUMERO_RG", "Numero RG"),
+
+                    # Champs complexes avec formatage spécial
+                    ("MAGISTRAT_ORDONNANCE_REFERE", "Magistrat Ordonnance Refere", 
+                    lambda x: self._format_person_info_simple(x, "MAGISTRAT_ORDONNANCE_REFERE")),
+
+                    ("GREFFIER_ORDONNANCE_REFERE", "Greffier Ordonnance Refere",
+                    lambda x: self._format_person_info_simple(x, "GREFFIER_ORDONNANCE_REFERE")),
+
+                    ("CONSIGNATION", "Consignation",
+                    lambda x: self._format_monetary_value(x, "CONSIGNATION")),
+
+                    ("SOMME_A_CONSIGER", "Somme A Consiger",
+                    lambda x: self._format_monetary_value(x, "SOMME_A_CONSIGER"))
+                ]
+
+                # Traitement de chaque champ
+                for field in fields_to_process:
+                    key = field[0]
+                    display_name = field[1]
+
+                    if key in info_gen:
+                        p = self.doc.add_paragraph(style='List Bullet')
+                        p.add_run(f"{display_name}: ").bold = True
+
+                        # Si c'est un champ avec formatage spécial (longueur du tuple = 3)
+                        if len(field) == 3:
+                            formatter = field[2]
+                            value = formatter(info_gen[key])
+                        else:
+                            value = str(info_gen[key])
+
+                        p.add_run(value)
+
+            # Traitement des demandeurs
+            if "DEMANDEURS" in self.json_data:
+                self._process_parties("DEMANDEURS", self.json_data["DEMANDEURS"], 1)
+
+            # Traitement des défendeurs
+            if "DEFENDEURS" in self.json_data:
+                self._process_parties("DEFENDEURS", self.json_data["DEFENDEURS"], 1)
+
+            # Historique
+            if "HISTORIQUE" in self.json_data:
+                self._process_special_fields("HISTORIQUE", self.json_data["HISTORIQUE"])
+
+            # Mission
+            if "MISSION" in self.json_data:
+                self._process_special_fields("MISSION", self.json_data["MISSION"])
+
+            # Sauvegarde du document
+            output_file = "rapport_extraction.docx"
+            self.doc.save(output_file)
+            self.logger.info(f"Rapport généré avec succès: {output_file}")
+
+            return output_file
+
+        except Exception as e:
+            self.logger.error(f"Erreur lors de la génération du rapport: {str(e)}")
+            raise