firefighter-incident 0.0.26__py3-none-any.whl → 0.0.28__py3-none-any.whl

firefighter/slack/messages/slack_messages.py

@@ -109,15 +109,36 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
                     action_id=UpdateStatusModal.open_action,
                 ),
             ),
-            SectionBlock(
-                text="2. Edit your post-mortem on Confluence",
-                accessory=ButtonElement(
-                    text="Edit post-mortem",
-                    value=self.incident.postmortem_for.page_edit_url,
-                    url=self.incident.postmortem_for.page_edit_url,
-                    action_id="open_link",
-                ),
-            ),
+        ]
+
+        # Add post-mortem editing options based on available services
+        if hasattr(self.incident, "postmortem_for") and self.incident.postmortem_for:
+            blocks.append(
+                SectionBlock(
+                    text="2. Edit your post-mortem on Confluence",
+                    accessory=ButtonElement(
+                        text="Edit post-mortem",
+                        value=self.incident.postmortem_for.page_edit_url,
+                        url=self.incident.postmortem_for.page_edit_url,
+                        action_id="open_link",
+                    ),
+                )
+            )
+        elif hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+            jira_pm = self.incident.jira_postmortem_for
+            blocks.append(
+                SectionBlock(
+                    text="2. Edit your post-mortem on Jira",
+                    accessory=ButtonElement(
+                        text=f"Edit Jira post-mortem ({jira_pm.jira_issue_key})",
+                        url=jira_pm.issue_url,
+                        action_id="open_link",
+                    ),
+                )
+            )
+
+        # Continue with remaining steps
+        blocks.extend([
             SectionBlock(
                 text=f"3. Submit the key events to {APP_DISPLAY_NAME}",
                 **accessory_kwargs,
@@ -138,7 +159,8 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
                     )
                 ]
             ),
-        ]
+        ])
+
         if POSTMORTEM_HELP_URL:
             blocks.insert(
                 4,
@@ -184,14 +206,30 @@ class SlackMessageIncidentFixedNextActions(SlackMessageSurface):
                 ),
             ),
             DividerBlock(),
-            ContextBlock(
-                elements=[
-                    MarkdownTextObject(
-                        text="A post-mortem is *not* required for this incident.\nIf you want to create one, use `/incident postmortem` to create a new post-mortem page on Confluence."
-                    )
-                ]
-            ),
         ]
+
+        # Add post-mortem context message if any post-mortem service is enabled
+        enable_confluence = getattr(settings, "ENABLE_CONFLUENCE", False)
+        enable_jira_postmortem = getattr(settings, "ENABLE_JIRA_POSTMORTEM", False)
+
+        if enable_confluence or enable_jira_postmortem:
+            postmortem_text = "A post-mortem is *not* required for this incident.\nIf you want to create one, use `/incident postmortem` to create a new post-mortem page"
+
+            if enable_confluence and enable_jira_postmortem:
+                postmortem_text += " on Confluence or Jira."
+            elif enable_confluence:
+                postmortem_text += " on Confluence."
+            elif enable_jira_postmortem:
+                postmortem_text += " on Jira."
+
+            blocks.append(
+                ContextBlock(
+                    elements=[
+                        MarkdownTextObject(text=postmortem_text)
+                    ]
+                )
+            )
+
         return blocks
 
 
@@ -612,7 +650,185 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
         return "\n".join(parts)
 
     def get_blocks(self) -> list[Block]:
