firefighter-incident 0.0.22__py3-none-any.whl → 0.0.23__py3-none-any.whl

firefighter/raid/signals/incident_updated.py

@@ -24,16 +24,36 @@ def incident_updated_close_ticket_when_mitigated_or_postmortem(
     updated_fields: list[str],
     **kwargs: Any,
 ) -> None:
-    # Close Jira ticket if mitigated, postmortem, or closed
-    if "_status" in updated_fields and incident_update.status in {
-        IncidentStatus.MITIGATED,
-        IncidentStatus.POST_MORTEM,
-        IncidentStatus.CLOSED,
-    }:
-        if not hasattr(incident, "jira_ticket") or incident.jira_ticket is None:
-            logger.warning(
-                f"Trying to close Jira ticket for incident {incident.id} but not having"
-            )
-            return
+    """Close Jira incident ticket based on incident status and priority.
+
+    Closure logic:
+    - P1/P2 (needs_postmortem): Close only when incident is CLOSED
+    - P3+ (no postmortem): Close when incident is MITIGATED or CLOSED
+    - POST_MORTEM status never closes the ticket (it remains open during PM phase)
+    """
+    if "_status" not in updated_fields:
+        return
+
+    if not hasattr(incident, "jira_ticket") or incident.jira_ticket is None:
+        logger.warning(
+            f"Trying to close Jira ticket for incident {incident.id} but no Jira ticket found"
+        )
+        return
+
+    # Determine if we should close the ticket based on status and priority
+    should_close = False
+
+    if incident_update.status == IncidentStatus.CLOSED:
+        # Always close on CLOSED regardless of priority
+        should_close = True
+    elif incident_update.status == IncidentStatus.MITIGATED:
+        # Only close on MITIGATED if incident doesn't need postmortem (P3+)
+        should_close = not incident.needs_postmortem
+
+    # POST_MORTEM status never closes the ticket - it stays open during PM phase
+
+    if should_close:
+        status_label = incident_update.status.label if incident_update.status else "Unknown"
+        logger.info(f"Closing Jira ticket for incident {incident.id} (status: {status_label})")
         client.close_issue(issue_id=incident.jira_ticket.id)
         # XXX We may want to add a comment if there is an incident update message on close

firefighter/slack/messages/slack_messages.py

@@ -208,6 +208,7 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         return f"A new {self.incident.priority} incident has been declared: {self.incident.title}"
 
     def get_blocks(self) -> list[Block]:
+        # Build main fields (keep under 10 items due to Slack limit)
         fields = [
             f"{self.incident.priority.emoji} *Priority:* {self.incident.priority.name}",
             f":package: *Incident category:* {self.incident.incident_category.name}",
@@ -218,7 +219,7 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         if hasattr(self.incident, "jira_ticket") and self.incident.jira_ticket:
             fields.append(f":jira_new: <{self.incident.jira_ticket.url}|*Jira ticket*>")
 
-        # Add custom fields if present
+        # Add custom fields if present (max to avoid exceeding 10 fields limit)
         if hasattr(self.incident, "custom_fields") and self.incident.custom_fields:
             custom_fields = self.incident.custom_fields
             if custom_fields.get("zendesk_ticket_id"):
@@ -240,17 +241,36 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
             slack_block_quote(self.incident.description),
             DividerBlock(),
             SectionBlock(
-                fields=fields,
+                fields=fields[:10],  # Slack limits fields to 10 items max
                 accessory=ButtonElement(
                     text="Update",
                     value=str(self.incident.id),
                     action_id=UpdateModal.open_action,
                 ),
             ),
+            *self._postmortem_blocks(),
             *self._impact_blocks(),
         ]
         return blocks
 
+    def _postmortem_blocks(self) -> list[Block]:
+        """Build post-mortem links block if any PM exists."""
+        pm_fields = []
+
+        if hasattr(self.incident, "postmortem_for") and self.incident.postmortem_for:
+            pm_fields.append(f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-mortem*>")
+
+        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+            pm_fields.append(f":jira_new: <{self.incident.jira_postmortem_for.issue_url}|*Jira Post-mortem ({self.incident.jira_postmortem_for.jira_issue_key})*>")
+
+        if not pm_fields:
+            return []
+
+        return [
+            DividerBlock(),
+            SectionBlock(fields=pm_fields),
+        ]
+
     def _impact_blocks(self) -> list[Block]:
         impacts = self.incident.impacts.all().order_by("impact_level__value")[:10]
         none_level = LevelChoices.NONE.value
@@ -573,7 +593,23 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
         super().__init__()
 
     def get_text(self) -> str:
-        return f"📔 The post-mortem has been created, you can edit it here: {self.incident.postmortem_for.page_url}."
+        """Generate text with links to all available post-mortems."""
+        parts = ["📔 The post-mortem has been created:"]
+
+        # Add Confluence link if available
+        if hasattr(self.incident, "postmortem_for"):
+            parts.append(
+                f"• Confluence: {self.incident.postmortem_for.page_url}"
+            )
+
+        # Add Jira link if available
+        if hasattr(self.incident, "jira_postmortem_for"):
+            jira_pm = self.incident.jira_postmortem_for
+            parts.append(
+                f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})"
+            )
+
+        return "\n".join(parts)
 
     def get_blocks(self) -> list[Block]:
         return [SectionBlock(text=self.get_text())]

