firefighter-incident 0.0.25__py3-none-any.whl → 0.0.27__py3-none-any.whl

firefighter/slack/messages/slack_messages.py

@@ -615,6 +615,168 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
         return [SectionBlock(text=self.get_text())]
 
 
+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 Confluence Post-Mortem",
+                    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):
     id = "ff_incident_during_off_hours"
 

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

firefighter/slack/views/modals/closure_reason.py

@@ -115,36 +115,63 @@ class ClosureReasonModal(IncidentSelectableModalMixin, SlackModal):
         self, ack: Ack, body: dict[str, Any], incident: Incident, user: User
     ) -> bool | None:
         """Handle the closure reason modal submission."""
-        # Early validation: Check if incident can be closed BEFORE calling ack()
-        # This validation happens BEFORE ack() so we can display errors in the modal
-        can_close, reasons = incident.can_be_closed
-        if not can_close:
-            # Build error message from reasons
-            error_messages = [reason[1] for reason in reasons]
-            error_text = "\n".join([f"• {msg}" for msg in error_messages])
-            ack(
-                response_action="errors",
-                errors={
-                    "closure_message": f"Cannot close this incident:\n{error_text}"
-                }
-            )
-            return False
-
-        # Clear ALL modals in the stack (not just this one)
-        # This ensures the underlying "Update Status" modal is also closed
-        ack(response_action="clear")
-
-        # Extract form values
+        # Extract form values up-front so validation can account for the submitted reason
         state_values = body["view"]["state"]["values"]
         closure_reason = state_values["closure_reason"]["select_closure_reason"][
             "selected_option"
         ]["value"]
         closure_reference = (
-            state_values["closure_reference"]["input_closure_reference"].get("value", "")
+            state_values["closure_reference"]["input_closure_reference"].get(
+                "value", ""
+            )
             or ""
         )
         message = state_values["closure_message"]["input_closure_message"]["value"]
 
+        # For early closure (OPEN/INVESTIGATING), we bypass normal workflow checks
+        # For normal closure (MITIGATED/POST_MORTEM), we must validate key events
+        current_status = incident.status
+        is_early_closure = current_status.value in {IncidentStatus.OPEN, IncidentStatus.INVESTIGATING}
+
+        if not is_early_closure:
+            # Normal closure path - validate that incident can be closed
+            can_close, reasons = incident.can_be_closed
+            if not can_close:
+                # Build error message from reasons
+                error_messages = [reason[1] for reason in reasons]
+                error_text = "\n".join([f"• {msg}" for msg in error_messages])
+                ack(
+                    response_action="errors",
+                    errors={
+                        "closure_message": f"Cannot close this incident:\n{error_text}"
+                    }
+                )
+                return False
+        else:
+            # Early closure path - validate with the submitted closure reason
+            # Temporarily inject the submitted closure_reason so early-closure bypass applies
+            original_closure_reason = incident.closure_reason
+            incident.closure_reason = closure_reason
+            try:
+                can_close, reasons = incident.can_be_closed
+            finally:
+                incident.closure_reason = original_closure_reason
+            if not can_close:
+                # Build error message from reasons
+                error_messages = [reason[1] for reason in reasons]
+                error_text = "\n".join([f"• {msg}" for msg in error_messages])
+                ack(
+                    response_action="errors",
+                    errors={
+                        "closure_message": f"Cannot close this incident:\n{error_text}"
+                    },
+                )
+                return False
+
+        # Clear ALL modals in the stack (not just this one)
+        # This ensures the underlying "Update Status" modal is also closed
+        ack(response_action="clear")
+
         try:
             # Update incident with closure fields
             incident.closure_reason = closure_reason
@@ -160,9 +187,7 @@ class ClosureReasonModal(IncidentSelectableModalMixin, SlackModal):
             )
 
         except Exception:
-            logger.exception(
-                "Error closing incident #%s with reason", incident.id
-            )
+            logger.exception("Error closing incident #%s with reason", incident.id)
             respond(
                 body=body,
                 text=f"❌ Failed to close incident #{incident.id}",
@@ -177,7 +202,11 @@ class ClosureReasonModal(IncidentSelectableModalMixin, SlackModal):
                         f"✅ Incident #{incident.id} has been closed.\n"
                         f"*Reason:* {ClosureReason(closure_reason).label}\n"
                         f"*Message:* {message}"
-                        + (f"\n*Reference:* {closure_reference}" if closure_reference else "")
+                        + (
+                            f"\n*Reference:* {closure_reference}"
+                            if closure_reference
+                            else ""
+                        )
                     ),
                 )
             except SlackApiError as e:

firefighter/slack/views/modals/update_status.py

@@ -127,12 +127,12 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
                     # Build error message from reasons
                     error_messages = [reason[1] for reason in reasons]
                     error_text = "\n".join([f"• {msg}" for msg in error_messages])
-                    logger.warning(f"Cannot close incident #{incident.id} via Update Status: {error_text}")
+                    logger.warning(
+                        f"Cannot close incident #{incident.id} via Update Status: {error_text}"
+                    )
                     ack(
                         response_action="errors",
-                        errors={
-                            "status": f"Cannot close this incident:\n{error_text}"
-                        }
+                        errors={"status": f"{error_text}"},
                     )
                     return
 

{firefighter_incident-0.0.25.dist-info → firefighter_incident-0.0.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.25
+Version: 0.0.27
 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/