firefighter-incident 0.0.22__tar.gz → 0.0.23__tar.gz

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.22
+Version: 0.0.23
 Summary: Incident Management tool made for Slack using Django
 Project-URL: Repository, https://github.com/ManoManoTech/firefighter-incident
 Project-URL: Documentation, https://manomanotech.github.io/firefighter-incident/latest/

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.22'
-__version_tuple__ = version_tuple = (0, 0, 22)
+__version__ = version = '0.0.23'
+__version_tuple__ = version_tuple = (0, 0, 23)
 
 __commit_id__ = commit_id = None

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/api/serializers.py

@@ -219,6 +219,8 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
     created_by = UserSerializer(read_only=True)
     slack_channel_name = serializers.SerializerMethodField()
     postmortem_url = serializers.SerializerMethodField()
+    jira_ticket_key = serializers.SerializerMethodField()
+    jira_ticket_url = serializers.SerializerMethodField()
 
     created_by_email = CreatableSlugRelatedField[User](
         source="created_by",
@@ -260,6 +262,20 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
             return obj.postmortem_for.page_url
         return None
 
+    @staticmethod
+    def get_jira_ticket_key(obj: Incident) -> str | None:
+        """Return the Jira ticket key if it exists."""
+        if hasattr(obj, "jira_ticket") and obj.jira_ticket:
+            return obj.jira_ticket.key
+        return None
+
+    @staticmethod
+    def get_jira_ticket_url(obj: Incident) -> str | None:
+        """Return the Jira ticket URL if it exists."""
+        if hasattr(obj, "jira_ticket") and obj.jira_ticket:
+            return obj.jira_ticket.url
+        return None
+
     def create(self, validated_data: dict[str, Any]) -> Incident:
         return Incident.objects.declare(**validated_data)
 
@@ -288,6 +304,8 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
             "slack_channel_name",
             "status_page_url",
             "postmortem_url",
+            "jira_ticket_key",
+            "jira_ticket_url",
             "status",
             "environment_id",
             "incident_category_id",

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/api/views/incidents.py

@@ -78,6 +78,7 @@ class IncidentViewSet(
             "environment",
             "conversation",
             "created_by",
+            "jira_ticket",
         )
         .prefetch_related(
             Prefetch(
@@ -118,6 +119,8 @@ class IncidentViewSet(
         "created_at",
         "slack_channel_name",
         "status_page_url",
+        "jira_ticket_key",
+        "jira_ticket_url",
         "metrics.*.duration_seconds",
         "costs.*.amount",
         "roles.*.email",

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/confluence/models.py

@@ -19,16 +19,78 @@ from firefighter.incidents.signals import postmortem_created
 
 if TYPE_CHECKING:
     from django.db.models import QuerySet
+
+    from firefighter.jira_app.models import JiraPostMortem
+    from firefighter.jira_app.service_postmortem import JiraPostMortemService
+
 logger = logging.getLogger(__name__)
 
 
+def _get_jira_postmortem_service() -> JiraPostMortemService:
+    """Lazy import to avoid circular dependency with jira_app."""
+    from firefighter.jira_app.service_postmortem import jira_postmortem_service
+
+    return jira_postmortem_service
+
+
 class PostMortemManager(models.Manager["PostMortem"]):
     @staticmethod
-    def create_postmortem_for_incident(incident: Incident) -> PostMortem:
-        if hasattr(incident, "postmortem_for"):
-            raise ValueError("Incident already has a post-mortem page")
+    def create_postmortem_for_incident(
+        incident: Incident,
+    ) -> tuple[PostMortem | None, JiraPostMortem | None]:
+        """Create post-mortem(s) for incident based on feature flags.
 
-        logger.info("Creating PostMortem for %s", incident)
+        Returns:
+            Tuple of (confluence_postmortem, jira_postmortem)
+            Either or both can be None depending on feature flags
+
+        Raises:
+            ValueError: If both backends are disabled or post-mortem already exists
+        """
+        confluence_pm = None
+        jira_pm = None
+
+        enable_confluence = getattr(settings, "ENABLE_CONFLUENCE", False)
+        enable_jira_postmortem = getattr(settings, "ENABLE_JIRA_POSTMORTEM", False)
+
+        # Check Confluence post-mortem
+        if enable_confluence:
+            if hasattr(incident, "postmortem_for"):
+                logger.warning(
+                    f"Incident #{incident.id} already has a Confluence post-mortem"
+                )
+            else:
+                confluence_pm = PostMortemManager._create_confluence_postmortem(
+                    incident
+                )
+
+        # Check Jira post-mortem
+        if enable_jira_postmortem:
+            if hasattr(incident, "jira_postmortem_for"):
+                logger.warning(
+                    f"Incident #{incident.id} already has a Jira post-mortem"
+                )
+            else:
+                jira_pm = _get_jira_postmortem_service().create_postmortem_for_incident(
+                    incident
+                )
+
+        # Validate at least one was created
+        if confluence_pm is None and jira_pm is None:
+            if not enable_confluence and not enable_jira_postmortem:
+                raise ValueError("Both Confluence and Jira post-mortems are disabled")
+            raise ValueError("Post-mortem already exists for this incident")
+
+        # Send signal if at least one post-mortem was created
+        if confluence_pm or jira_pm:
+            postmortem_created.send_robust(sender=__name__, incident=incident)
+
+        return confluence_pm, jira_pm
+
+    @staticmethod
+    def _create_confluence_postmortem(incident: Incident) -> PostMortem:
+        """Create Confluence post-mortem (existing logic)."""
+        logger.info("Creating Confluence PostMortem for %s", incident)
 
         topic_prefix = (
             ""
@@ -58,8 +120,6 @@ class PostMortemManager(models.Manager["PostMortem"]):
         )
         pm_page.save()
 
-        postmortem_created.send_robust(sender=__name__, incident=incident)
-
         previous_postmortem = (
             PostMortem.objects.exclude(id=pm_page.id)
             .exclude(incident__isnull=True)

firefighter_incident-0.0.23/firefighter/confluence/signals/incident_updated.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Never
+
+from django.apps import apps
+from django.dispatch.dispatcher import receiver
+
+from firefighter.incidents.signals import incident_updated
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models.incident import Incident
+    from firefighter.incidents.models.incident_update import IncidentUpdate
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(signal=incident_updated)
+def incident_updated_handler(
+    sender: Any,
+    incident: Incident,
+    incident_update: IncidentUpdate,
+    updated_fields: list[str],
+    **kwargs: Never,
+) -> None:
+    """Handle Confluence-specific incident updates.
+
+    Note: Post-mortem creation logic has been moved to jira_app.signals.postmortem_created
+    to handle both Confluence and Jira post-mortems independently of Confluence being enabled.
+    """
+    if not apps.is_installed("firefighter.slack"):
+        logger.error("Slack app is not installed. Skipping.")
+        return
+
+    # This handler is now empty but kept for future Confluence-specific logic
+    # Post-mortem creation is handled by jira_app.signals.postmortem_created

firefighter_incident-0.0.23/firefighter/firefighter/settings/components/jira_app.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from firefighter.firefighter.settings.components.common import INSTALLED_APPS
+from firefighter.firefighter.settings.settings_utils import config
+
+ENABLE_JIRA: bool = config("ENABLE_JIRA", cast=bool, default=False)
+"Enable the Jira app."
+
+if ENABLE_JIRA:
+    INSTALLED_APPS += ("firefighter.jira_app",)
+
+    RAID_JIRA_API_USER: str = config("RAID_JIRA_API_USER")
+    """The Jira API user to use."""
+    RAID_JIRA_API_PASSWORD: str = config("RAID_JIRA_API_PASSWORD")
+    """The Jira API password to use."""
+    RAID_JIRA_API_URL: str = config("RAID_JIRA_API_URL")
+    """The Jira API URL to use. If no protocol is defined, https will be used."""
+
+    if not RAID_JIRA_API_URL.startswith("http"):
+        RAID_JIRA_API_URL = f"https://{RAID_JIRA_API_URL}"
+    RAID_JIRA_API_URL = RAID_JIRA_API_URL.rstrip("/")
+
+    # Jira Post-mortem Configuration
+    ENABLE_JIRA_POSTMORTEM: bool = config(
+        "ENABLE_JIRA_POSTMORTEM", cast=bool, default=False
+    )
+    "Enable Jira post-mortem creation (in addition to or instead of Confluence)."
+
+    if ENABLE_JIRA_POSTMORTEM:
+        JIRA_POSTMORTEM_PROJECT_KEY: str = config(
+            "JIRA_POSTMORTEM_PROJECT_KEY", default="INCIDENT"
+        )
+        "Jira project key for post-mortems."
+
+        JIRA_POSTMORTEM_ISSUE_TYPE: str = config(
+            "JIRA_POSTMORTEM_ISSUE_TYPE", default="Post-mortem"
+        )
+        "Jira issue type for post-mortems."
+
+        # Jira Custom Field IDs
+        JIRA_POSTMORTEM_FIELDS: dict[str, str] = {
+            "incident_summary": config(
+                "JIRA_FIELD_INCIDENT_SUMMARY", default="customfield_12699"
+            ),
+            "timeline": config("JIRA_FIELD_TIMELINE", default="customfield_12700"),
+            "root_causes": config("JIRA_FIELD_ROOT_CAUSES", default="customfield_12701"),
+            "impact": config("JIRA_FIELD_IMPACT", default="customfield_12702"),
+            "mitigation_actions": config(
+                "JIRA_FIELD_MITIGATION_ACTIONS", default="customfield_12703"
+            ),
+            "incident_category": config(
+                "JIRA_FIELD_INCIDENT_CATEGORY", default="customfield_12369"
+            ),
+        }

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/incidents/admin.py

@@ -6,6 +6,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from django import apps
+from django.conf import settings
 from django.contrib import admin
 from django.contrib.admin import AdminSite, helpers
 from django.contrib.admin.decorators import action
@@ -514,6 +515,8 @@ class IncidentAdmin(admin.ModelAdmin[Incident]):
         ]
         if apps.apps.is_installed("firefighter.confluence"):
             select_related.append("postmortem_for")
+        if getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
+            select_related.append("jira_postmortem_for")
         return select_related
 
 

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/incidents/models/impact.py

@@ -12,8 +12,6 @@ from django.utils.translation import gettext_lazy as _
 from django_stubs_ext.db.models import TypedModelMeta
 
 if TYPE_CHECKING:
-    from django.db.models.fields.related import ManyToManyField
-
     from firefighter.incidents.models.incident import Incident  # noqa: F401
 
 
@@ -50,7 +48,7 @@ class LevelChoices(models.TextChoices):
             self.LOWEST: 5,
             self.NONE: 6,
         }
-        return priority_mapping.get(self, 6)  # type: ignore [call-overload]
+        return priority_mapping.get(self, 6)  # type: ignore[call-overload]
 
     @property
     def emoji(self) -> str:
@@ -64,7 +62,7 @@ class LevelChoices(models.TextChoices):
             self.LOWEST: "⏬",
             self.NONE: none_emoji,
         }
-        return emoji_mapping.get(self, none_emoji)  # type: ignore [call-overload]
+        return emoji_mapping.get(self, none_emoji)  # type: ignore[call-overload]
 
 
 class ImpactLevel(models.Model):
@@ -156,4 +154,4 @@ class IncidentImpact(models.Model):
 
 class HasImpactProtocol(Protocol):
     id: Any
-    impacts: ManyToManyField[Impact, Any]
+    impacts: Any

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/incidents/models/incident.py

@@ -69,6 +69,8 @@ if TYPE_CHECKING:
 
     if settings.ENABLE_CONFLUENCE:
         from firefighter.confluence.models import PostMortem
+    if getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
+        from firefighter.jira_app.models import JiraPostMortem
 
 
 NON_ALPHANUMERIC_CHARACTERS = re.compile(r"[^\da-zA-Z]+")
@@ -338,15 +340,25 @@ class Incident(models.Model):
 
     @property
     def needs_postmortem(self) -> bool:
-        return (
-            bool(
-                self.priority
-                and self.environment
-                and self.priority.needs_postmortem
-                and self.environment.value == "PRD"
-            )
-            if apps.is_installed("firefighter.confluence")
-            else False
+        """Check if incident requires a post-mortem based on priority and environment.
+
+        Post-mortem is required if:
+        - Priority requires it (P1/P2)
+        - Environment is PRD
+        - At least one post-mortem system is enabled (Confluence OR Jira)
+        """
+        # Check if at least one post-mortem system is enabled
+        has_confluence = apps.is_installed("firefighter.confluence")
+        has_jira_postmortem = getattr(settings, "ENABLE_JIRA_POSTMORTEM", False)
+
+        if not (has_confluence or has_jira_postmortem):
+            return False
+
+        return bool(
+            self.priority
+            and self.environment
+            and self.priority.needs_postmortem
+            and self.environment.value == "PRD"
         )
 
     @property
@@ -649,6 +661,9 @@ class Incident(models.Model):
         if settings.ENABLE_CONFLUENCE:
             postmortem_for: PostMortem
             postmortem_for_id: UUID
+        if getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
+            jira_postmortem_for: JiraPostMortem
+            jira_postmortem_for_id: UUID
         priority_id: UUID
         environment_id: UUID
         component_id: UUID

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/incidents/views/views.py

@@ -150,6 +150,8 @@ class IncidentDetailView(CustomDetailView[Incident]):
     ]
     if settings.ENABLE_CONFLUENCE:
         select_related.append("postmortem_for")
+    if getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
+        select_related.append("jira_postmortem_for")
     queryset = Incident.objects.select_related(*select_related).prefetch_related(
         Prefetch(
             "incidentupdate_set",

firefighter_incident-0.0.23/firefighter/jira_app/admin.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from django.contrib import admin
+
+from firefighter.jira_app.models import JiraIssue, JiraPostMortem, JiraUser
+
+
+@admin.register(JiraUser)
+class JiraUserAdmin(admin.ModelAdmin[JiraUser]):
+    model = JiraUser
+    list_display = ["id", "user"]
+    list_display_links = ["id", "user"]
+    search_fields = ["id", "user__username"]
+    list_select_related = ["user"]
+
+
+@admin.register(JiraIssue)
+class JiraIssueAdmin(admin.ModelAdmin[JiraIssue]):
+    model = JiraIssue
+    list_display = ["id", "key", "summary"]
+    list_display_links = ["id", "key", "summary"]
+    search_fields = ["id", "key", "summary", "description"]
+
+    autocomplete_fields = ["watchers", "assignee", "reporter"]
+
+
+@admin.register(JiraPostMortem)
+class JiraPostMortemAdmin(admin.ModelAdmin[JiraPostMortem]):
+    model = JiraPostMortem
+    list_display = ["jira_issue_key", "incident", "created_at", "created_by"]
+    list_display_links = ["jira_issue_key", "incident"]
+    search_fields = ["jira_issue_key", "jira_issue_id", "incident__id"]
+    list_select_related = ["incident", "created_by"]
+    autocomplete_fields = ["incident", "created_by"]
+    readonly_fields = ["created_at", "updated_at", "issue_url"]
+
+    def issue_url(self, obj: JiraPostMortem) -> str:
+        return obj.issue_url

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/jira_app/apps.py

@@ -10,6 +10,9 @@ class JiraAppConfig(AppConfig):
     verbose_name = "Jira"
 
     def ready(self) -> None:
+        # Register signals
+        # E.g. usage: create PostMortem (Jira and/or Confluence) on incident_updated
+        import firefighter.jira_app.signals
         import firefighter.jira_app.tasks
 
         return super().ready()

{firefighter_incident-0.0.22 → firefighter_incident-0.0.23}/firefighter/jira_app/client.py

@@ -268,9 +268,7 @@ class JiraClient:
             raise
         else:
             if len(watchers) == 0:
-                logger.debug(
-                    "No watchers found for jira_issue_id '%s'.", jira_issue_id
-                )
+                logger.debug("No watchers found for jira_issue_id '%s'.", jira_issue_id)
             return watchers
 
     @staticmethod
@@ -461,5 +459,155 @@ class JiraClient:
 
         return statuses_info_list
 
+    def create_postmortem_issue(
+        self,
+        project_key: str,
+        issue_type: str,
+        fields: dict[str, Any],
+        parent_issue_key: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a Jira post-mortem issue with custom fields.
+
+        Args:
+            project_key: Jira project key (e.g., "INCIDENT")
+            issue_type: Issue type name (e.g., "Post-mortem")
+            fields: Dictionary of field IDs to values
+            parent_issue_key: Optional parent issue key to link this post-mortem to
+
+        Returns:
+            Dictionary with 'key' and 'id' of created issue
+
+        Raises:
+            JiraAPIError: If issue creation fails
+        """
+        try:
+            issue_dict: dict[str, Any] = {
+                "project": {"key": project_key},
+                "issuetype": {"name": issue_type},
+                **fields,
+            }
+
+            # Create the issue first without parent link
+            issue = self.jira.create_issue(fields=issue_dict)
+            logger.info(
+                "Created post-mortem issue %s in project %s", issue.key, project_key
+            )
+
+            # Create issue link to parent if provided
+            # Using link instead of parent to avoid hierarchy restrictions
+            if parent_issue_key:
+                self._create_issue_link_safe(
+                    parent_issue_key=parent_issue_key,
+                    postmortem_issue_key=issue.key,
+                )
+
+        except exceptions.JIRAError as e:
+            logger.exception("Failed to create Jira issue in project %s", project_key)
+            error_msg = f"Failed to create Jira issue: {e.status_code} {e.text}"
+            raise JiraAPIError(error_msg) from e
+        else:
+            return {
+                "key": issue.key,
+                "id": issue.id,
+            }
+
+    def _create_issue_link_safe(
+        self, parent_issue_key: str, postmortem_issue_key: str
+    ) -> None:
+        """Create an issue link between parent and post-mortem, with robust error handling.
+
+        This method tries multiple link types in order of preference:
+        1. "Relates" - Standard link type
+        2. "Blocks" - Alternative link type
+        3. "Relates to" - Another common variant
+
+        Args:
+            parent_issue_key: Parent incident issue key
+            postmortem_issue_key: Post-mortem issue key
+
+        Note:
+            This method will not raise exceptions - it logs warnings instead.
+            The post-mortem creation should succeed even if linking fails.
+        """
+        # List of link types to try, in order of preference
+        link_types = ["Relates", "Blocks", "Relates to"]
+
+        for link_type in link_types:
+            try:
+                # Validate that both issues exist before attempting link
+                try:
+                    self.jira.issue(parent_issue_key)
+                    self.jira.issue(postmortem_issue_key)
+                except exceptions.JIRAError as validation_error:
+                    logger.warning(
+                        "Issue validation failed before creating link: %s",
+                        validation_error,
+                    )
+                    return
+
+                # Create the link
+                self.jira.create_issue_link(
+                    type=link_type,
+                    inwardIssue=parent_issue_key,
+                    outwardIssue=postmortem_issue_key,
+                    comment={
+                        "body": f"Post-mortem {postmortem_issue_key} created for incident {parent_issue_key}"
+                    },
+                )
+
+            except exceptions.JIRAError as link_error:
+                logger.warning(
+                    "Failed to create issue link (%s) from %s to %s: %s",
+                    link_type,
+                    parent_issue_key,
+                    postmortem_issue_key,
+                    link_error,
+                )
+                # Continue to try next link type
+            else:
+                logger.info(
+                    "Created issue link (%s) from %s to %s",
+                    link_type,
+                    parent_issue_key,
+                    postmortem_issue_key,
+                )
+                return  # Success - exit early
+
+        # All link types failed
+        logger.error(
+            "Failed to create any issue link from %s to %s after trying all link types: %s",
+            parent_issue_key,
+            postmortem_issue_key,
+            link_types,
+        )
+
+    def assign_issue(self, issue_key: str, account_id: str) -> bool:
+        """Assign a Jira issue to a user.
+
+        Args:
+            issue_key: Jira issue key (e.g., "INCIDENT-123")
+            account_id: Jira account ID of the user
+
+        Returns:
+            True if assignment succeeded, False otherwise
+
+        Note:
+            This method does not raise exceptions. Assignment failures are logged
+            as warnings since assignment is typically an optional operation.
+        """
+        try:
+            self.jira.assign_issue(issue_key, account_id)
+        except exceptions.JIRAError as e:
+            logger.warning(
+                "Failed to assign issue %s to user %s: %s",
+                issue_key,
+                account_id,
+                e.text if hasattr(e, "text") else str(e),
+            )
+            return False
+        else:
+            logger.info("Assigned issue %s to user %s", issue_key, account_id)
+            return True
+
 
 client = JiraClient()

firefighter_incident-0.0.23/firefighter/jira_app/management/__init__.py

@@ -0,0 +1 @@
+"""Management commands for jira_app."""

firefighter_incident-0.0.23/firefighter/jira_app/management/commands/__init__.py

@@ -0,0 +1 @@
+"""Management commands for jira_app."""

firefighter_incident-0.0.23/firefighter/jira_app/migrations/0002_add_jira_postmortem_model.py

@@ -0,0 +1,71 @@
+# Generated by Django 4.2.21 on 2025-11-06 15:15
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0029_add_custom_fields_to_incident"),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("jira_app", "0001_initial_oss"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="JiraPostMortem",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "jira_issue_key",
+                    models.CharField(
+                        help_text="Jira issue key (e.g., INCIDENT-123)",
+                        max_length=32,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "jira_issue_id",
+                    models.CharField(
+                        help_text="Jira issue ID", max_length=32, unique=True
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "created_by",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="jira_postmortems_created",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "incident",
+                    models.OneToOneField(
+                        help_text="Incident this post-mortem is for",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="jira_postmortem_for",
+                        to="incidents.incident",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Jira Post-mortem",
+                "verbose_name_plural": "Jira Post-mortems",
+                "db_table": "jira_postmortem",
+            },
+        ),
+    ]