firefighter/slack/signals/postmortem_created.py

@@ -4,6 +4,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from django.dispatch.dispatcher import receiver
+from slack_sdk.errors import SlackApiError
 
 from firefighter.incidents.signals import postmortem_created
 from firefighter.slack.messages.slack_messages import (
@@ -19,7 +20,19 @@ logger = logging.getLogger(__name__)
 @receiver(signal=postmortem_created)
 # pylint: disable=unused-argument
 def postmortem_created_send(sender: Any, incident: Incident, **kwargs: Any) -> None:
-    if not hasattr(incident, "postmortem_for"):
+    # Refresh incident from database to get the newly created post-mortem relationships
+    # This is necessary because the signal might be sent before the ORM cache is updated
+    try:
+        incident.refresh_from_db()
+    except Exception:
+        logger.exception(f"Failed to refresh incident #{incident.id} from database")
+        return
+
+    # Check if at least one post-mortem exists
+    has_confluence = hasattr(incident, "postmortem_for")
+    has_jira = hasattr(incident, "jira_postmortem_for")
+
+    if not has_confluence and not has_jira:
         logger.warning(f"No PostMortem to post for incident {incident}.")
         return
 
@@ -28,9 +41,44 @@ def postmortem_created_send(sender: Any, incident: Incident, **kwargs: Any) -> N
             f"No Incident Slack channel to post PostMortem for incident {incident}."
         )
         return
+
+    # Send message with all available post-mortem links (pinned)
     incident.conversation.send_message_and_save(
         SlackMessageIncidentPostMortemCreated(incident), pin=True
     )
