diff --git a/migrations/5.0.25.5.0/post-0001_add_new_column.py b/migrations/5.0.25.5.0/post-0001_add_new_column.py
new file mode 100644
index 0000000..dd60093
--- /dev/null
+++ b/migrations/5.0.25.5.0/post-0001_add_new_column.py
@@ -0,0 +1,18 @@
+from tools import config
+import pooler
+
+
+def up(cursor, installed_version):
+    if not installed_version or config.updating_all:
+        return
+
+    pool = pooler.get_pool(cursor.dbname)
+
+    pool.get("poweremail.templates")._auto_init(cursor, context={'module': 'poweremail'})
+
+
+def down(cursor, installed_version):
+    pass
+
+
+migrate = up
\ No newline at end of file
diff --git a/poweremail_template.py b/poweremail_template.py
index f7838d5..9165db3 100644
--- a/poweremail_template.py
+++ b/poweremail_template.py
@@ -396,6 +396,7 @@ def _get_model_data_name_search(
         'report_template':fields.many2one(
                 'ir.actions.report.xml',
                 'Report to send'),
+        'report_template_object_reference': fields.char('Reference of the report', size=300, required=False),
         #'report_template':fields.reference('Report to send',[('ir.actions.report.xml','Reports')],size=128),
         'allowed_groups':fields.many2many(
                 'res.groups',
@@ -905,6 +906,10 @@ def _generate_partner_events(self,
         return True
 
     def create_report(self, cursor, user, template, record_ids, context=None):
+        """"
+        Generate report to be attached and return it
+        If contain object_to_report_id in context, it will be used instead of record_ids
+        """
         if context is None:
             context = {}
         report_obj = self.pool.get('ir.actions.report.xml')
@@ -935,6 +940,7 @@ def _generate_attach_reports(self, cursor, user, template, record_ids, mail, con
         if context is None:
             context = {}
         lang = get_value(cursor, user, record_ids[0], template.lang, template, context=context)
+        record_reference_ids = record_ids
         ctx = context.copy()
         if lang:
             ctx['lang'] = lang
@@ -949,14 +955,120 @@ def _generate_attach_reports(self, cursor, user, template, record_ids, mail, con
 
         return True
 
+    def _get_records_from_report_template_object_reference(self, cursor, user, template, record_ids, context=None):
+        """
+        Evaluate the expression in report_template_object_reference field
+        to get the records to be used to generate the report.
+
+        :param cursor: Database Cursor
+        :param user: ID of User
+        :param template: Browse record of template
+        :param record_ids: IDs of objects to be used to evaluate the expression
+        :param context: Context arguments
+
+        :return: dict with model and record_ids keys evaluated from the expression
+        """
+        res_ids = []
+        expr = template.report_template_object_reference.replace('object', 'rec')
+        model = ''
+        for rec_obj in self.pool.get(template.object_name.model).simple_browse(cursor, user, record_ids, context=context):
+            try:
+                value = eval(expr, {}, {'rec': rec_obj})
+                if not value:
+                    continue
+
+                if isinstance(value, (list, tuple)):
+                    value = value[0]
+
+                model = value._table_name
+                if hasattr(value, 'id'):
+                    value = value.id
+
+                res_ids.append(value)
+            except Exception as e:
+                LOGGER.notifyChannel(
+                    _("Power Email"),
+                    netsvc.LOG_DEBUG,
+                    _("Error evaluating reference '%s' for record id %d: %s") % (
+                        template.report_template_object_reference, rec_obj.id, e)
+                )
+
+        return {
+            'model': model,
+            'record_ids': res_ids
+        }
+
+    def create_report_from_report_template_object_reference_reference(self, cursor, user, template, record_ids, context=None):
+        """
+        Generate report to be attached from the expression in report_template_object_reference field
+        and return it.
+
+        :param cursor: Database Cursor
+        :param user: ID of User
+        :param template: Browse record of template
+        :param record_ids: IDs of template object
+        :param context:
+        :return:
+        """
+        if 'object' not in template.report_template_object_reference:
+            LOGGER.notifyChannel(
+                _("Power Email"),
+                netsvc.LOG_ERROR,
+                _("Error evaluating reference: %s from record id %d. The expression must contain the 'object' variable.") % (
+                    template.report_template_object_reference, template.id)
+            )
+
+        refs = self._get_records_from_report_template_object_reference(cursor,
+                                                                       user,
+                                                                       template,
+                                                                       record_ids,
+                                                                       context=context)
+        if not refs.get('record_ids', []):
+            LOGGER.notifyChannel(
+                _("Power Email"),
+                netsvc.LOG_ERROR,
+                _("Error evaluating reference: %s from record id %d. The expression did not return any record.") % (
+                    template.report_template_object_reference, template.id)
+            )
+
+        return self.create_report(cursor, user, template,
+                                         refs.get('record_ids', []),
+                                         context=context)
+
     def get_dynamic_attachment(self, cursor, user, template, record_ids, context=None):
-        res = {}
-        if template.report_template:
-            report_vals = self.create_report(cursor, user, template, record_ids, context=context)
-            res = {
-                'file': base64.b64encode(report_vals[0]),
-                'extension': report_vals[1]
-            }
+        """
+        Generate report to be attached and return it. If contain a report_template_object_reference field,
+        it will generate the report from the records evaluated from the expression in that field. Ignoring
+        the record_ids parameter.
+
+        :param cursor: Database Cursor
+        :param user: ID of User
+        :param template: Browse record of template
+        :param record_ids: IDs of template object
+        :param context: Context arguments
+
+        :return: List of dicts with 'file' (base64 encoded) and 'extension' keys
+        """
+        res = []
+        if template.report_template_object_reference:
+            try:
+                report_vals = self.create_report_from_report_template_object_reference_reference(
+                    cursor, user, template, record_ids, context=context
+                )
+            except Exception as e:
+                LOGGER.notifyChannel(
+                    _("Power Email"),
+                    netsvc.LOG_ERROR,
+                    _("Error evaluating reference: %s from record id %d. Error: %s") % (template.report_template_object_reference, template.id, e)
+                )
+        else:
+            report_vals = self.create_report(cursor, user, template, record_ids,
+                                             context=context)
+        res.append({
+            'file': base64.b64encode(report_vals[0].encode()),
+            'extension': report_vals[1]
+        })
+
         return res
 
     def set_dynamic_attachments(self, cursor, user, template, mail, record_ids, context=None):
@@ -966,9 +1078,9 @@ def set_dynamic_attachments(self, cursor, user, template, mail, record_ids, cont
         mailbox_obj = self.pool.get('poweremail.mailbox')
 
         res = False
-        dynamic_attachment = self.get_dynamic_attachment(cursor, user, template, record_ids, context=context)
+        dynamic_attachments = self.get_dynamic_attachment(cursor, user, template, record_ids, context=context)
 
-        if dynamic_attachment:
+        for dynamic_attachment in dynamic_attachments:
             new_att_vals = {
                 'name': mail.pem_subject + ' (Email Attachment)',
                 'datas': dynamic_attachment['file'],
diff --git a/poweremail_template_view.xml b/poweremail_template_view.xml
index 3ff5ce6..75093dd 100644
--- a/poweremail_template_view.xml
+++ b/poweremail_template_view.xml
@@ -72,7 +72,7 @@
                                 <!--
                                     I dont advice using the html widget
                                     because tinymce is interfering too
-                                    much with the html generated 
+                                    much with the html generated
 
                                     Sunday,30 May 2010:Enabling HTML as
                                     community votes for it
@@ -142,6 +142,8 @@
                                 <field name="save_to_drafts" colspan="4"/>
                                 <field name="inline" colspan="4"/>
                             </group>
+                            <separator string="Attachments (Report to attach)" colspan="4" />
+                            <field name="report_template_object_reference" colspan="2"/>
                             <group>
                                 <separator colspan="4" string="Allowed User Groups" />
                                 <field name="allowed_groups" string="Allowed User Groups" nolabel="1" colspan="4"/>
diff --git a/tests/__init__.py b/tests/__init__.py
index 2c52bdf..9f81e81 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1,2 +1,3 @@
 from .test_poweremail_mailbox import *
 from .test_poweremail_templates import *
+from .test_attach_other_models import *
diff --git a/tests/test_attach_other_models.py b/tests/test_attach_other_models.py
new file mode 100644
index 0000000..d3eea9f
--- /dev/null
+++ b/tests/test_attach_other_models.py
@@ -0,0 +1,238 @@
+# coding=utf-8
+
+from destral.transaction import Transaction
+from destral import testing
+from mock import patch
+from base64 import b64decode
+import netsvc
+from mock import ANY
+
+class TestAttachOtherModels(testing.OOTestCase):
+    """
+    Test the attachment of other models to the email
+    """
+
+    def setUp(self):
+        self.openerp.install_module('giscedata_facturacio')
+
+    def _create_account(self, cursor, uid, extra_vals=None):
+        acc_obj = self.openerp.pool.get('poweremail.core_accounts')
+
+        vals = {
+            'name': 'Test account',
+            'user': uid,
+            'email_id': 'test@example.com',
+            'smtpserver': 'smtp.example.com',
+            'smtpport': 587,
+            'smtpuname': 'test',
+            'smtppass': 'test',
+            'company': 'yes'
+        }
+        if extra_vals:
+            vals.update(extra_vals)
+
+        acc_id = acc_obj.create(cursor, uid, vals)
+        return acc_id
+
+    def _create_template(self, cursor, uid, extra_vals=None):
+        if extra_vals is None:
+            extra_vals = {}
+
+        imd_obj = self.openerp.pool.get('ir.model.data')
+        tmpl_obj = self.openerp.pool.get('poweremail.templates')
+        acc_id = False
+        if 'enforce_from_account' not in extra_vals:
+            acc_id = self._create_account(cursor, uid)
+
+        model_partner = imd_obj.get_object_reference(
+            cursor, uid, 'base', 'model_res_partner'
+        )[1] # Retunr ir.model id of res.partner
+
+        # Agafem un report de demo
+        report_id = imd_obj.get_object_reference(
+                cursor, uid, 'base', 'report_test'
+        )[1]
+
+        vals = {
+            'name': 'Test template',
+            'object_name': model_partner,
+            'enforce_from_account': acc_id,
+            'template_language': 'mako',
+            'def_to': 'Test to',
+            'inline': True,
+            'def_subject': 'Test subject',
+            'def_cc': 'Test cc',
+            'def_bcc': 'Test bcc',
+            'def_body_text': 'Test body text',
+            'def_priority': '2',
+            'report_template': report_id,
+            'report_template_object_reference': extra_vals['report_template_object_reference'] if 'report_template_object_reference' in extra_vals else '',
+        }
+
+        if extra_vals:
+            vals.update(extra_vals)
+
+        tmpl_id = tmpl_obj.create(cursor, uid, vals)
+        return tmpl_id
+
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report', return_value=("content_from_report_template_object_reference", "provapdf"))
+    def test_generate_attachments_with_report_template_object_reference(self, extra_vals=None):
+        """
+        Test the generation of attachments with a report template object reference
+
+        NOTE: In this case only will generate one attachment, because the conditions are too restrictive to return anything
+        """
+        with Transaction().start(self.database) as txn:
+            uid = txn.user
+            cursor = txn.cursor
+            mailbox_obj = self.openerp.pool.get('poweremail.mailbox')
+            pm_tmp_obj = self.openerp.pool.get('poweremail.templates')
+
+            acc1_id = self._create_account(cursor, uid, extra_vals={'name': 'acc1', 'email_id': 'test1@example.com'})
+            tmpl_id = self._create_template(cursor, uid, extra_vals={'enforce_from_account': acc1_id,
+                                                                        'name': 'Test template 1',
+                                                                        'report_template_object_reference': 'object.invoice_id',
+                                                                        })
+
+            mailbox_id = pm_tmp_obj.generate_mail(cursor, uid, tmpl_id, [1], context={'raise_exception': True})
+            mail = mailbox_obj.simple_browse(cursor, uid, mailbox_id)
+            for att in mail.pem_attachments_ids:
+                self.assertEqual(b64decode(att.datas), 'content_from_report_template_object_reference') # datas is get from the 1r tuple value from create_report method, that in this case is mocked to avoid the real report generation
+
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report', return_value=("content_from_report_template_object_reference", "provapdf"))
+    def test_generate_attachments_without_report_template_object_reference(self, mock_create_report , extra_vals=None):
+        """
+        Test the generation of attachments without a report template object reference
+        """
+        with Transaction().start(self.database) as txn:
+            uid = txn.user
+            cursor = txn.cursor
+            pm_tmp_obj = self.openerp.pool.get('poweremail.templates')
+            mailbox_obj = self.openerp.pool.get('poweremail.mailbox')
+
+            acc1_id = self._create_account(cursor, uid, extra_vals={'name': 'acc1', 'email_id': 'test1@example.com'})
+            tmpl_id = self._create_template(cursor, uid, extra_vals={'enforce_from_account': acc1_id,
+                                                                        'name': 'Test template 1',
+                                                                        'model': None,
+                                                                        'conditions': None}) # Without report_template_object_reference
+
+            with patch.object(pm_tmp_obj, '_generate_attach_reports') as mock_generate_attach_reports:
+                mock_generate_attach_reports.return_value = None
+                with patch.object(pm_tmp_obj._generate_attach_reports, 'get_value') as mock_get_value_from_generate_attach_reports: # Mock the get_value from the _generate_attach_reports method
+                    mailbox_id = pm_tmp_obj.generate_mail(cursor, uid, tmpl_id, [1], context={'raise_exception': True})
+                    mock_get_value_from_generate_attach_reports.assert_not_called()
+
+                    mail = mailbox_obj.simple_browse(cursor, uid, mailbox_id)
+                    for att in mail.pem_attachments_ids:
+                        self.assertEqual(b64decode(att.datas), 'content_from_report_template_object_reference')
+
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report', return_value=("content_from_report_template_object_reference", "provapdf"))
+    def test_generate_attachments_with_user(self, mock_create_report, extra_vals=None):
+        """
+        Test the generation of attachments with a user and invoice
+        """
+        with Transaction().start(self.database) as txn:
+            uid = txn.user
+            cursor = txn.cursor
+            mailbox_obj = self.openerp.pool.get('poweremail.mailbox')
+            pm_tmp_obj = self.openerp.pool.get('poweremail.templates')
+
+            acc1_id = self._create_account(cursor, uid, extra_vals={'name': 'acc1', 'email_id': 'test1@example.com'})
+            tmpl_id = self._create_template(cursor, uid, extra_vals={'enforce_from_account': acc1_id,
+                                                                     'name': 'Test template 1',
+                                                                     'report_template_object_reference': 'object.invoice_id',
+                                                                     })
+
+            mailbox_id = pm_tmp_obj.generate_mail(cursor, uid, tmpl_id, [1], context={'raise_exception': True})
+            mail = mailbox_obj.simple_browse(cursor, uid, mailbox_id)
+
+            for att in mail.pem_attachments_ids:
+                self.assertEqual(b64decode(att.datas), 'content_from_report_template_object_reference')
+
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report', return_value=("content_main", "pdf"))
+    def test_main_report_only(self, mock_create_report):
+        """Test that main report is generated correctly when no object reference."""
+        with Transaction().start(self.database) as txn:
+            cursor = txn.cursor
+            uid = txn.user
+            tmpl_id = self._create_template(cursor, uid)
+            tmpl_obj = self.openerp.pool.get('poweremail.templates')
+
+            res = tmpl_obj.get_dynamic_attachment(cursor, uid, tmpl_obj.simple_browse(cursor, uid, tmpl_id, context={}), [1], context={})
+            self.assertEqual(len(res), 1)
+            self.assertEqual(b64decode(res[0]['file']), b'content_main')
+            self.assertEqual(res[0]['extension'], 'pdf')
+
+
+    @patch('poweremail.poweremail_template.LOGGER')
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report',
+           return_value=("content_main", "pdf"))
+    def test_reference_expression_without_object(self, mock_create_report, mock_logger):
+        """Ensure expressions without 'object' are handled gracefully."""
+        with Transaction().start(self.database) as txn:
+            cursor = txn.cursor
+            uid = txn.user
+            tmpl_id = self._create_template(cursor, uid, {
+                'report_template_object_reference': 'invoice_id'
+            })
+            tmpl_obj = self.openerp.pool.get('poweremail.templates')
+            tmpl = tmpl_obj.simple_browse(cursor, uid, tmpl_id, context={})
+
+            res = tmpl_obj.get_dynamic_attachment(cursor, uid, tmpl, [1], context={})
+            self.assertEqual(len(res), 1)
+            mock_logger.notifyChannel.assert_any_call(
+                'Power Email', netsvc.LOG_ERROR,
+                ANY
+            )
+
+    @patch('poweremail.poweremail_template.poweremail_templates._get_records_from_report_template_object_reference',
+           return_value={'model': 'account.invoice', 'record_ids': []})
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report',
+           return_value=("content_main", "pdf"))
+    def test_reference_evaluates_to_empty(self, mock_create_report, mock_get_refs):
+        """Ensure when reference returns empty list, only main report is generated."""
+        with Transaction().start(self.database) as txn:
+            cursor = txn.cursor
+            uid = txn.user
+            tmpl_id = self._create_template(cursor, uid, {
+                'report_template_object_reference': 'object.invoice_ids'
+            })
+            tmpl_obj = self.openerp.pool.get('poweremail.templates')
+            tmpl = tmpl_obj.simple_browse(cursor, uid, tmpl_id, context={})
+
+            res = tmpl_obj.get_dynamic_attachment(cursor, uid, tmpl, [1], context={})
+            self.assertEqual(len(res), 1)
+            self.assertEqual(b64decode(res[0]['file']), b'content_main')
+
+    def test_get_records_from_reference_many2one(self):
+        """Test helper method evaluates a Many2one reference correctly."""
+        with Transaction().start(self.database) as txn:
+            cursor = txn.cursor
+            uid = txn.user
+            tmpl_id = self._create_template(cursor, uid, {
+                'report_template_object_reference': 'object.invoice_id'
+            })
+            tmpl_obj = self.openerp.pool.get('poweremail.templates')
+            tmpl = tmpl_obj.simple_browse(cursor, uid, tmpl_id, context={})
+
+            res = tmpl_obj._get_records_from_report_template_object_reference(cursor, uid, tmpl, [1])
+            self.assertIn('model', res)
+            self.assertIn('record_ids', res)
+            self.assertIsInstance(res['record_ids'], list)
+
+    @patch('poweremail.poweremail_template.poweremail_templates.create_report', return_value=("content_from_report_template_object_reference", "provapdf"))
+    def test_reference_uses_same_report_template(self, mock_create_report):
+        """Ensure referenced records still use the template's own report."""
+        with Transaction().start(self.database) as txn:
+            cursor = txn.cursor
+            uid = txn.user
+            tmpl_id = self._create_template(cursor, uid, {
+                'report_template_object_reference': 'object.invoice_id'
+            })
+            tmpl_obj = self.openerp.pool.get('poweremail.templates')
+            tmpl = tmpl_obj.simple_browse(cursor, uid, tmpl_id, context={})
+
+            tmpl_obj.get_dynamic_attachment(cursor, uid, tmpl, [1], context={})
+            mock_create_report.assert_called_once()
+            args, kwargs = mock_create_report.call_args
+            self.assertEqual(args[2].report_template.id, tmpl.report_template.id)