Support Templates in SMTP Extension

[derks]

Moving this bit from PR #742:

def send_by_template(self, template, data={}, **kw):
        # test if template exists by loading it
        def _template_exists(template):
            # check if stored in cache already
            if template in self._template_exists_cache:
                return self._template_exists_cache[template]
            # do first time check from file or module
            result = False
            try:
                # successfully load when available
                self.app.template.load(template)
                result = True
            except:
                pass
            # store flag in cache list to prevent often load access
            self._template_exists_cache[template] = result
            # return state
            return result

        # prepare email params
        params = dict(**kw)
        # check render subject
        if 'subject' not in params:
            if _template_exists(f'{template}.title.jinja2'):
                params['subject'] = self.app.render(data,
                                                    f'{template}.title.jinja2',
                                                    out=None)
        # build body
        body = list()
        if _template_exists(f'{template}.plain.jinja2'):
            body.append(self.app.render(dict(**data, mail_params=params),
                                       f'{template}.plain.jinja2',
                                       out=None))
        if _template_exists(f'{template}.html.jinja2'):
            # before adding a html part make sure that plain part exists
            if len(body) == 0:
                body.append('Content is delivered as HTML only.')
            body.append(self.app.render(dict(**data, mail_params=params),
                                        f'{template}.html.jinja2',
                                        out=None))
        # send the message
        self.send(body=body, **params)

Would be convenient to be able to link templates with sending mail, however it needs to be TemplateHandler agnostic.

[TomFreudenberg]

Hey @derks

I have already made some progress here and using this with latest changes to smtp on 3.0.14.

So this should be the new starting point for that feature:

    def send_by_template(self, template, data={}, **kw):
        """
        Send an email using a template for content generation.

        This method provides template-based email sending by rendering email
        content from Jinja2 templates. It looks for template files with specific
        naming conventions to generate the subject, plain text, and HTML parts
        of the email.

        ### Args:

        - **template** (str): Base template path/name without extension
        - **data** (dict): Data context for template rendering
        - **kw**: Additional email parameters passed to send()

        ### Returns:

        - **bool**: Result from the send() method

        ### Notes:

        : The method looks for the following template files:

            1. `{template}.title.jinja2`: For subject line (optional)
            1. `{template}.plain.jinja2`: For plain text body (optional)
            1. `{template}.html.jinja2`: For HTML body (optional)

        : At least one of plain text or HTML templates should exist.
            The mail_params context variable is provided to templates
            containing the email parameters.

        ### Example:

        ```python
        # Assuming templates/emails/welcome.plain.jinja2,
        # templates/emails/welcome.html.jinja2, and
        # templates/emails/welcome.title.jinja2 exist:

        app.mail.send_by_template(
            'emails/welcome',
            {'username': 'john', 'account_info': account_data},
            to=['john@example.com'],
            files=['/path/to/terms.pdf']
        )
        ```

        """

        # Helper function to check if a template exists and cache the result
        def _template_exists(template):
            """
            Check if a template exists and cache the result.

            Attempts to load the template and caches the result to avoid
            repeated file system or module lookups for the same template.

            ### Args:

            - **template** (str): Template path to check

            ### Returns:

            - **bool**: True if template exists and can be loaded

            """
            # Check if stored in cache already
            if template in self._template_exists_cache:
                return self._template_exists_cache[template]

            # Do first time check from file or module
            result = False
            try:
                # Successfully load when available
                self.app.template.load(template)
                result = True
            except Exception:
                pass

            # Store flag in cache to prevent repeated lookups
            self._template_exists_cache[template] = result
            return result

        # Prepare email params
        params = dict(**kw)

        # Check if we need to render the subject from template
        if 'subject' not in params:
            if _template_exists(f'{template}.title.jinja2'):
                params['subject'] = self.app.render(data, f'{template}.title.jinja2', out=None)

        # Build the email body from templates
        body = dict()

        # Plain text template
        if _template_exists(f'{template}.plain.jinja2'):
            body['text'] = self.app.render(dict(**data, mail_params=params), f'{template}.plain.jinja2', out=None)
        if _template_exists(f'{template}.html.jinja2'):
            body['html'] = self.app.render(dict(**data, mail_params=params), f'{template}.html.jinja2', out=None)
        # send the message
        self.send(body=body, **params)

Maybe we should add some configable instead of hard coded .jinja2 extension?