-        return [SectionBlock(text=self.get_text())]
+        blocks: list[Block] = [SectionBlock(text=self.get_text())]
+
+        # Add documentation link if Jira post-mortem exists
+        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+            blocks.append(
+                SectionBlock(
+                    text="Need guidance on how to fill Post-Mortems in Jira? See our documentation",
+                    accessory=ButtonElement(
+                        text="Open documentation",
+                        url="https://manomano.atlassian.net/wiki/spaces/TC/pages/5639635000/How+to+fill+Post-Mortems+in+Jira",
+                        value="jira_postmortem_documentation",
+                        action_id="open_link",
+                    ),
+                )
+            )
+
+        return blocks
+
+
+class SlackMessageIncidentPostMortemCreatedAnnouncement(SlackMessageSurface):
+    """Message to announce post-mortem creation in #critical-incidents (tech_incidents tag)."""
+
+    id = "ff_incident_postmortem_created_announcement"
+    incident: Incident
+
+    def __init__(self, incident: Incident) -> None:
+        self.incident = incident
+        super().__init__()
+
+    def get_text(self) -> str:
+        """Generate announcement text for critical incidents channel."""
+        return f"📔 Post-mortem created for {self.incident.priority} incident #{self.incident.id}: {self.incident.title}"
+
+    def get_blocks(self) -> list[Block]:
+        fields = [
+            f"{self.incident.priority.emoji} *Priority:* {self.incident.priority.name}",
+            f":calendar: *Created at:* {date_time(self.incident.created_at)}",
+            f":slack: *Channel:* <#{self.incident.conversation.channel_id}>",
+        ]
+
+        # Add Confluence link if available
+        if hasattr(self.incident, "postmortem_for"):
+            fields.append(
+                f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-Mortem*>"
+            )
+
+        # Add Jira link if available
+        if hasattr(self.incident, "jira_postmortem_for"):
+            jira_pm = self.incident.jira_postmortem_for
+            fields.append(
+                f":jira_new: <{jira_pm.issue_url}|*Jira Post-Mortem ({jira_pm.jira_issue_key})*>"
+            )
+
+        blocks: list[Block] = [
+            SectionBlock(
+                text=f"📔 *Post-mortem created for incident #{self.incident.id}*"
+            ),
+            SectionBlock(text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*"),
+            DividerBlock(),
+            SectionBlock(fields=fields),
+        ]
+
+        return blocks
+
+
+class SlackMessagePostMortemReminder5Days(SlackMessageSurface):
+    """Reminder message sent 5 days after incident reaches MITIGATED status.
+
+    Sent to both the incident channel and #critical-incidents (tech_incidents tag).
+    """
+
+    id = "ff_incident_postmortem_reminder_5days"
+    incident: Incident
+
+    def __init__(self, incident: Incident) -> None:
+        self.incident = incident
+        super().__init__()
+
+    def get_text(self) -> str:
+        return f"⏰ Reminder: Post-mortem for incident #{self.incident.id} needs to be completed"
+
+    def get_blocks(self) -> list[Block]:
+        blocks: list[Block] = [
+            HeaderBlock(
+                text=PlainTextObject(
+                    text="⏰ Post-mortem Reminder ⏰",
+                    emoji=True,
+                )
+            ),
+            SectionBlock(
+                text="This incident was mitigated 5 days ago. The post-mortem *must* be completed to close the incident."
+            ),
+            DividerBlock(),
+        ]
+
+        # Add links to post-mortems
+        pm_links = []
+        if hasattr(self.incident, "postmortem_for"):
+            pm_links.append(
+                ButtonElement(
+                    text="Open Post-Mortem (Confluence)",
+                    url=self.incident.postmortem_for.page_edit_url,
+                    action_id="open_link",
+                )
+            )
+
+        if hasattr(self.incident, "jira_postmortem_for"):
+            jira_pm = self.incident.jira_postmortem_for
+            pm_links.append(
+                ButtonElement(
+                    text=f"Open Jira Post-Mortem ({jira_pm.jira_issue_key})",
+                    url=jira_pm.issue_url,
+                    action_id="open_link",
+                )
+            )
+
+        if pm_links:
+            blocks.append(ActionsBlock(elements=pm_links))
+
+        # Add action buttons
+        blocks.extend([
+            DividerBlock(),
+            SectionBlock(
+                text="Update the incident status or close it once the post-mortem is complete.",
+                accessory=ButtonElement(
+                    text="Update status",
+                    value=str(self.incident.id),
+                    action_id=UpdateStatusModal.open_action,
+                ),
+            ),
+        ])
+
+        return blocks
+
+
+class SlackMessagePostMortemReminder5DaysAnnouncement(SlackMessageSurface):
+    """Announcement version of 5-day reminder for #critical-incidents channel."""
+
+    id = "ff_incident_postmortem_reminder_5days_announcement"
+    incident: Incident
+
+    def __init__(self, incident: Incident) -> None:
+        self.incident = incident
+        super().__init__()
+
+    def get_text(self) -> str:
+        return f"⏰ Post-mortem reminder for {self.incident.priority} incident #{self.incident.id}: {self.incident.title}"
+
+    def get_blocks(self) -> list[Block]:
+        fields = [
+            f"{self.incident.priority.emoji} *Priority:* {self.incident.priority.name}",
+            f":calendar: *Mitigated:* {date_time(self.incident.mitigated_at) if self.incident.mitigated_at else 'Unknown'}",
+            f":slack: *Channel:* <#{self.incident.conversation.channel_id}>",
+        ]
+
+        # Add post-mortem links
+        if hasattr(self.incident, "postmortem_for"):
+            fields.append(
+                f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-Mortem*>"
+            )
+
+        if hasattr(self.incident, "jira_postmortem_for"):
+            jira_pm = self.incident.jira_postmortem_for
+            fields.append(
+                f":jira_new: <{jira_pm.issue_url}|*Jira Post-Mortem ({jira_pm.jira_issue_key})*>"
+            )
+
+        blocks: list[Block] = [
+            SectionBlock(
+                text=f"⏰ *Post-mortem reminder for incident #{self.incident.id}*"
+            ),
+            SectionBlock(
+                text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*\n_This incident was mitigated 5 days ago. Post-mortem completion is overdue._"
+            ),
+            DividerBlock(),
+            SectionBlock(fields=fields),
+        ]
+
+        return blocks
 
 
 class SlackMessageIncidentDuringOffHours(SlackMessageSurface):

firefighter/slack/migrations/0009_add_postmortem_reminder_periodic_task.py

@@ -0,0 +1,60 @@
+# Generated by Django 4.2.21 on 2025-12-19 14:05
+
+from django.db import migrations
+
+
+def create_postmortem_reminder_task(apps, schema_editor):
+    """Create periodic task for post-mortem reminders.
+
+    Runs twice daily at 10:00 AM and 3:00 PM to check for incidents mitigated 5+ days ago.
+    """
+    CrontabSchedule = apps.get_model("django_celery_beat", "CrontabSchedule")
+    PeriodicTask = apps.get_model("django_celery_beat", "PeriodicTask")
+
+    # Create crontab schedule for 10:00 AM and 3:00 PM (Europe/Paris timezone)
+    # Crontab format: minute hour day_of_week day_of_month month_of_year
+    # hour='10,15' means run at both 10:00 and 15:00
+    # Using Europe/Paris timezone handles DST automatically
+    schedule, _ = CrontabSchedule.objects.get_or_create(
+        minute="0",
+        hour="10,15",
+        day_of_week="*",
+        day_of_month="*",
+        month_of_year="*",
+        timezone="Europe/Paris",
+    )
+
+    # Create the periodic task
+    PeriodicTask.objects.get_or_create(
+        name="Send post-mortem reminders for mitigated incidents",
+        defaults={
+            "task": "slack.send_postmortem_reminders",
+            "crontab": schedule,
+            "enabled": True,
+            "description": "Send reminders for incidents mitigated 5+ days ago that still need post-mortem completion (runs at 10 AM and 3 PM)",
+        },
+    )
+
+
+def remove_postmortem_reminder_task(apps, schema_editor):
+    """Remove the periodic task on migration rollback."""
+    PeriodicTask = apps.get_model("django_celery_beat", "PeriodicTask")
+
+    PeriodicTask.objects.filter(
+        task="slack.send_postmortem_reminders"
+    ).delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("slack", "0008_alter_conversation_incident_categories_and_more"),
+        ("django_celery_beat", "0019_alter_periodictasks_options"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            create_postmortem_reminder_task,
+            reverse_code=remove_postmortem_reminder_task,
+        ),
+    ]

