whatsapp_web/models/whatsapp_composer.py

from odoo import models, fields, api
from odoo.exceptions import ValidationError
import logging

_logger = logging.getLogger(__name__)

class WhatsAppComposer(models.TransientModel):
    _inherit = 'whatsapp.composer'

    # Campos para soporte de grupos
    recipient_type = fields.Selection([
        ('phone', 'Phone Number'),
        ('group', 'WhatsApp Group')
    ], string='Send To', default='phone', help="Choose recipient type")
    
    # Campo para ID de grupo como string (más robusto)
    whatsapp_group_id_char = fields.Char(string='Group ID', 
                                         help="WhatsApp Group ID (e.g., 120363158956331133@g.us)")
    
    # Campo Many2one opcional si el modelo existe
    whatsapp_group_id = fields.Many2one('ww.group', string='WhatsApp Group', 
                                        help="Select WhatsApp group to send message to",
                                        ondelete='set null')
    
    # Campo para mensaje libre (sin plantilla)
    body = fields.Html(string='Message Body', help="Free text message (for WhatsApp Web accounts without template)")
    
    @api.constrains('recipient_type', 'phone', 'whatsapp_group_id', 'wa_template_id', 'body')
    def _check_recipient_configuration(self):
        """Validar configuración de destinatario en composer"""
        for record in self:
            # Si está en contexto de skip_template_validation, saltar validaciones de plantilla
            if self.env.context.get('skip_template_validation'):
                # Solo validar configuración básica de destinatario
                if record.recipient_type == 'group' and not record.whatsapp_group_id and not record.whatsapp_group_id_char:
                    raise ValidationError("Please select a WhatsApp group or enter a Group ID when sending to groups")
                elif record.recipient_type == 'phone' and not record.phone:
                    raise ValidationError("Please provide a phone number when sending to individuals")
                return  # Saltar el resto de validaciones
            
            # Detectar si hay cuentas de WhatsApp Web disponibles
            whatsapp_web_accounts = record.env['whatsapp.account'].search([
                ('whatsapp_web_url', '!=', False)
            ])
            has_whatsapp_web = bool(whatsapp_web_accounts)
            
            if record.recipient_type == 'group' and not record.whatsapp_group_id and not record.whatsapp_group_id_char:
                raise ValidationError("Please select a WhatsApp group or enter a Group ID when sending to groups")
            elif record.recipient_type == 'phone' and not record.phone:
                raise ValidationError("Please provide a phone number when sending to individuals")
            
            # Validar que haya contenido (plantilla o mensaje libre)
            if not record.wa_template_id and not record.body:
                if has_whatsapp_web:
                    raise ValidationError("Please provide either a template or write a free text message")
                else:
                    raise ValidationError("Template is required for WhatsApp Business API")
            
            # Si usa mensaje libre, debe haber WhatsApp Web
            if record.body and not record.wa_template_id and not has_whatsapp_web:
                raise ValidationError("Free text messages require WhatsApp Web account configuration")
    
    @api.depends('phone', 'batch_mode', 'recipient_type', 'whatsapp_group_id', 'whatsapp_group_id_char')
    def _compute_invalid_phone_number_count(self):
        """Override SOLO para casos específicos de grupos - NO interferir con funcionalidad nativa"""
        for composer in self:
            # SOLO intervenir si es un caso muy específico de grupo
            if (hasattr(composer, 'recipient_type') and composer.recipient_type == 'group'):
                composer.invalid_phone_number_count = 0
                continue
                
            # SOLO intervenir si el phone es explícitamente un ID de grupo
            if composer.phone and composer.phone.endswith('@g.us'):
                composer.invalid_phone_number_count = 0
                continue
                
            # TODOS LOS DEMÁS CASOS: usar lógica original sin modificar
            super(WhatsAppComposer, composer)._compute_invalid_phone_number_count()
    
    @api.onchange('recipient_type')
    def _onchange_recipient_type(self):
        """Limpiar campos al cambiar tipo de destinatario"""
        if self.recipient_type == 'group':
            self.phone = False
        else:
            self.whatsapp_group_id = False
    
    def action_send_whatsapp_template(self):
        """Override del método de envío SOLO para casos específicos de WhatsApp Web sin plantilla"""
        
        # SOLO intervenir si es un caso muy específico:
        # 1. No hay plantilla
        # 2. Hay mensaje libre (body)
        # 3. Es tipo grupo O hay WhatsApp Web disponible
        whatsapp_web_accounts = self.env['whatsapp.account'].search([
            ('whatsapp_web_url', '!=', False)
        ])
        has_whatsapp_web = bool(whatsapp_web_accounts)
        
        # CONDICIÓN MUY ESPECÍFICA para no interferir con funcionalidad nativa
        is_special_case = (
            not self.wa_template_id and  # Sin plantilla
            self.body and  # Con mensaje libre
            has_whatsapp_web and  # Con WhatsApp Web disponible
            (self.recipient_type == 'group' or  # Es grupo
             (hasattr(self, 'phone') and self.phone and self.phone.endswith('@g.us')))  # O es ID de grupo directo
        )
        
        if is_special_case:
            return self._send_whatsapp_web_message()
        
        # TODOS LOS DEMÁS CASOS: usar método original sin modificar
        return super().action_send_whatsapp_template()
    
    def _send_whatsapp_web_message(self):
        """Enviar mensaje WhatsApp Web sin plantilla - siguiendo lógica original"""
        records = self._get_active_records()
        
        for record in records:
            # Determinar destinatario
            if self.recipient_type == 'group':
                if self.whatsapp_group_id:
                    mobile_number = self.whatsapp_group_id.whatsapp_web_id
                elif self.whatsapp_group_id_char:
                    mobile_number = self.whatsapp_group_id_char
                else:
                    raise ValidationError("Please specify a group")
            else:
                mobile_number = self.phone
                if not mobile_number:
                    raise ValidationError("Please provide a phone number")
            
            # Crear mail.message con adjuntos si existen (siguiendo lógica original)
            post_values = {
                'attachment_ids': [self.attachment_id.id] if self.attachment_id else [],
                'body': self.body,
                'message_type': 'whatsapp_message',
                'partner_ids': hasattr(record, '_mail_get_partners') and record._mail_get_partners()[record.id].ids or record._whatsapp_get_responsible().partner_id.ids,
            }
            
            if hasattr(records, '_message_log'):
                message = record._message_log(**post_values)
            else:
                message = self.env['mail.message'].create(
                    dict(post_values, res_id=record.id, model=self.res_model,
                         subtype_id=self.env['ir.model.data']._xmlid_to_res_id("mail.mt_note"))
                )
            
            # Crear mensaje WhatsApp (siguiendo estructura original)
            whatsapp_message = self.env['whatsapp.message'].create({
                'mail_message_id': message.id,
                'mobile_number': mobile_number,
                'mobile_number_formatted': mobile_number,
                'recipient_type': self.recipient_type,
                'wa_template_id': False,  # Sin plantilla
                'wa_account_id': self._get_whatsapp_web_account().id,
                'state': 'outgoing',
            })
            
            # Enviar mensaje usando la lógica original de _send_message
            whatsapp_message._send_message()
        
        return {'type': 'ir.actions.act_window_close'}
    
    def _prepare_whatsapp_message_values(self, record):
        """Override SOLO para agregar información de grupo - NO interferir con funcionalidad nativa"""
        
        # SIEMPRE usar lógica original primero
        values = super()._prepare_whatsapp_message_values(record)
        
        # SOLO agregar información de grupo si es caso específico
        if (hasattr(self, 'recipient_type') and self.recipient_type == 'group'):
            group_id_to_use = None
            if self.whatsapp_group_id:
                try:
                    group_id_to_use = self.whatsapp_group_id.whatsapp_web_id
                    values.update({
                        'whatsapp_group_id': self.whatsapp_group_id.id,
                    })
                except:
                    # Si falla, usar campo manual
                    pass
                    
            if not group_id_to_use and self.whatsapp_group_id_char:
                group_id_to_use = self.whatsapp_group_id_char
                
            # Solo actualizar si hay un grupo válido
            if group_id_to_use:
                values.update({
                    'recipient_type': 'group',
                    'mobile_number': group_id_to_use,
                    'mobile_number_formatted': group_id_to_use,
                })
        
        # Siempre agregar recipient_type para compatibilidad
        if not values.get('recipient_type'):
            values['recipient_type'] = 'phone'
        
        return values
    
    def _get_whatsapp_web_account(self):
        """Obtener cuenta de WhatsApp Web disponible"""
        # Primero intentar usar la cuenta de la plantilla si existe
        if self.wa_template_id and self.wa_template_id.wa_account_id and self.wa_template_id.wa_account_id.whatsapp_web_url:
            return self.wa_template_id.wa_account_id
            
        # Si no, buscar cualquier cuenta con WhatsApp Web
        account = self.env['whatsapp.account'].search([
            ('whatsapp_web_url', '!=', False)
        ], limit=1)
        
        if not account:
            raise ValidationError("No WhatsApp Web account configured")
            
        return account
    
    def _send_whatsapp_message_without_template(self, body, phone=None, group_id=None):
        """Enviar mensaje de WhatsApp sin plantilla (solo para WhatsApp Web)"""
        # Solo funciona con WhatsApp Web, no con API oficial
        if not (phone or group_id):
            raise ValidationError("Debe especificar teléfono o grupo")
            
        # Crear mensaje directamente
        message_vals = {
            'body': body,
            'mobile_number': group_id or phone,
            'recipient_type': 'group' if group_id else 'phone',
            'wa_template_id': False,  # Sin plantilla
            'state': 'outgoing',
        }
        
        if group_id and hasattr(self, 'whatsapp_group_id') and self.whatsapp_group_id:
            message_vals['whatsapp_group_id'] = self.whatsapp_group_id.id
            
        # Crear mail.message
        mail_message = self.env['mail.message'].create({
            'body': body,
            'message_type': 'whatsapp_message',
        })
        
        message_vals['mail_message_id'] = mail_message.id
        
        # Crear y enviar mensaje WhatsApp
        whatsapp_message = self.env['whatsapp.message'].create(message_vals)
        whatsapp_message._send_message()
        
        return whatsapp_message