-    incident.conversation.add_bookmark(
-        title="Postmortem", link=incident.postmortem_for.page_url, emoji=":confluence:"
+
+    # Update the initial incident message with post-mortem links
+    from firefighter.slack.messages.slack_messages import (  # noqa: PLC0415
+        SlackMessageIncidentDeclaredAnnouncement,
+    )
+
+    incident.conversation.send_message_and_save(
+        SlackMessageIncidentDeclaredAnnouncement(incident)
     )
+
+    # Add bookmarks for each available post-mortem
+    if has_confluence:
+        try:
+            incident.conversation.add_bookmark(
+                title="Postmortem (Confluence)",
+                link=incident.postmortem_for.page_url,
+                emoji=":confluence:",
+            )
+        except SlackApiError as e:
+            logger.warning(
+                f"Failed to add Confluence bookmark for incident #{incident.id}: {e}. "
+                "This is expected in test environments without custom emojis."
+            )
+
+    if has_jira:
+        try:
+            incident.conversation.add_bookmark(
+                title=f"Postmortem ({incident.jira_postmortem_for.jira_issue_key})",
+                link=incident.jira_postmortem_for.issue_url,
+                emoji=":jira_new:",
+            )
+        except SlackApiError as e:
+            logger.warning(
+                f"Failed to add Jira bookmark for incident #{incident.id}: {e}. "
+                "This is expected in test environments without custom emojis."
+            )

firefighter/slack/views/modals/closure_reason.py

@@ -115,6 +115,21 @@ 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")

firefighter/slack/views/modals/key_event_message.py

@@ -12,6 +12,7 @@ from slack_sdk.models.blocks.basic_components import MarkdownTextObject
 from slack_sdk.models.blocks.block_elements import ButtonElement
 
 from firefighter.incidents.forms.update_key_events import IncidentUpdateKeyEventsForm
+from firefighter.incidents.signals import incident_key_events_updated
 from firefighter.slack.messages.base import SlackMessageStrategy, SlackMessageSurface
 from firefighter.slack.views.modals.base_modal.base import MessageForm
 
@@ -108,6 +109,14 @@ class KeyEvents(MessageForm[IncidentUpdateKeyEventsForm]):
             return
         self.form = form
         self.form.save()
+
+        # Send signal to update Jira post-mortem timeline if applicable
+        logger.debug("Sending signal incident_key_events_updated")
+        incident_key_events_updated.send_robust(
+            __name__,
+            incident=incident,
+        )
+
         incident.compute_metrics()
 
         self.update_with_form()

firefighter/slack/views/modals/postmortem.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any
 
-from django.apps import apps
 from slack_sdk.models.blocks.blocks import Block, SectionBlock
 from slack_sdk.models.views import View
 
@@ -12,9 +11,6 @@ from firefighter.slack.views.modals.base_modal.mixins import (
     IncidentSelectableModalMixin,
 )
 
-if apps.is_installed("firefighter.confluence"):
-    from firefighter.confluence.models import PostMortem
-
 if TYPE_CHECKING:
     from slack_bolt.context.ack.ack import Ack
 
@@ -34,54 +30,50 @@ class PostMortemModal(
 
     def build_modal_fn(self, incident: Incident, **kwargs: Any) -> View:
         blocks: list[Block] = []
-        if hasattr(incident, "postmortem_for"):
-            blocks.extend([
-                SectionBlock(
-                    text=f"Postmortem for incident #{incident.id} has already been created."
-                ),
-                SectionBlock(
-                    text=f"See the postmortem page <{incident.postmortem_for.page_url}|on Confluence>."
-                ),
-            ])
-            submit = None
+
+        # Check existing post-mortems
+        has_confluence = hasattr(incident, "postmortem_for")
+        has_jira = hasattr(incident, "jira_postmortem_for")
+
+        if has_confluence or has_jira:
+            blocks.append(
+                SectionBlock(text=f"Post-mortem(s) for incident #{incident.id}:")
+            )
+
+            if has_confluence:
+                blocks.append(
+                    SectionBlock(
+                        text=f"• Confluence: <{incident.postmortem_for.page_url}|View page>"
+                    )
+                )
+
+            if has_jira:
+                blocks.append(
+                    SectionBlock(
+                        text=f"• Jira: <{incident.jira_postmortem_for.issue_url}|{incident.jira_postmortem_for.jira_issue_key}>"
+                    )
+                )
         else:
-            blocks.extend([
+            blocks.append(
                 SectionBlock(
-                    text=f"Postmortem does not yet exist for incident #{incident.id}."
-                ),
-                SectionBlock(
-                    text="Click on the button to create the postmortem on Confluence."
-                ),
-            ])
-            submit = "Create postmortem"[:24]
+                    text=f"Post-mortem for incident #{incident.id} will be automatically created when the incident reaches MITIGATED status."
+                )
+            )
 
         return View(
             type="modal",
             title="Postmortem"[:24],
-            submit=submit,
+            submit=None,
             callback_id=self.callback_id,
             private_metadata=str(incident.id),
             blocks=blocks,
         )
 
     @staticmethod
-    def handle_modal_fn(ack: Ack, body: dict[str, Any], incident: Incident) -> None:  # type: ignore[override]
-        if not apps.is_installed("firefighter.confluence"):
-            ack(text="Confluence is not enabled!")
-            return
-        if hasattr(incident, "postmortem_for"):
-            ack(text="Post-mortem has already been created.")
-            return
-
-        # Check if this modal was pushed on top of another modal
-        # If yes, clear the entire stack to avoid leaving stale modals visible
-        is_pushed = body.get("view", {}).get("previous_view_id") is not None
-        if is_pushed:
-            ack(response_action="clear")
-        else:
-            ack()
-
-        PostMortem.objects.create_postmortem_for_incident(incident)
+    def handle_modal_fn(ack: Ack, **_kwargs: Any) -> None:
+        # This modal is now read-only (no submit button)
+        # Post-mortems are created automatically when incident reaches MITIGATED status
+        ack()
 
 
 modal_postmortem = PostMortemModal()

firefighter/slack/views/modals/update_status.py

@@ -104,12 +104,14 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
                 },
                 "incident": incident,
             },
+            ack_on_success=False,  # We'll ack after custom validations
         )
         if slack_form is None:
             return
         form: UpdateStatusFormSlack = slack_form.form
         if len(form.cleaned_data) == 0:
             # XXX We should have a prompt for empty forms
+            ack()
             return
 
         # Check if user is trying to close and needs a closure reason
@@ -118,13 +120,14 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
             if handle_update_status_close_request(ack, body, incident, target_status):
                 return
 
-            # If trying to close, validate that incident can be closed
+            # Validate that incident can be closed (check key events, post-mortem, etc.)
             if target_status == IncidentStatus.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])
+                    logger.warning(f"Cannot close incident #{incident.id} via Update Status: {error_text}")
                     ack(
                         response_action="errors",
                         errors={
@@ -133,6 +136,9 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
                     )
                     return
 
+        # All validations passed, acknowledge the submission
+        ack()
+
         update_kwargs: dict[str, Any] = {}
         for changed_key in form.changed_data:
             if changed_key in {"incident_category", "priority"}:

{firefighter_incident-0.0.22.dist-info → firefighter_incident-0.0.23.dist-info}/METADATA

@@ -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/