refactor: Rewrite some parts of the feedback feature

- Add SMTP mock for local development (in cluster and in dev-mode)
- Change to newer Python syntax, e.g. `t.Optional` -> `| None`
- Outsource email sending to it's own module, it will be relevant for other parts as well
- Import modules and not classes or functions directly.
- Remove the anonoymity policy and feedback percentage for simplicity and determinism.
- Auto-disable feedback if SMTP is not set, decline enabling with disabled SMTP
- Decline enabling feedback with empty list of recipients
- Reduce the verbosity of the AnonymizedSession. It did include the whole tool config before.
- Rename receivers to recipients.
- Add more Stories and pytests.
- Add storage limits to all containers (suggested by SonarCloud)
- Change some error codes from Server errors to Client errors
- Disable footer feedback button if not logged in.

Makefile

@@ -96,6 +96,7 @@ helm-deploy:
 		--set docker.registry.sessions=$(CAPELLACOLLAB_SESSIONS_REGISTRY) \
 		--set docker.tag=$(DOCKER_TAG) \
 		--set mocks.oauth=True \
+		--set mocks.smtp=True \
 		--set backend.authentication.claimMapping.username=sub \
 		--set backend.authentication.endpoints.authorization=https://localhost/default/authorize \
 		--set development=$(DEVELOPMENT_MODE) \
@@ -191,7 +192,7 @@ reach-registry:
 	fi
 
 dev:
-	$(MAKE) -j5 dev-frontend dev-backend dev-oauth-mock dev-docs dev-storybook
+	$(MAKE) -j6 dev-frontend dev-backend dev-oauth-mock dev-smtp-mock dev-docs dev-storybook
 
 dev-frontend:
 	$(MAKE) -C frontend dev
@@ -202,6 +203,9 @@ dev-backend:
 dev-oauth-mock:
 	$(MAKE) -C mocks/oauth start
 
+dev-smtp-mock:
+	$(MAKE) -C mocks/smtp start
+
 dev-docs:
 	$(MAKE) -C docs serve
 

backend/capellacollab/config/models.py

@@ -330,25 +330,30 @@ class PrometheusConfig(BaseConfig):
     )
 
 
-class SmtpConfig(BaseConfig):
+class SMTPConfig(BaseConfig):
     enabled: bool = pydantic.Field(
-        default=False,
+        default=True,
         description="Whether to enable SMTP. Necessary for feedback.",
         examples=[True, False],
     )
     host: str = pydantic.Field(
         description="The SMTP server host.",
+        default="localhost:587",
         examples=["smtp.example.com:587"],
         pattern=r"^(.*):(\d+)$",
     )
     user: str = pydantic.Field(
-        description="The SMTP server user.", examples=["username"]
+        default="username",
+        description="The SMTP server user.",
+        examples=["username"],
     )
     password: str = pydantic.Field(
+        default="password",
         description="The SMTP server password.",
         examples=["password"],
     )
     sender: str = pydantic.Field(
+        default="[email protected]",
         description="The sender email address.",
         examples=["[email protected]"],
     )
@@ -366,4 +371,4 @@ class AppConfig(BaseConfig):
     logging: LoggingConfig = LoggingConfig()
     requests: RequestsConfig = RequestsConfig()
     pipelines: PipelineConfig = PipelineConfig()
-    smtp: t.Optional[SmtpConfig] = None
+    smtp: SMTPConfig | None = SMTPConfig()

backend/capellacollab/core/__init__.py

@@ -3,7 +3,7 @@
 
 import os
 