firefighter/slack/rules.py

@@ -52,3 +52,25 @@ def should_publish_in_it_deploy_channel(incident: Incident) -> bool:
         and not incident.private
         and incident.incident_category.deploy_warning
     )
+
+
+def should_publish_pm_in_general_channel(incident: Incident) -> bool:
+    """Determine if post-mortem creation should be announced in #critical-incidents.
+
+    Post-mortems are announced for P1-P3 production incidents that are not private
+    and require a post-mortem.
+
+    Args:
+        incident: The incident for which a post-mortem was created.
+
+    Returns:
+        True if the post-mortem creation should be announced in tech_incidents channel.
+    """
+    return (
+        incident.priority is not None
+        and incident.priority.value <= 3
+        and incident.environment is not None
+        and incident.environment.value == "PRD"
+        and not incident.private
+        and incident.needs_postmortem
+    )

firefighter/slack/tasks/send_postmortem_reminders.py

@@ -0,0 +1,127 @@
+"""Celery task to send post-mortem reminders for incidents.
+
+This task runs periodically to check for incidents that were mitigated
+5 days ago and still need their post-mortem completed.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+from celery import shared_task
+from django.conf import settings
+from django.utils import timezone
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.models.incident import Incident
+from firefighter.slack.models.conversation import Conversation
+from firefighter.slack.rules import should_publish_pm_in_general_channel
+
+if TYPE_CHECKING:
+    from firefighter.slack.models import Message
+
+if settings.ENABLE_SLACK:
+    from firefighter.slack.messages.slack_messages import (
+        SlackMessagePostMortemReminder5Days,
+        SlackMessagePostMortemReminder5DaysAnnouncement,
+    )
+    from firefighter.slack.models import Message
+
+logger = logging.getLogger(__name__)
+
+# Days after mitigation to send reminder
+POSTMORTEM_REMINDER_DAYS = 5
+
+
+@shared_task(name="slack.send_postmortem_reminders")
+def send_postmortem_reminders() -> None:
+    """Send post-mortem completion reminders for incidents mitigated 5+ days ago.
+
+    This task:
+    1. Finds incidents that were mitigated at least 5 days ago
+    2. Filters for incidents that still need their post-mortem completed
+    3. Sends reminders to both the incident channel and #critical-incidents
+    4. Tracks sent reminders to avoid duplicates
+    """
+    # Calculate the cutoff date (5 days ago)
+    cutoff_date = timezone.now() - timedelta(days=POSTMORTEM_REMINDER_DAYS)
+
+    # Get incidents that:
+    # - Were mitigated at least 5 days ago
+    # - Still need post-mortem (P1-P3)
+    # - Are in MITIGATED or POST_MORTEM status (not yet closed)
+    # - Are not ignored
+    incidents_needing_reminder = Incident.objects.filter(
+        mitigated_at__lte=cutoff_date,
+        mitigated_at__isnull=False,
+        _status__in=[
+            IncidentStatus.MITIGATED.value,
+            IncidentStatus.POST_MORTEM.value,
+        ],
+        priority__needs_postmortem=True,
+        ignore=False,
+    ).select_related("conversation", "priority", "environment")
+
+    logger.info(
+        f"Found {incidents_needing_reminder.count()} incidents needing post-mortem reminders"
+    )
+
+    for incident in incidents_needing_reminder:
+        # Check if we already sent a reminder for this incident
+        if Message.objects.filter(
+            ff_type=SlackMessagePostMortemReminder5Days.id,
+            incident=incident,
+        ).exists():
+            logger.debug(
+                f"Skipping incident #{incident.id} - reminder already sent"
+            )
+            continue
+
+        # Skip if no conversation
+        if not hasattr(incident, "conversation") or not incident.conversation:
+            logger.warning(
+                f"Incident #{incident.id} has no conversation, skipping reminder"
+            )
+            continue
+
+        # Send reminder to incident channel
+        try:
+            reminder_message = SlackMessagePostMortemReminder5Days(incident)
+            incident.conversation.send_message_and_save(reminder_message)
+            logger.info(
+                f"Sent post-mortem reminder to incident #{incident.id} channel"
+            )
+        except Exception:
+            logger.exception(
+                f"Failed to send post-mortem reminder to incident #{incident.id} channel"
+            )
+            continue
+
+        # Send announcement to #critical-incidents if applicable
+        if should_publish_pm_in_general_channel(incident):
+            try:
+                tech_incidents_conversation = Conversation.objects.get_or_none(
+                    tag="tech_incidents"
+                )
+                if tech_incidents_conversation:
+                    announcement = SlackMessagePostMortemReminder5DaysAnnouncement(
+                        incident
+                    )
+                    tech_incidents_conversation.send_message_and_save(announcement)
+                    logger.info(
+                        f"Sent post-mortem reminder to tech_incidents for incident #{incident.id}"
+                    )
+                else:
+                    logger.warning(
+                        "Could not find tech_incidents conversation! Is there a channel with tag tech_incidents?"
+                    )
+            except Exception:
+                logger.exception(
+                    f"Failed to send post-mortem reminder to tech_incidents for incident #{incident.id}"
+                )
+
+    logger.info(
+        f"Post-mortem reminder task completed. Processed {incidents_needing_reminder.count()} incidents."
+    )

firefighter/slack/views/modals/close.py

@@ -104,7 +104,9 @@ class CloseModal(
                             ]
                         ),
                     ]
-                elif reason[0] == "STATUS_NOT_POST_MORTEM":
+                elif reason[0] == "STATUS_NOT_POST_MORTEM" and getattr(
+                    settings, "ENABLE_CONFLUENCE", False
+                ):
                     reason_blocks += [
                         SectionBlock(
                             text=f":warning: *Status is not _{IncidentStatus.POST_MORTEM.label}_* :warning:\n"
@@ -148,6 +150,44 @@ class CloseModal(
                             ]
                         ),
                     ]
+                elif reason[0] == "JIRA_POSTMORTEM_NOT_READY" and getattr(
+                    settings, "ENABLE_JIRA", False
+                ):
+                    reason_blocks += [
+                        SectionBlock(
+                            text=":warning: *Jira post-mortem not ready* :warning:\n"
+                        ),
+                        ContextBlock(
+                            elements=[
+                                MarkdownTextObject(
+                                    text=f"{reason[1]}\nPlease move the Jira post-mortem to the Ready status before closing the incident."
+                                )
+                            ]
+                        ),
+                        ActionsBlock(
+                            elements=[
+                                ButtonElement(
+                                    text="Open Jira post-mortem",
+                                    action_id="open_link",
+                                    url=incident.jira_postmortem_for.issue_url,
+                                    style="primary",
+                                ),
+                            ]
+                        ),
+                    ]
+                elif reason[0] == "JIRA_POSTMORTEM_STATUS_UNKNOWN":
+                    reason_blocks += [
+                        SectionBlock(
+                            text=":warning: *Could not verify Jira post-mortem status* :warning:\n"
+                        ),
+                        ContextBlock(
+                            elements=[
+                                MarkdownTextObject(
+                                    text=f"{reason[1]}\nPlease check the Jira post-mortem status before closing the incident."
+                                )
+                            ]
+                        ),
+                    ]
                 elif reason[0] == "STATUS_NOT_MITIGATED":
                     reason_blocks += [
                         SectionBlock(
@@ -178,6 +218,74 @@ class CloseModal(
                             ]
                         ),
                     ]
+                elif reason[0] == "POSTMORTEM_NOT_READY":
+                    reason_blocks += [
+                        SectionBlock(
+                            text=":warning: *Post-mortem is not Ready* :warning:\n"
+                        ),
+                        ContextBlock(
+                            elements=[
+                                MarkdownTextObject(
+                                    text="The linked Jira post-mortem must be in the *Ready* status before closing the incident.\n"
+                                    + reason[1]
+                                )
+                            ]
+                        ),
+                        ActionsBlock(
+                            elements=[
+                                ButtonElement(
+                                    text="Open Jira post-mortem",
+                                    action_id="open_link",
+                                    url=(
+                                        getattr(
+                                            incident.jira_postmortem_for,
+                                            "issue_url",
+                                            None,
+                                        )
+                                        if hasattr(incident, "jira_postmortem_for")
+                                        else None
+                                    ),
+                                    style="primary",
+                                ),
+                                ButtonElement(
+                                    text="Update status",
+                                    action_id=UpdateStatusModal.push_action,
+                                    value=str(incident.id),
+                                ),
+                            ]
+                        ),
+                    ]
+                elif reason[0] == "POSTMORTEM_STATUS_UNKNOWN":
+                    reason_blocks += [
+                        SectionBlock(
+                            text=":warning: *Could not verify post-mortem status* :warning:\n"
+                        ),
+                        ContextBlock(
+                            elements=[
+                                MarkdownTextObject(
+                                    text="We could not verify the Jira post-mortem status. Please open it in Jira to confirm it is Ready before closing."
+                                )
+                            ]
+                        ),
+                        ActionsBlock(
+                            elements=[
+                                ButtonElement(
+                                    text="Open Jira post-mortem",
+                                    action_id="open_link",
+                                    url=(
+                                        getattr(
+                                            incident.jira_postmortem_for,
+                                            "issue_url",
+                                            None,
+                                        )
+                                        if hasattr(incident, "jira_postmortem_for")
+                                        else None
+                                    ),
+                                    style="primary",
+                                ),
+                            ]
+                        ),
+                    ]
 
             return View(
                 type="modal",
@@ -227,7 +335,7 @@ class CloseModal(
 
     def handle_modal_fn(  # type: ignore[override]
         self, ack: Ack, body: dict[str, Any], incident: Incident, user: User
-    ) ->  bool | None:
+    ) -> bool | None:
         """Handle response from /incident close modal."""
         # Check if this should be handled by closure reason modal
         closure_result = handle_close_modal_callback(ack, body, incident, user)
@@ -243,7 +351,9 @@ class CloseModal(
         update_kwargs = {}
         for changed_key in form.changed_data:
             if changed_key == "incident_category":
-                update_kwargs["incident_category_id"] = form.cleaned_data[changed_key].id
+                update_kwargs["incident_category_id"] = form.cleaned_data[
+                    changed_key
+                ].id
             if changed_key in {"description", "title", "message"}:
                 update_kwargs[changed_key] = form.cleaned_data[changed_key]
         # Check can close