Add Email Templates editor to categories, and events

Author: vasantvohra

indico/migrations/versions/20251212_2142_86873b143da2_add_email_template_model.py

@@ -0,0 +1,42 @@
+"""Add email template model
+
+Revision ID: 86873b143da2
+Revises: 932389d22b1f
+Create Date: 2025-09-12 21:42:26.537009
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision = '86873b143da2'
+down_revision = '932389d22b1f'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table('email_templates',
+                    sa.Column('id', sa.Integer(), nullable=False),
+                    sa.Column('title', sa.String(), nullable=False),
+                    sa.Column('type', sa.String(), nullable=False),
+                    sa.Column('status', sa.String(), nullable=False),
+                    sa.Column('subject', sa.String(), nullable=False),
+                    sa.Column('body', sa.Text(), nullable=False),
+                    sa.Column('event_id', sa.Integer(), nullable=True, index=True),
+                    sa.Column('category_id', sa.Integer(), nullable=True, index=True),
+                    sa.Column('rules', postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+                    sa.Column('is_active', sa.Boolean(), nullable=False),
+                    sa.Column('is_system_template', sa.Boolean(), nullable=False),
+                    sa.CheckConstraint('(event_id IS NULL) != (category_id IS NULL)',
+                                       name='event_xor_category_id_null'),
+                    sa.ForeignKeyConstraint(['category_id'], ['categories.categories.id']),
+                    sa.ForeignKeyConstraint(['event_id'], ['events.events.id']),
+                    sa.PrimaryKeyConstraint('id'),
+                    schema='indico')
+
+
+def downgrade():
+    op.drop_table('email_templates', schema='indico')

indico/modules/categories/models/categories.py

@@ -281,6 +281,7 @@ def __table_args__(cls):
     # relationship backrefs:
     # - attachment_folders (AttachmentFolder.category)
     # - designer_templates (DesignerTemplate.category)
+    # - email_templates (EmailTemplate.category)
     # - event_move_requests (EventMoveRequest.category)
     # - events (Event.category)
     # - favorite_of (User.favorite_categories)

indico/modules/designer/controllers.py

@@ -197,9 +197,13 @@ class CloneTemplateMixin(TargetFromURLMixin):
     def _check_access(self):
         if not self.target.can_manage(session.user):
             raise Forbidden
+        elif isinstance(self.target, Event):
+            check_event_locked(self, self.target)
 
     def _process_args(self):
         self.template = DesignerTemplate.get_or_404(request.view_args['template_id'])
+        if self.target.is_deleted:
+            raise NotFound
 
     def clone_template(self, target=None):
         title = f'{self.template.title} (copy)'

indico/modules/email_templates/__init__.py

@@ -0,0 +1,29 @@
+# This file is part of Indico.
+# Copyright (C) 2002 - 2025 CERN
+#
+# Indico is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see the
+# LICENSE file for more details.
+
+from flask import session
+
+from indico.core import signals
+from indico.util.i18n import _
+from indico.web.flask.util import url_for
+from indico.web.menu import SideMenuItem
+
+
+@signals.menu.items.connect_via('event-management-sidemenu')
+def _event_sidemenu_items(sender, event, **kwargs):
+    if event.can_manage(session.user):
+        return SideMenuItem('email_templates', _('Email Templates'),
+                            url_for('email_templates.email_template_list', event),
+                            section='customization')
+
+
+@signals.menu.items.connect_via('category-management-sidemenu')
+def _category_sidemenu_items(sender, category, **kwargs):
+    if category.can_manage(session.user):
+        return SideMenuItem('email_templates', _('Email Templates'),
+                            url_for('email_templates.email_template_list', category),
+                            weight=25, icon='mail')

indico/modules/email_templates/blueprint.py

@@ -0,0 +1,46 @@
+# This file is part of Indico.
+# Copyright (C) 2002 - 2025 CERN
+#
+# Indico is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see the
+# LICENSE file for more details.
+
+from indico.modules.email_templates.controllers import (RHAddCategoryEmailTemplate, RHAddEventEmailTemplate,
+                                                        RHCloneCategoryEmailTemplate, RHCloneEventEmailTemplate,
+                                                        RHDeleteEmailTemplate, RHEditEmailTemplate,
+                                                        RHListCategoryEmailTemplates, RHListEventEmailTemplates)
+from indico.util.caching import memoize
+from indico.web.flask.util import make_view_func
+from indico.web.flask.wrappers import IndicoBlueprint
+
+
+_bp = IndicoBlueprint('email_templates', __name__, template_folder='templates',
+                      virtual_template_folder='email_templates')
+
+
+@memoize
+def _dispatch(event_rh, category_rh):
+    event_view = make_view_func(event_rh)
+    categ_view = make_view_func(category_rh)
+
+    def view_func(**kwargs):
+        return categ_view(**kwargs) if kwargs['object_type'] == 'category' else event_view(**kwargs)
+
+    return view_func
+
+
+for object_type in ('event', 'category'):
+    prefix = f'/{object_type}/<int:{object_type}_id>/manage/email_templates'
+    _bp.add_url_rule(f'{prefix}/', 'email_template_list',
+                     _dispatch(RHListEventEmailTemplates, RHListCategoryEmailTemplates),
+                     defaults={'object_type': object_type})
+    _bp.add_url_rule(f'{prefix}/add', 'add_email_template',
+                     _dispatch(RHAddEventEmailTemplate, RHAddCategoryEmailTemplate),
+                     defaults={'object_type': object_type}, methods=('GET', 'POST'))
+    _bp.add_url_rule(f'{prefix}/<int:email_template_id>/', 'edit_email_template',
+                     RHEditEmailTemplate, defaults={'object_type': object_type}, methods=('GET', 'POST'))
+    _bp.add_url_rule(f'{prefix}/<int:email_template_id>', 'delete_email_template',
+                     RHDeleteEmailTemplate, defaults={'object_type': object_type}, methods=('DELETE',))
+    _bp.add_url_rule(f'{prefix}/<int:email_template_id>/clone', 'clone_email_template',
+                     _dispatch(RHCloneEventEmailTemplate, RHCloneCategoryEmailTemplate),
+                     defaults={'object_type': object_type}, methods=('GET', 'POST'))

indico/modules/email_templates/controllers.py

@@ -0,0 +1,227 @@
+# This file is part of Indico.
+# Copyright (C) 2002 - 2025 CERN
+#
+# Indico is free software; you can redistribute it and/or
+# modify it under the terms of the MIT License; see the
+# LICENSE file for more details.
+
+from copy import deepcopy
+
+from flask import flash, request, session
+from markupsafe import Markup
+from werkzeug.exceptions import Forbidden, NotFound
+
+from indico.core.db import db
+from indico.modules.categories import Category
+from indico.modules.categories.controllers.base import RHManageCategoryBase
+from indico.modules.designer.forms import CloneTemplateForm
+from indico.modules.email_templates.forms import CreateEmailTemplatesForm, EditEmailTemplatesForm
+from indico.modules.email_templates.models.email_templates import EmailTemplate
+from indico.modules.email_templates.util import get_inherited_templates
+from indico.modules.email_templates.views import WPCategoryManagementEmailTemplate, WPEventManagementEmailTemplate
+from indico.modules.events import Event
+from indico.modules.events.management.controllers import RHManageEventBase
+from indico.modules.events.util import check_event_locked
+from indico.util.i18n import _
+from indico.web.flask.templating import get_template_module
+from indico.web.flask.util import url_for
+from indico.web.rh import RHProtected
+from indico.web.util import jsonify_data, jsonify_form
+
+
+def _render_template_list(target, event=None):
+    tpl = get_template_module('email_templates/_list.html')
+    return tpl.render_email_template_list(target.email_templates, target, event=event,
+                                          inherited_templates=get_inherited_templates(target))
+
+
+class EmailTemplateMixin:
+    """Basic class for all template designer mixins.
+
+    It resolves the target object type from the blueprint URL.
+    """
+
+    @property
+    def object_type(self):
+        """Figure out whether we're targeting an event or category, based on URL info."""
+        return request.view_args['object_type']
+
+    @property
+    def event_or_none(self):
+        return self.target if self.object_type == 'event' else None
+
+    def _render_template(self, tpl_name, **kwargs):
+        view_class = (WPEventManagementEmailTemplate
+                      if self.object_type == 'event' else WPCategoryManagementEmailTemplate)
+        return view_class.render_template(tpl_name, self.target, 'email_templates',
+                                          target=self.target, **kwargs)
+
+
+class SpecificEmailTemplateMixin(EmailTemplateMixin):
+    """Mixin that accepts a target template passed in the URL.
+
+    The target category/event will be the owner of that template.
+    """
+
+    normalize_url_spec = {
+        'locators': {
+            lambda self: self.email_tpl
+        }
+    }
+
+    @property
+    def target(self):
+        return self.email_tpl.owner
+
+    def _check_access(self):
+        self._require_user()
+        if not self.target.can_manage(session.user):
+            raise Forbidden
+        elif isinstance(self.target, Event):
+            check_event_locked(self, self.target)
+
+    def _process_args(self):
+        self.email_tpl = EmailTemplate.get_or_404(request.view_args['email_template_id'])
+        if self.target.is_deleted:
+            raise NotFound
+
+
+class TargetFromURLMixin(EmailTemplateMixin):
+    """Mixin that takes the target event/category from the URL that is passed."""
+
+    @property
+    def target_dict(self):
+        return {'event': self.event} if self.object_type == 'event' else {'category': self.category}
+
+    @property
+    def target(self):
+        return self.event if self.object_type == 'event' else self.category
+
+
+class EmailTemplateListMixin(TargetFromURLMixin):
+    def _process(self):
+        inherited_templates = get_inherited_templates(self.target)
+        return self._render_template('list.html', inherited_templates=inherited_templates)
+
+
+class AddEmailTemplateMixin(TargetFromURLMixin):
+    def _check_access(self):
+        if not self.target.can_manage(session.user):
+            raise Forbidden
+
+    def _process(self):
+        form = CreateEmailTemplatesForm(target=self.target)
+        if form.validate_on_submit():
+            new_email_tpl = EmailTemplate(**self.target_dict)
+            new_email_tpl.rules = {'status': form.status.data}
+            form.populate_obj(new_email_tpl)
+            flash(_("Added a new email template '{}'").format(new_email_tpl.title), 'success')
+            return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
+        return jsonify_form(form, disabled_until_change=False)
+
+
+class RHListEventEmailTemplates(EmailTemplateListMixin, RHManageEventBase):
+    pass
+
+
+class RHListCategoryEmailTemplates(EmailTemplateListMixin, RHManageCategoryBase):
+    pass
+
+
+class RHAddEventEmailTemplate(AddEmailTemplateMixin, RHManageEventBase):
+    pass
+
+
+class RHAddCategoryEmailTemplate(AddEmailTemplateMixin, RHManageCategoryBase):
+    pass
+
+
+class RHModifyEmailTemplateBase(SpecificEmailTemplateMixin, RHProtected):
+    def _check_access(self):
+        RHProtected._check_access(self)
+        SpecificEmailTemplateMixin._check_access(self)
+
+
+class RHEditEmailTemplate(RHModifyEmailTemplateBase):
+    def _process(self):
+        form = EditEmailTemplatesForm(target=self.target, obj=self.email_tpl)
+        if form.validate_on_submit():
+            self.email_tpl.rules = {'status': form.status.data}
+            form.populate_obj(self.email_tpl)
+            flash(_("Edited email template '{}'").format(self.email_tpl.title), 'success')
+            return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
+        return jsonify_form(form, disabled_until_change=False)
+
+
+class RHDeleteEmailTemplate(RHModifyEmailTemplateBase):
+    def _process(self):
+        db.session.delete(self.email_tpl)
+        db.session.flush()
+        flash(_('The email template has been deleted'), 'success')
+        return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
+
+
+class CloneTemplateMixin(TargetFromURLMixin):
+    cloneable_elsewhere = False
+
+    def _check_access(self):
+        if not self.target.can_manage(session.user):
+            raise Forbidden
+        elif isinstance(self.target, Event):
+            check_event_locked(self, self.target)
+
+    def _process_args(self):
+        self.email_tpl = EmailTemplate.get_or_404(request.view_args['email_template_id'])
+        if self.target.is_deleted:
+            raise NotFound
+
+    def is_active(self):
+        email_templates = [email_tpl for email_tpl in self.target.email_templates
+                           if email_tpl.type == self.email_tpl.type]
+        if status := self.email_tpl.rules.get('status'):
+            email_templates = [email_tpl for email_tpl in email_templates
+                               if email_tpl.rules and email_tpl.rules.get('status') == status]
+        if email_templates:
+            return not any(tpl.is_active for tpl in email_templates)
+        return self.email_tpl.is_active
+
+    def clone_template(self, target=None):
+        title = f'{self.email_tpl.title} (copy)'
+        target_dict = target or self.target_dict
+        new_email_tpl = EmailTemplate(title=title, type=self.email_tpl.type, **target_dict)
+        new_email_tpl.subject = self.email_tpl.subject
+        new_email_tpl.body = self.email_tpl.body
+        new_email_tpl.is_system_template = self.email_tpl.is_system_template
+        new_email_tpl.is_active = self.is_active()
+        new_email_tpl.rules = deepcopy(self.email_tpl.rules)
+        message = _("Created copy of template '{}'").format(self.email_tpl.title)
+        if target_dict != self.target_dict:
+            message += Markup(' (<a href="{}">{}</a>)').format(url_for('email_templates.email_template_list',
+                                                                       target_dict['category']), _('Go to category'))
+        flash(message, 'success')
+        return jsonify_data(html=_render_template_list(self.target, event=self.event_or_none))
+
+    def _process(self):
+        if self.cloneable_elsewhere:
+            category = (self.target if isinstance(self.target, Category) and
+                                       self.target.can_manage(session.user) else None)
+            form = CloneTemplateForm(category=category)
+            if form.validate_on_submit():
+                return self.clone_template(target=form.data)
+            return jsonify_form(form, submit=_('Clone'), disabled_until_change=False)
+        if request.method == 'POST':
+            return self.clone_template()
+
+
+class RHCloneEventEmailTemplate(CloneTemplateMixin, RHManageEventBase):
+    def _process_args(self):
+        RHManageEventBase._process_args(self)
+        CloneTemplateMixin._process_args(self)
+
+
+class RHCloneCategoryEmailTemplate(CloneTemplateMixin, RHManageCategoryBase):
+    cloneable_elsewhere = True
+
+    def _process_args(self):
+        RHManageCategoryBase._process_args(self)
+        CloneTemplateMixin._process_args(self)