projetcbaollm/odoo_data/odoo_toolkit/menu_handlers.py

from ticket_manager import TicketManager
from ticket_search import TicketSearch
from ticket_display import TicketDisplay
from ticket_classification import TicketClassification
from ui_utils import get_ticket_codes, get_field_name, confirm_action
import os
import json
from config import EXPORT_DIR, ODOO_HOST

# Initialisation des objets
ticket_manager = TicketManager()
ticket_search = TicketSearch()
ticket_display = TicketDisplay()
ticket_classification = TicketClassification()

def handle_search_by_code():
    """Gère la recherche de tickets par code"""
    ticket_code = input("\nEntrez le code du ticket: ")
    if not ticket_code:
        print("Aucun code de ticket fourni.")
        return
    
    ticket = ticket_search.get_ticket_by_code(ticket_code)
    if not ticket:
        print(f"Aucun ticket trouvé avec le code {ticket_code}")
        return
    
    print(f"\nTicket trouvé: {ticket.get('name', 'Sans nom')}")
    print("Voulez-vous voir plus de détails?")
    if confirm_action():
        ticket_display.display_ticket(ticket)

def handle_ticket_display_field():
    """Gère l'affichage d'un champ spécifique d'un ticket"""
    ticket_codes = get_ticket_codes()
    if not ticket_codes:
        return
    
    field_name = get_field_name()
    if not field_name:
        return
    
    for code in ticket_codes:
        ticket = ticket_search.get_ticket_by_code(code)
        if ticket:
            ticket_display.display_field(ticket, field_name)
        else:
            print(f"Ticket {code} non trouvé")

def handle_ticket_export():
    """Gère l'exportation des tickets en JSON"""
    ticket_codes = get_ticket_codes()
    if not ticket_codes:
        return
    
    tickets = []
    for code in ticket_codes:
        ticket = ticket_search.get_ticket_by_code(code)
        if ticket:
            tickets.append(ticket)
    
    if not tickets:
        print("Aucun ticket à exporter.")
        return
    
    filename = input("Nom du fichier d'export (sans extension): ")
    if not filename:
        filename = "tickets_export"
    
    # Assurer que le répertoire d'export existe
    if not os.path.exists(EXPORT_DIR):
        os.makedirs(EXPORT_DIR)
    
    file_path = os.path.join(EXPORT_DIR, f"{filename}.json")
    with open(file_path, 'w', encoding='utf-8') as f:
        json.dump(tickets, f, indent=4, ensure_ascii=False)
    
    print(f"Tickets exportés avec succès dans {file_path}")

def handle_field_ticket_classification():
    """Gère la classification des tickets selon un champ spécifique"""
    ticket_codes = get_ticket_codes()
    if not ticket_codes:
        return
    
    field_name = get_field_name()
    if not field_name:
        return
    
    tickets = []
    for code in ticket_codes:
        ticket = ticket_search.get_ticket_by_code(code)
        if ticket:
            tickets.append(ticket)
    
    if not tickets:
        print("Aucun ticket à classer.")
        return
    
    classified_tickets = ticket_classification.classify_tickets_by_field(tickets, field_name)
    print(f"Classification terminée: {len(classified_tickets)} groupes créés.")

def handle_common_values_analysis():
    """Gère l'analyse des valeurs communes entre tickets"""
    ticket_codes = get_ticket_codes()
    if len(ticket_codes) < 2:
        print("L'analyse des valeurs communes nécessite au moins 2 tickets.")
        return
    
    tickets = []
    for code in ticket_codes:
        ticket = ticket_search.get_ticket_by_code(code)
        if ticket:
            tickets.append(ticket)
    
    if len(tickets) < 2:
        print("Insuffisamment de tickets valides pour l'analyse.")
        return
    
    # Analyse des champs communs
    common_fields = ticket_manager.analyze_common_values(tickets)
    
    print("\nChamps avec valeurs identiques entre tous les tickets:")
    for field, value in common_fields.items():
        print(f"- {field}: {value}")
    
    if not common_fields:
        print("Aucun champ commun trouvé.")

