llm_ticket3/retrieve_ticket.py

#!/usr/bin/env python3
"""
Script pour récupérer un ticket Odoo en utilisant TicketManager.
Exemple d'usage: python retrieve_ticket.py T0123
"""

import os
import sys
from utils.ticket_manager2 import TicketManager
import json
import argparse

def main():
    """Fonction principale du script"""
    parser = argparse.ArgumentParser(description="Extraction de tickets Odoo")
    parser.add_argument("ticket_code", help="Code du ticket à extraire (ex: T0167)")
    parser.add_argument("--config", default="config.json", help="Chemin vers le fichier de configuration")
    parser.add_argument("--output-dir", help="Répertoire de sortie (par défaut: output/ticket_CODE)")
    parser.add_argument("--verbose", "-v", action="store_true", help="Afficher plus d'informations")
    parser.add_argument("--keep-html", action="store_true", help="Conserver le contenu HTML dans les messages")
    parser.add_argument("--no-original", action="store_true", help="Ne pas conserver le corps de message original")
    parser.add_argument("--keep-all", action="store_true", help="Conserver tous les messages (y compris ceux d'OdooBot et les messages vides)")
    args = parser.parse_args()
    
    # Charger la configuration
    try:
        with open(args.config, "r", encoding="utf-8") as f:
            config = json.load(f)
        
        if args.verbose:
            print(f"Configuration chargée depuis {args.config}")
    except Exception as e:
        print(f"Erreur lors du chargement de la configuration: {e}")
        sys.exit(1)
    
    # Extraire les informations de connexion
    odoo_config = config.get("odoo", {})
    url = odoo_config.get("url")
    db = odoo_config.get("db")
    username = odoo_config.get("username")
    api_key = odoo_config.get("api_key")
    
    if not all([url, db, username, api_key]):
        print("Informations de connexion Odoo manquantes dans le fichier de configuration")
        sys.exit(1)
    
    # Définir le répertoire de sortie
    output_dir = args.output_dir or os.path.join(config.get("output_dir", "output"), f"ticket_{args.ticket_code}")
    
    # Créer et connecter le gestionnaire de tickets
    ticket_manager = TicketManager(url, db, username, api_key)
    
    # Personnaliser le nettoyage des messages HTML si demandé
    if args.keep_html:
        # Remplacer la méthode de nettoyage par une qui ne fait rien
        ticket_manager._clean_messages = lambda messages: [
            {**msg, "body_original": msg["body"] if isinstance(msg.get("body"), str) else msg.get("body")} 
            for msg in messages
        ]
    elif args.keep_all:
        # Modifier la méthode pour garder tous les messages mais nettoyer leur contenu
        original_clean_method = ticket_manager._clean_messages
        def keep_all_messages(messages):
            result = []
            for message in messages:
                cleaned = message.copy()
                if "body" in cleaned and cleaned["body"] and isinstance(cleaned["body"], str):
                    # Nettoyer le contenu mais garder tous les messages
                    cleaned["body_original"] = cleaned["body"]
                    # Appliquer le nettoyage de base
                    import re
                    from html import unescape
                    
                    body = cleaned["body"]
                    body = re.sub(r'<img[^>]*?>', '', body)
                    body = re.sub(r'<style[^>]*?>.*?</style>', '', body, flags=re.DOTALL)
                    body = re.sub(r'<script[^>]*?>.*?</script>', '', body, flags=re.DOTALL)
                    body = re.sub(r' style="[^"]*"', '', body)
                    body = re.sub(r'<(?:p|div)[^>]*?>', '\n', body)
                    body = re.sub(r'</(?:p|div)>', '\n', body)
                    body = re.sub(r'<br[^>]*?>', '\n', body)
                    body = re.sub(r'<[^>]*?>', '', body)
                    body = unescape(body)
                    body = re.sub(r'\n\s*\n', '\n\n', body)
                    body = re.sub(r' +', ' ', body)
                    body = body.strip()
                    
                    cleaned["body"] = body
                result.append(cleaned)
            return result
        
        ticket_manager._clean_messages = keep_all_messages
    elif args.no_original:
        # Modifier la méthode pour ne pas conserver le corps original
        original_clean_method = ticket_manager._clean_messages
        ticket_manager._clean_messages = lambda messages: [
            {k: v for k, v in msg.items() if k != "body_original"}
            for msg in original_clean_method(messages)
        ]
    
    if not ticket_manager.login():
        print("Échec de la connexion à Odoo")
        sys.exit(1)
    
    # Récupérer le ticket
    if args.verbose:
        print(f"Recherche du ticket {args.ticket_code}...")
    
    ticket = ticket_manager.get_ticket_by_code(args.ticket_code)
    
    if not ticket:
        print(f"Ticket {args.ticket_code} non trouvé")
        sys.exit(1)
    
    if args.verbose:
        print(f"Ticket {args.ticket_code} trouvé (ID: {ticket.get('id')})")
        print(f"Extraction des données vers {output_dir}...")
    
    # Extraire et sauvegarder toutes les données
    result = ticket_manager.extract_ticket_data(ticket["id"], output_dir)
    
    if "error" in result:
        print(f"Erreur: {result['error']}")
        sys.exit(1)
    
    print(f"Extraction terminée avec succès")
    print(f"- Informations du ticket: {result['ticket_info']}")
    print(f"- Messages: {result['messages_file']}")
    print(f"- Données complètes: {result['ticket_data_file']}")
    print(f"- Pièces jointes: {len(result['attachments'])} fichiers")
    
    # Afficher un résumé
    print(f"\nRésumé du ticket {args.ticket_code}:")
    print(f"- Nom: {ticket.get('name', 'N/A')}")
    print(f"- Description: {ticket.get('description', 'N/A')[:100]}...")
    print(f"- Étape: {ticket.get('stage_id', ['N/A'])[1] if isinstance(ticket.get('stage_id'), (list, tuple)) else 'N/A'}")

if __name__ == "__main__":
    main()