projetcbaollm/odoo_data/odoo_toolkit/ticket_search.py

from odoo_connection import OdooConnection

class TicketSearch:
    def __init__(self):
        """Initialise la classe de recherche de tickets et établit la connexion à Odoo"""
        try:
            self.conn = OdooConnection()
            self.odoo = self.conn.get_odoo_instance()
            # Force la connexion immédiatement
            if not self.conn.connected:
                success = self.conn.connect()
                if success:
                    print("Connexion à Odoo établie avec succès.")
                    self.odoo = self.conn.get_odoo_instance()
                else:
                    print("Échec de la connexion à Odoo.")
                    self.odoo = None
            self.model_name = "project.task"
        except Exception as e:
            print(f"Erreur lors de l'initialisation de TicketSearch: {str(e)}")
            self.odoo = None
            self.model_name = "project.task"

    def initialize_connection(self):
        """Initialise la connexion à Odoo"""
        if self.odoo is None:
            self.conn = OdooConnection()
            self.odoo = self.conn.get_odoo_instance()
            if self.odoo is None:
                print("Erreur: Impossible de se connecter à Odoo.")
                return False
        return True

    def _check_connection(self):
        """Vérifie que la connexion Odoo est active"""
        if not self.initialize_connection():
            return False
        return True

    def search_tickets_by_fields(self, field_criteria, limit=50):
        """Recherche des tickets selon des critères de champs"""
        if not self._check_connection():
            return []

        domain = [(field, '=', value) for field, value in field_criteria.items()]
        print(f"\nRecherche de tickets avec les critères: {field_criteria}")

        try:
            ticket_ids = self.odoo.execute(self.model_name, 'search', domain, 0, limit)
            if not ticket_ids:
                print("Aucun ticket ne correspond aux critères de recherche.")
                return []

            # Spécifier explicitement les champs à récupérer pour éviter les erreurs de relation
            fields_to_read = ['id', 'name', 'stage_id', 'create_date', 'write_date', 
                              'description', 'priority', 'sequence', 'date_deadline', 'project_id']
            
            tickets = self.odoo.execute(self.model_name, 'read', ticket_ids, fields_to_read)
            print(f"{len(tickets)} tickets trouvés.")
            return tickets
        except Exception as e:
            print(f"Erreur lors de la recherche de tickets: {str(e)}")
            return []

    def get_ticket_by_id(self, ticket_id):
        """Récupère un ticket par son ID"""
        if not self._check_connection():
            return None

        try:
            ticket_data = self.odoo.execute(self.model_name, 'read', [ticket_id])
            return ticket_data[0] if ticket_data else None
        except Exception as e:
            print(f"Erreur lors de la récupération du ticket {ticket_id}: {str(e)}")
            return None

    def get_ticket_by_code(self, ticket_code):
        """Récupère un ticket par son code (numéro de séquence)"""
        if not self._check_connection():
            return None
        
        try:
            # Recherche par le champ name qui contient généralement le code du ticket
            domain = [('name', '=', ticket_code)]
            ticket_ids = self.odoo.execute(self.model_name, 'search', domain, 0, 1)
            
            if not ticket_ids:
                # Essayer avec un match partiel si la recherche exacte échoue
                domain = [('name', 'ilike', ticket_code)]
                ticket_ids = self.odoo.execute(self.model_name, 'search', domain, 0, 1)
            
            if not ticket_ids:
                print(f"Aucun ticket trouvé avec le code {ticket_code}")
                return None
                
            ticket_data = self.odoo.execute(self.model_name, 'read', [ticket_ids[0]])
            return ticket_data[0] if ticket_data else None
        except Exception as e:
            print(f"Erreur lors de la recherche du ticket {ticket_code}: {str(e)}")
            return None

    def get_field_values(self, field_name):
        """Récupère les valeurs possibles pour un champ relationnel"""
        if not self._check_connection():
            return {}
        
        # Déterminer le modèle à interroger en fonction du champ
        relation_models = {
            'stage_id': 'project.task.type',
            'project_id': 'project.project',
            'user_id': 'res.users',
            # Ajouter d'autres relations si nécessaire
        }
        
        model = relation_models.get(field_name)
        if not model:
            print(f"Modèle relationnel inconnu pour le champ {field_name}")
            return {}
        
        try:
            # Récupérer tous les enregistrements du modèle relationnel
            record_ids = self.odoo.execute(model, 'search', [], 0, 100)
            records = self.odoo.execute(model, 'read', record_ids, ['name'])
            
            # Créer un dictionnaire {id: name}
            values = {record['id']: record['name'] for record in records}
            return values
        except Exception as e:
            print(f"Erreur lors de la récupération des valeurs pour {field_name}: {str(e)}")
            return {}

    def search_by_project_and_stage(self, project_id, stage_id, limit=100):
        """Recherche des tickets par project_id et stage_id"""
        if not self._check_connection():
            return []
        
        domain = [
            ('project_id', '=', project_id),
            ('stage_id', '=', stage_id)
        ]
        
        print(f"\nRecherche de tickets du projet {project_id} à l'étape {stage_id}")
        
        try:
            ticket_ids = self.odoo.execute(self.model_name, 'search', domain, 0, limit)
            if not ticket_ids:
                print("Aucun ticket ne correspond aux critères de recherche.")
                return []
            
            # Spécifier explicitement les champs à récupérer pour éviter les erreurs de relation
            fields_to_read = ['id', 'name', 'stage_id', 'create_date', 'write_date', 
                              'description', 'priority', 'sequence', 'date_deadline']
            
            tickets = self.odoo.execute(self.model_name, 'read', ticket_ids, fields_to_read)
            print(f"{len(tickets)} tickets trouvés.")
            return tickets
        except Exception as e:
            print(f"Erreur lors de la recherche: {str(e)}")
            return []

    def get_tickets_by_project(self, project_id, limit=200):
        """Récupère tous les tickets d'un projet spécifique"""
        if not self._check_connection():
            return []
        
        domain = [('project_id', '=', project_id)]
        
        try:
            # Récupérer d'abord les IDs des tickets
            ticket_ids = self.odoo.execute(self.model_name, 'search', domain, 0, limit)
            if not ticket_ids:
                print(f"Aucun ticket trouvé pour le projet ID: {project_id}")
                return []
            
            # Spécifier explicitement les champs à récupérer pour éviter les erreurs de relation
            fields_to_read = ['id', 'name', 'stage_id', 'create_date', 'write_date', 
                              'description', 'priority', 'sequence', 'date_deadline']
            
            tickets = self.odoo.execute(self.model_name, 'read', ticket_ids, fields_to_read)
            print(f"{len(tickets)} tickets trouvés pour le projet ID: {project_id}")
            return tickets
        except Exception as e:
            print(f"Erreur lors de la recherche de tickets par projet: {str(e)}")
            return []