def handle_search_by_relational_fields():
    """Gère la recherche et classification par champs relationnels"""
    print("\nRecherche par champs relationnels:")
    print("1. stage_id (État)")
    print("2. project_id (Projet)")
    print("3. user_id (Assigné à)")
    print("4. Autre champ relationnel")
    
    option = input("Choisissez une option (1-4): ")
    field_name = ""
    
    if option == '1':
        field_name = "stage_id"
    elif option == '2':
        field_name = "project_id"
    elif option == '3':
        field_name = "user_id"
    elif option == '4':
        field_name = input("Entrez le nom du champ relationnel: ")
    else:
        print("Option invalide")
        return
    
    # Récupérer les valeurs possibles pour ce champ
    field_values = ticket_search.get_field_values(field_name)
    if not field_values:
        print(f"Impossible de récupérer les valeurs pour le champ {field_name}")
        return
    
    print(f"\nValeurs disponibles pour {field_name}:")
    for value_id, name in field_values.items():
        print(f"ID: {value_id} - {name}")
    
    value_id = input("\nEntrez l'ID à rechercher: ")
    try:
        value_id = int(value_id)
    except ValueError:
        print("L'ID doit être un nombre entier")
        return
    
    # Recherche des tickets
    field_criteria = {field_name: value_id}
    tickets = ticket_search.search_tickets_by_fields(field_criteria)
    
    if not tickets:
        return
    
    print(f"{len(tickets)} tickets trouvés.")
    
    # Demander si l'utilisateur veut classer ces tickets
    print("\nVoulez-vous classer ces tickets par un champ?")
    if confirm_action():
        classify_field = get_field_name()
        if classify_field:
            classified_tickets = ticket_classification.classify_tickets_by_field(tickets, classify_field)
            print(f"Classification terminée: {len(classified_tickets)} groupes créés.")

def handle_search_by_project_and_stage():
    """Gère la recherche et sauvegarde de tickets par project_id et stage_id"""
    # Récupérer les projets disponibles
    projects = ticket_search.get_field_values('project_id')
    if not projects:
        print("Impossible de récupérer la liste des projets")
        return
        
    print("\nProjets disponibles:")
    for project_id, project_name in projects.items():
        print(f"ID: {project_id} - {project_name}")
    
    # Demander à l'utilisateur de choisir un projet
    project_id = input("\nEntrez l'ID du projet: ")
    try:
        project_id = int(project_id)
        if project_id not in projects:
            print("ID de projet invalide")
            return
    except ValueError:
        print("L'ID doit être un nombre entier")
        return
        
    # Récupérer les étapes disponibles
    stages = ticket_search.get_field_values('stage_id')
    if not stages:
        print("Impossible de récupérer la liste des étapes")
        return
        
    print("\nÉtapes disponibles:")
    for stage_id, stage_name in stages.items():
        print(f"ID: {stage_id} - {stage_name}")
    
    # Demander à l'utilisateur de choisir une étape ou toutes
    stage_input = input("\nEntrez l'ID de l'étape (ou 'tous' pour toutes les étapes): ")
    
    all_tickets = []
    project_name = projects[project_id]
    
    if stage_input.lower() in ('tous', 'toutes', 'all'):
        # Récupérer tous les tickets du projet pour chaque étape
        for stage_id, stage_name in stages.items():
            tickets = ticket_search.search_by_project_and_stage(project_id, stage_id)
            all_tickets.extend(tickets)
    else:
        try:
            stage_id = int(stage_input)
            if stage_id not in stages:
                print("ID d'étape invalide")
                return
                
            all_tickets = ticket_search.search_by_project_and_stage(project_id, stage_id)
        except ValueError:
            print("L'ID doit être un nombre entier")
            return
    
    if not all_tickets:
        print("Aucun ticket trouvé avec ces critères")
        return
        
    # Sauvegarder les tickets par étape
    ticket_classification.save_tickets_by_stage(all_tickets, project_name)
    
    print(f"\nTous les tickets ont été sauvegardés avec succès dans des répertoires par étape.")