-DEVELOPMENT_MODE = os.getenv("DEVELOPMENT_MODE", "").lower() in (
+DEVELOPMENT_MODE: bool = os.getenv("DEVELOPMENT_MODE", "").lower() in (
     "1",
     "true",
     "t",

backend/capellacollab/core/email/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright DB InfraGO AG and contributors
+# SPDX-License-Identifier: Apache-2.0

backend/capellacollab/core/email/exceptions.py

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright DB InfraGO AG and contributors
+# SPDX-License-Identifier: Apache-2.0
+
+from fastapi import status
+
+from capellacollab.core import exceptions as core_exceptions
+
+
+class SMTPNotConfiguredError(core_exceptions.BaseError):
+    def __init__(self):
+        super().__init__(
+            status_code=status.HTTP_403_FORBIDDEN,
+            title="SMTP is not configured",
+            reason="SMTP must be configured in the application configuration before sending emails and activating related features.",
+            err_code="SMTP_NOT_CONFIGURED",
+        )

backend/capellacollab/core/email/models.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright DB InfraGO AG and contributors
+# SPDX-License-Identifier: Apache-2.0
+
+from capellacollab.core import pydantic as core_pydantic
+
+
+class EMailContent(core_pydantic.BaseModelStrict):
+    subject: str
+    message: str

backend/capellacollab/core/email/send.py

@@ -0,0 +1,51 @@
+# SPDX-FileCopyrightText: Copyright DB InfraGO AG and contributors
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import smtplib
+from email.mime import multipart, text
+
+import pydantic
+
+from capellacollab.config import config
+
+from . import exceptions, models
+
+
+def send_email(
+    recipients: list[pydantic.EmailStr],
+    email: models.EMailContent,
+    logger: logging.LoggerAdapter,
+):
+    if not (config.smtp and config.smtp.enabled):
+        raise exceptions.SMTPNotConfiguredError()
+
+    try:
+        with smtplib.SMTP(
+            config.smtp.host.split(":")[0], int(config.smtp.host.split(":")[1])
+        ) as smtp:
+            smtp.ehlo()
+            smtp.starttls()
+            smtp.ehlo()
+            smtp.login(config.smtp.user, config.smtp.password)
+
+            logger.info(
+                "Sending emails to recipients %s", ", ".join(recipients)
+            )
+
+            for recipient in recipients:
+                msg = multipart.MIMEMultipart()
+                msg["From"] = config.smtp.sender
+                msg["To"] = recipient
+                msg["Subject"] = email.subject
+                msg.attach(text.MIMEText(email.message, "plain"))
+
+                logger.info(
+                    "Sending email to '%s' with subject '%s'",
+                    recipient,
+                    email.subject,
+                )
+
+                smtp.sendmail(config.smtp.sender, recipient, msg.as_string())
+    except Exception:
+        logger.exception("Error while sending email(s).")

backend/capellacollab/feedback/exceptions.py

@@ -6,21 +6,21 @@
 from capellacollab.core import exceptions as core_exceptions
 
 
-class SmtpNotSetupError(core_exceptions.BaseError):
+class FeedbackNotEnabledError(core_exceptions.BaseError):
     def __init__(self):
         super().__init__(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            title="SMTP is not set up",
-            reason="SMTP must be set up to perform this action",
-            err_code="SMTP_NOT_SETUP",
+            status_code=status.HTTP_403_FORBIDDEN,
+            title="Feedback is not enabled",
+            reason="Feedback must be set up to perform this action",
+            err_code="FEEDBACK_NOT_ENABLED",
         )
 
 
-class FeedbackNotEnabledError(core_exceptions.BaseError):
+class NoFeedbackRecipientsError(core_exceptions.BaseError):
     def __init__(self):
         super().__init__(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            title="Feedback is not set enabled",
-            reason="Feedback must be set up to perform this action",
-            err_code="FEEDBACK_NOT_SETUP",
+            status_code=status.HTTP_400_BAD_REQUEST,
+            title="The list of recipients is empty",
+            reason="Feedback can only be activated when there are recipients.",
+            err_code="FEEDBACK_MISSING_RECIPIENTS",
         )

backend/capellacollab/feedback/models.py

@@ -3,13 +3,12 @@
 
 import datetime
 import enum
-import typing as t
 
 import pydantic
 
 from capellacollab.core import models as core_models
 from capellacollab.core import pydantic as core_pydantic
-from capellacollab.sessions.models import SessionType
+from capellacollab.sessions import models as sessions_models
 from capellacollab.tools import models as tools_models
 
 
@@ -21,31 +20,32 @@ class FeedbackRating(str, enum.Enum):
 
 class AnonymizedSession(core_pydantic.BaseModel):
     id: str
-    type: SessionType
+    type: sessions_models.SessionType
     created_at: datetime.datetime
 
-    version: tools_models.ToolVersionWithTool
+    version: tools_models.MinimalToolVersionWithTool
 
     state: str = pydantic.Field(default="UNKNOWN")
     warnings: list[core_models.Message] = pydantic.Field(default=[])
 
-    connection_method_id: str
-    connection_method: tools_models.ToolSessionConnectionMethod | None = None
+    connection_method: (
+        tools_models.MinimalToolSessionConnectionMethod | None
+    ) = None
 
 
 class Feedback(core_pydantic.BaseModel):
     rating: FeedbackRating = pydantic.Field(
         description="The rating of the feedback"
     )
-    feedback_text: t.Optional[str] = pydantic.Field(
-        description="The feedback text"
+    feedback_text: str | None = pydantic.Field(
+        description="The feedback text", max_length=255
     )
     share_contact: bool = pydantic.Field(
         description="Whether the user wants to share their contact information"
     )
     sessions: list[AnonymizedSession] = pydantic.Field(
         description="The sessions the feedback is for"
     )
-    trigger: str = pydantic.Field(
-        description="What triggered the feedback form"
+    trigger: str | None = pydantic.Field(
+        description="What triggered the feedback form", max_length=255
     )

backend/capellacollab/feedback/routes.py

@@ -2,46 +2,62 @@
 # SPDX-License-Identifier: Apache-2.0
 
 
+import logging
 import typing as t
 
 import fastapi
 from sqlalchemy import orm
 
+from capellacollab.config import config
 from capellacollab.core import database
-from capellacollab.feedback.models import Feedback
-from capellacollab.feedback.util import is_feedback_allowed, send_email
+from capellacollab.core import logging as log
+from capellacollab.core.authentication import injectables as auth_injectables
 from capellacollab.settings.configuration import core as config_core
-from capellacollab.settings.configuration import (
-    models as settings_config_models,
-)
-from capellacollab.settings.configuration.models import FeedbackConfiguration
+from capellacollab.settings.configuration import models as config_models
 from capellacollab.users import injectables as user_injectables
 from capellacollab.users import models as users_models
 
+from . import models, util
+
 router = fastapi.APIRouter()
 
 
 @router.get(
-    "/feedback",
-    response_model=FeedbackConfiguration,
+    "/configurations/feedback",
+    response_model=config_models.FeedbackConfiguration,
 )
-def get_feedback(db: orm.Session = fastapi.Depends(database.get_db)):
-    cfg = config_core.get_config(db, "global")
-    assert isinstance(cfg, settings_config_models.GlobalConfiguration)
-
-    return FeedbackConfiguration.model_validate(cfg.feedback.model_dump())
+def get_feedback_configuration(
+    db: orm.Session = fastapi.Depends(database.get_db),
+):
+    feedback = config_core.get_global_configuration(db).feedback
+    if not (config.smtp and config.smtp.enabled):
+        util.disable_feedback(feedback)
+    return feedback
 
 
-@router.post("/feedback")
+@router.post(
+    "/feedback",
+    status_code=204,
+    dependencies=[
+        fastapi.Depends(
+            auth_injectables.RoleVerification(
+                required_role=users_models.Role.USER
+            )
+        )
+    ],
+)
 def submit_feedback(
-    feedback: Feedback,
+    feedback: models.Feedback,
     background_tasks: fastapi.BackgroundTasks,
     user_agent: t.Annotated[str | None, fastapi.Header()] = None,
     user: users_models.DatabaseUser = fastapi.Depends(
         user_injectables.get_own_user
     ),
     db: orm.Session = fastapi.Depends(database.get_db),
+    logger: logging.LoggerAdapter = fastapi.Depends(log.get_request_logger),
 ):
-    is_feedback_allowed(db)
-    background_tasks.add_task(send_email, feedback, user, user_agent, db)
-    return {"status": "sending"}
+    util.check_if_feedback_is_allowed(db)
+
+    background_tasks.add_task(
+        util.send_feedback_email, db, feedback, user, user_agent, logger
+    )