odoo_toolkit/ticket_manager.py

from odoo_connection import OdooConnection
import os
import json
from utils import save_json, ensure_export_directory
from config import EXPORT_DIR
from data_filter import filter_ticket_data

class TicketManager:
    """Gestionnaire de tickets simplifié avec seulement les fonctionnalités essentielles"""
    
    def __init__(self):
        """Initialise le gestionnaire de tickets"""
        self.conn = OdooConnection()
        self.odoo = self.conn.get_odoo_instance()
        self.model_name = "project.task"
    
    def _check_connection(self):
        """Vérifie la connexion Odoo"""
        if self.odoo is None:
            try:
                self.conn = OdooConnection()
                self.odoo = self.conn.get_odoo_instance()
            except Exception as e:
                print(f"Erreur de connexion: {e}")
                self.odoo = None
        return self.odoo is not None
    
    def _safe_execute(self, model, method, *args):
        """Exécute une méthode Odoo de manière sécurisée"""
        if not self._check_connection():
            return None
        try:
            return self.odoo.execute(model, method, *args)
        except Exception as e:
            print(f"Erreur lors de {method} sur {model}: {e}")
            return None
    
    def list_models(self):
        """Affiche la liste des modèles disponibles dans Odoo"""
        models = self._safe_execute('ir.model', 'search_read', [], ['model', 'name'])
        if not models:
            print("Aucun modèle disponible.")
            return []
        
        print("\nListe des modèles disponibles:")
        for model in models:
            print(f"Modèle: {model['name']} (ID: {model['model']})")
        return models
    
    def list_model_fields(self, model_name):
        """Affiche les champs d'un modèle donné"""
        fields_info = self._safe_execute(model_name, 'fields_get')
        if not fields_info:
            print(f"Aucun champ trouvé pour le modèle {model_name}.")
            return []
        
        print(f"\nChamps du modèle {model_name}:")
        for field_name, field_data in fields_info.items():
            print(f"Champ: {field_name} - Type: {field_data['type']}")
        return fields_info
    
    def get_project_tickets_summary(self, project_id):
        """Récupère un résumé des tickets d'un projet pour permettre la sélection"""
        domain = [('project_id', '=', project_id)]
        ticket_ids = self._safe_execute(self.model_name, 'search', domain, 0, 200)
        
        if not ticket_ids:
            print(f"Aucun ticket trouvé pour le projet ID: {project_id}")
            return []
        
        fields_to_read = ['id', 'name', 'code', 'stage_id', 'date_deadline']
        tickets_data = self._safe_execute(self.model_name, 'read', ticket_ids, fields_to_read)
        
        if not tickets_data:
            print("Erreur lors de la récupération des données des tickets.")
            return []
        
        summary_tickets = []
        for ticket in tickets_data:
            stage_name = "Non défini"
            if ticket.get('stage_id'):
                stage_name = ticket['stage_id'][1] if isinstance(ticket['stage_id'], list) and len(ticket['stage_id']) > 1 else str(ticket['stage_id'])
            
            summary_tickets.append({
                'id': ticket['id'],
                'name': ticket['name'],
                'code': ticket.get('code', 'N/A'),
                'stage_id': ticket.get('stage_id', [0, "Non défini"]),
                'stage_name': stage_name,
                'date_deadline': ticket.get('date_deadline', 'Non défini')
            })
        
        return summary_tickets
    
    def export_tickets_by_project_and_stage(self, project_id, selected_stage_ids=None):
        """Exporte les tickets d'un projet classés par étape"""
        project_data = self._safe_execute('project.project', 'search_read', [('id', '=', project_id)], ['id', 'name'])
        if not project_data:
            print(f"Projet ID {project_id} introuvable")
            return
        
        project_name = project_data[0]['name']
        domain = [('project_id', '=', project_id)]
        if selected_stage_ids:
            domain.append(('stage_id', 'in', selected_stage_ids))
        
        ticket_ids = self._safe_execute(self.model_name, 'search', domain, 0, 1000)
        if not ticket_ids:
            print("Aucun ticket trouvé")
            return
        
        tickets = [self.get_ticket_by_id(ticket_id) for ticket_id in ticket_ids]
        
        tickets_by_stage = {}
        for ticket in tickets:
            stage_id = ticket["Champs Relationnels"].get("stage_id", [0, "Non classé"])[0]
            stage_name = ticket["Champs Relationnels"].get("stage_id", [0, "Non classé"])[1]
            key = f"{stage_id}_{stage_name}"
            
            if key not in tickets_by_stage:
                tickets_by_stage[key] = []
            tickets_by_stage[key].append(ticket)
        
        project_dir = ensure_export_directory(f"project_{project_id}_{project_name.replace(' ', '_')}")
        
        for stage_key, stage_tickets in tickets_by_stage.items():
            stage_dir = os.path.join(project_dir, stage_key)
            os.makedirs(stage_dir, exist_ok=True)
            save_json(os.path.join(stage_dir, "all_tickets.json"), stage_tickets)
        
        print(f"Exportation terminée dans {project_dir}/")