def handle_project_tickets_by_stage():
    """Récupère et sauvegarde les tickets d'un projet, classés par étape"""
    from ticket_search import TicketSearch
    from ticket_utils import save_project_tickets_by_stage
    
    # Créer une nouvelle instance à chaque fois pour éviter les problèmes de connexion
    ticket_search = TicketSearch()
    
    # Vérifier la connexion
    if not ticket_search._check_connection():
        print("\nERREUR: Impossible de se connecter à Odoo.")
        print("Vérifiez vos paramètres de connexion dans config.py et assurez-vous que:")
        print(f"1. L'hôte Odoo est accessible: {ODOO_HOST}")
        print("2. Les identifiants sont corrects")
        print("3. Le réseau permet la connexion au serveur Odoo")
        return
    
    # Récupérer les projets disponibles
    projects = ticket_search.get_field_values('project_id')
    if not projects:
        print("\nERREUR: Impossible de récupérer la liste des projets.")
        print("Causes possibles:")
        print("1. Problème de permissions - votre utilisateur n'a pas accès aux projets")
        print("2. Aucun projet n'existe dans le système")
        print("3. Problème de connexion intermittent avec le serveur Odoo")
        return
    
    print("\nProjets disponibles:")
    for project_id, project_name in projects.items():
        print(f"ID: {project_id} - {project_name}")
    
    # Demander à l'utilisateur de choisir un projet
    project_input = input("\nEntrez l'ID du projet (ou 'q' pour quitter): ")
    if project_input.lower() == 'q':
        return
        
    try:
        project_id = int(project_input)
        if project_id not in projects:
            print("ID de projet invalide")
            return
    except ValueError:
        print("L'ID doit être un nombre entier")
        return
    
    project_name = projects[project_id]
    print(f"\nRécupération des tickets du projet: {project_name}")
    print("Note: Seuls les champs essentiels sont récupérés pour éviter les erreurs SQL")
    
    # Récupérer tous les tickets du projet
    tickets = ticket_search.get_tickets_by_project(project_id)
    
    if not tickets:
        print("\nAucun ticket trouvé pour ce projet.")
        print("Causes possibles:")
        print("1. Le projet n'a pas de tickets")
        print("2. Vous n'avez pas accès aux tickets de ce projet")
        print("3. Il y a eu une erreur SQL lors de la récupération (vérifiez les messages d'erreur)")
        return
    
    print(f"\n{len(tickets)} tickets récupérés avec succès.")
    
    # Sauvegarder les tickets organisés par étape
    save_project_tickets_by_stage(tickets, project_name)
    print("\nTraitement terminé!")
    print("Vous pouvez maintenant utiliser ces fichiers JSON pour d'autres analyses.")

def handle_list_models():
    """Gère l'affichage de la liste des modèles"""
    ticket_manager.list_models()


def handle_list_model_fields():
    """Gère l'affichage des champs d'un modèle"""
    model_name = input("\nEntrez le nom du modèle: ")
    if not model_name:
        print("Aucun nom de modèle fourni.")
        return
    ticket_manager.list_model_fields(model_name)


def handle_export_model_fields_to_json():
    """Gère l'exportation des informations des champs d'un modèle en JSON"""
    model_name = input("\nEntrez le nom du modèle: ")
    if not model_name:
        print("Aucun nom de modèle fourni.")
        return
    filename = input("Entrez le nom du fichier pour l'exportation: ")
    if not filename:
        print("Aucun nom de fichier fourni.")
        return
    ticket_manager.export_model_fields_to_json(model_name, filename)