llm_ticket3/odoo_extractor.py

"""
Script pour récupérer les tickets depuis odoo.
Extraction d'un ticket unique ou d'un groupe de tickets.
"""

import os
import sys
import json
import argparse
from datetime import datetime
from odoo.auth_manager import AuthManager
from odoo.ticket_manager import TicketManager
from core.utils import setup_logging, log_separator
from formatters.json_to_markdown import create_markdown_from_json
from odoo.retrieve_ticket import retrieve_ticket
from odoo.retrieve_tickets_batch import retrieve_tickets_batch, parse_domain, list_projects, list_stages

#importation de l'extracteur d'images HTML (optionnel)
try:
    from utils.image_extractor import extract_images_from_ticket
    from utils.image_extractor.extract_all_images import enhance_ticket_data_with_images
    HTML_IMAGE_EXTRACTOR_AVAILABLE = True
except ImportError:
    HTML_IMAGE_EXTRACTOR_AVAILABLE = False

def parse_arguments():
    """Parse les arguments de ligne de commande."""
    parser = argparse.ArgumentParser(description="Extrait des données depuis Odoo (ticket unique ou par lots).")
    
    # Paramètres communs
    parser.add_argument("--config", "-c", help="Fichier de configuration", default="config.json")
    parser.add_argument("--verbose", "-v", action="store_true", help="Mode verbeux")
    parser.add_argument("--output", "-o", help="Répertoire de sortie", default=None)
    parser.add_argument("--no-md", action="store_true", help="Désactiver la génération automatique du fichier Markdown")
    parser.add_argument("--extract-html-images", action="store_true", help="Activer l'extraction des images intégrées dans le HTML")
    
    # Sous-parseurs pour les différentes commandes
    subparsers = parser.add_subparsers(dest="command", help="Commande à exécuter")
    
    # Commande pour extraire un ticket unique
    single_parser = subparsers.add_parser("ticket", help="Extrait un ticket unique par son code")
    single_parser.add_argument("ticket_code", help="Code du ticket à extraire")
    
    # Commande pour extraire un lot de tickets
    batch_parser = subparsers.add_parser("batch", help="Extrait un lot de tickets")
    batch_parser.add_argument("--domain", "-d", help="Critères de recherche (format: field1:op1:value1;field2:op2:value2)")
    batch_parser.add_argument("--project", "-p", type=int, help="Id du projet")
    batch_parser.add_argument("--stage", "-s", type=int, help="Id de l'étape/statut")
    batch_parser.add_argument("--limit", "-l", type=int, default=50, help="Nombre maximum de tickets à extraire")
    batch_parser.add_argument("--offset", type=int, default=0, help="Index de départ pour la pagination")
    batch_parser.add_argument("--include-existing", action="store_true", help="Inclure les tickets déjà extraits")
    
    # Commande pour lister les projets
    projects_parser = subparsers.add_parser("projects", help="Liste les projets disponibles")
    # Commande pour lister les étapes/statuts
    stages_parser = subparsers.add_parser("stages", help="Liste les étapes/statuts disponibles")
    
    return parser.parse_args()

def load_config(config_file):
    """Charge le fichier de configuration."""
    try:
        with open(config_file, 'r') as f:
            return json.load(f)
    except Exception as e:
        print(f"Erreur lors du chargement de la configuration: {e}")
        sys.exit(1)

def main():
    """Point d'entrée principal du script."""
    args = parse_arguments()
    config = load_config(args.config)
    
    # Configurer la journalisation
    log_level = "DEBUG" if args.verbose else "INFO"
    setup_logging(log_level)
    
    # 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)
        
    # Traiter la commande appropriée
    if args.command == "ticket":
        # Extraction d'un ticket unique
        result = retrieve_ticket(
            ticket_code=args.ticket_code,
            output=args.output,
            config_file=args.config,
            verbose=args.verbose
        )
        
        if not result:
            print(f"Echec de l'extraction du ticket {args.ticket_code}")
            sys.exit(1)
            
        if not args.no_md:
            # Génération du rapport Markdown
            json_file = os.path.join(result, "all_messages.json")
            if os.path.exists(json_file):
                md_file_path = os.path.join(result, "rapport.md")
                print(f"Génération du rapport Markdown...")
                if create_markdown_from_json(json_file, md_file_path):
                    print(f"Rapport Markdown créé: {md_file_path}")
                else:
                    print("Echec de la génération du rapport Markdown.")
    
    elif args.command == "batch":
        # Extraction par lot
        domain = []
        
        if args.domain:
            domain = parse_domain(args.domain)
        
        # Ajouter project_id et stage_id si spécifiés
        if args.project:
            domain.append(["project_id", "=", args.project])
        
        if args.stage:
            domain.append(["stage_id", "=", args.stage])
        
        print(f"Démarrage de l'extraction par lot avec les critères: {domain}")
        print(f"Limite: {args.limit} tickets, offset: {args.offset}")
        
        result = retrieve_tickets_batch(
            domain=domain,
            limit=args.limit,
            offset=args.offset,
            output=args.output,
            config_file=args.config,
            verbose=args.verbose,
            skip_existing=not args.include_existing
        )
        
        if not result or result.get("status") == "error":
            print("Echec de l'extraction par lots")
            sys.exit(1)
        
        # Afficher un résumé des résultats
        print(f"Extraction par lot terminée")
        print(f"Tickets traités: {result.get('processed', 0)}")
        print(f"Tickets ignorés: {result.get('skipped', 0)}")
        
        # Générer des rapports Markdown pour chaque ticket extrait
        if not args.no_md:
            print("Génération des rapports Markdown pour les tickets extraits...")
            processed_tickets = result.get("processed_tickets", [])
            for ticket_info in processed_tickets:
                ticket_dir = ticket_info.get("output_dir")
                if ticket_dir and os.path.exists(ticket_dir):
                    json_file = os.path.join(ticket_dir, "all_messages.json")
                    if os.path.exists(json_file):
                        md_file_path = os.path.join(ticket_dir, "rapport.md")
                        print(f"Génération du rapport Markdown pour {ticket_info.get('code')}...")
                        if create_markdown_from_json(json_file, md_file_path):
                            print(f"Rapport Markdown créé: {md_file_path}")
                        else:
                            print(f"Echec de la génération du rapport Markdown pour {ticket_info.get('code')}")
                    else:
                        print(f"Fichier de messages introuvable pour {ticket_info.get('code')}")
                else:
                    print(f"Répertoire introuvable pour {ticket_info.get('code')}")
                    
    elif args.command == "projects":
        # Lister les projets
        list_projects(args.config)
        
    elif args.command == "stages":
        # Lister les étapes/statuts
        list_stages(args.config)
        
    else:
        parser = argparse.ArgumentParser(description="Extrait des données depuis Odoo (ticket unique ou par lots).")
        parser.print_help()
        sys.exit(1)
        
if __name__ == "__main__":
    main()