firefighter-incident 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

firefighter/slack/views/modals/opening/check_current_incidents.py

@@ -44,9 +44,9 @@ class CheckCurrentIncidentsModal(
             .order_by("-created_at")
             .select_related(
                 "priority",
-                "component",
+                "incident_category",
                 "environment",
-                "component__group",
+                "incident_category__group",
                 "conversation",
             )[:30]
         )

firefighter/slack/views/modals/opening/details/unified.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from django import forms
+from django.conf import settings
+from slack_sdk.models.blocks.basic_components import MarkdownTextObject
+from slack_sdk.models.blocks.blocks import ContextBlock, SectionBlock
+
+from firefighter.incidents.forms.unified_incident import UnifiedIncidentForm
+from firefighter.slack.views.modals.base_modal.form_utils import SlackForm
+from firefighter.slack.views.modals.opening.set_details import SetIncidentDetails
+from firefighter.slack.views.modals.opening.types import OpeningData
+
+if TYPE_CHECKING:
+    from firefighter.slack.views.modals.base_modal.form_utils import (
+        SlackFormAttributesDict,
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class UnifiedIncidentFormSlack(UnifiedIncidentForm):
+    """Slack version of UnifiedIncidentForm with Slack-specific field configurations."""
+
+    slack_fields: SlackFormAttributesDict = {
+        "title": {
+            "input": {
+                "multiline": False,
+                "placeholder": "Short, punchy description of what's happening.",
+            },
+            "block": {"hint": None},
+        },
+        "description": {
+            "input": {
+                "multiline": True,
+                "placeholder": "Help people responding to the incident. This will be posted to #tech-incidents and on our internal status page.\nThis description can be edited later.",
+            },
+            "block": {"hint": None},
+        },
+        "environment": {
+            "input": {
+                "placeholder": "Select environments",
+            },
+        },
+        "platform": {
+            "input": {
+                "placeholder": "Select platforms",
+            },
+        },
+        "priority": {
+            "input": {
+                "placeholder": "Select a priority",
+            },
+            "widget": {
+                "post_block": (
+                    SectionBlock(
+                        text=f"_<{settings.SLACK_SEVERITY_HELP_GUIDE_URL}|How to choose the priority?>_"
+                    )
+                    if settings.SLACK_SEVERITY_HELP_GUIDE_URL
+                    else None
+                ),
+                "label_from_instance": lambda obj: f"{obj.emoji}  {obj.name} - {obj.description}",
+            },
+        },
+        "incident_category": {
+            "input": {
+                "placeholder": "Select affected issue category",
+            },
+        },
+        "suggested_team_routing": {
+            "input": {
+                "placeholder": "Select feature team or train",
+            },
+            "widget": {
+                "post_block": ContextBlock(
+                    elements=[
+                        MarkdownTextObject(
+                            text="Feature Team or Train that should own the issue. If you don't know access <https://manomano.atlassian.net/wiki/spaces/QRAFT/pages/3970335291/Teams+and+owners|here> for guidance."
+                        ),
+                    ]
+                )
+            },
+        },
+        "zendesk_ticket_id": {
+            "input": {
+                "placeholder": "Zendesk ticket ID (if applicable)",
+            },
+            "block": {
+                "hint": "Link this incident to an existing Zendesk customer ticket"
+            },
+        },
+        "seller_contract_id": {
+            "input": {
+                "placeholder": "Seller contract ID",
+            },
+        },
+        "zoho_desk_ticket_id": {
+            "input": {
+                "placeholder": "Zoho Desk ticket ID (if applicable)",
+            },
+            "block": {
+                "hint": "Link this incident to an existing Zoho Desk seller ticket"
+            },
+        },
+    }
+
+    def __init__(
+        self,
+        *args: Any,
+        impacts_data: dict[str, Any] | None = None,
+        response_type: str = "critical",
+        **kwargs: Any,
+    ) -> None:
+        """Initialize form with impact-based field visibility.
+
+        Args:
+            *args: Positional arguments passed to parent form
+            impacts_data: Dictionary of impact selections
+            response_type: "critical" or "normal"
+            **kwargs: Keyword arguments passed to parent form
+        """
+        super().__init__(*args, **kwargs)
+
+        # Store for later use
+        self._impacts_data = impacts_data or {}
+        self._response_type = response_type
+
+        # Make priority field hidden
+        self.fields["priority"].widget = forms.HiddenInput()
+
+        # Conditionally hide fields based on impacts and response_type
+        self._configure_field_visibility()
+
+    def _configure_field_visibility(self) -> None:
+        """Configure which fields should be visible based on impacts and response type."""
+        visible_fields = self.get_visible_fields_for_impacts(
+            self._impacts_data, self._response_type
+        )
+
+        # Remove fields that shouldn't be visible
+        fields_to_remove = [
+            field_name for field_name in self.fields if field_name not in visible_fields
+        ]
+
+        for field_name in fields_to_remove:
+            del self.fields[field_name]
+
+
+class OpeningUnifiedModal(SetIncidentDetails[UnifiedIncidentFormSlack]):
+    """Unified modal for all incident types (P1-P5)."""
+
+    open_action: str = "open_incident_unified"
+    push_action: str = "push_incident_unified"
+    callback_id: str = "open_incident_unified"
+    id = "incident_unified"
+
+    title = "Incident Details"
+    form_class = UnifiedIncidentFormSlack
+
+    def get_form_class(self) -> Any:
+        """Return a SlackForm wrapper that passes impacts_data and response_type."""
+        form_class = self.form_class
+
+        # Create a custom form class that accepts our parameters
+        class ContextAwareForm(form_class):  # type: ignore
+            def __init__(self, *args: Any, **kwargs: Any) -> None:
+                # Extract context from kwargs
+                open_incident_context = kwargs.pop("open_incident_context", None)
+                if open_incident_context:
+                    kwargs["impacts_data"] = open_incident_context.get("impact_form_data", {})
+                    kwargs["response_type"] = open_incident_context.get("response_type", "critical")
+                super().__init__(*args, **kwargs)
+
+        # Return SlackForm wrapping the context-aware form
+        return SlackForm(ContextAwareForm)
+
+    def build_modal_fn(
+        self, open_incident_context: OpeningData | None = None, **kwargs: Any
+    ) -> Any:
+        """Build modal with impact-aware form."""
+        # Extract impacts and response type from context
+        if open_incident_context is None:
+            open_incident_context = OpeningData()
+
+        response_type = open_incident_context.get("response_type", "critical")
+
+        # Store in initial data so form can access it
+        details_form_data = open_incident_context.get("details_form_data")
+        if details_form_data is None:
+            details_form_data = {}
+        details_form_data["response_type"] = response_type
+
+        # Update context
+        open_incident_context["details_form_data"] = details_form_data
+
+        # Store context for get_form_class in kwargs
+        # Call parent build_modal_fn with open_incident_context in kwargs
+        return super().build_modal_fn(open_incident_context=open_incident_context, **kwargs)
+
+
+modal_opening_unified = OpeningUnifiedModal()

firefighter/slack/views/modals/opening/select_impact.py

@@ -139,13 +139,16 @@ class SelectImpactModal(
         impact_descriptions = ""
         if impact_form_data:
             for value in impact_form_data.values():
-                if value.name != "NO" and value.description:
+                # Filter out "no impact" levels using the value field instead of name
+                if not ((hasattr(value, "value") and value.value == "NO") or value.name == "NO" or not value.description):
                     if hasattr(value, "impact_type_id") and value.impact_type_id:
                         impact_type = ImpactType.objects.get(pk=value.impact_type_id)
                         if impact_type:
                             impact_descriptions += f"\u00A0\u00A0 :exclamation: {impact_type} - {value}\n"
                     for line in str(value.description).splitlines():
-                        impact_descriptions += f"\u00A0\u00A0\u00A0\u00A0\u00A0\u00A0 • {line}\n"
+                        # Skip empty lines or lines with only dashes/whitespace
+                        if line.strip() and line.strip() != "-":
+                            impact_descriptions += f"\u00A0\u00A0\u00A0\u00A0\u00A0\u00A0 • {line}\n"
         return impact_descriptions
 
     def handle_modal_fn(  # type: ignore

firefighter/slack/views/modals/opening/set_details.py

@@ -78,7 +78,7 @@ class SetIncidentDetails(ModalForm[T], Generic[T]):
             submit=self.submit_text[:24],
             close="Close details",
             callback_id=self.callback_id,
-            blocks=self.get_form_class()(initial=details_form_data).slack_blocks(),
+            blocks=self.get_form_class()(initial=details_form_data, open_incident_context=open_incident_context, **kwargs).slack_blocks(),
             private_metadata=json.dumps(
                 open_incident_context, cls=SlackFormJSONEncoder
             ),
@@ -99,7 +99,8 @@ class SetIncidentDetails(ModalForm[T], Generic[T]):
             priority = Priority.objects.get(pk=priority)
 
         slack_form = self.get_form_class()(
-            data={**slack_view_submission_to_dict(body), "priority": priority}
+            data={**slack_view_submission_to_dict(body), "priority": priority},
+            open_incident_context=private_metadata,
         )
         form: T = slack_form.form
         if form.is_valid():

firefighter/slack/views/modals/postmortem.py

@@ -65,14 +65,22 @@ class PostMortemModal(
         )
 
     @staticmethod
-    def handle_modal_fn(ack: Ack, incident: Incident) -> None:  # type: ignore[override]
+    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
-        ack()
+
+        # 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)
 
 

firefighter/slack/views/modals/update_status.py

@@ -7,9 +7,11 @@ from django.conf import settings
 from slack_sdk.models.blocks.blocks import SectionBlock
 from slack_sdk.models.views import View
 
+from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.forms.update_status import UpdateStatusForm
 from firefighter.slack.slack_templating import slack_block_footer, slack_block_separator
 from firefighter.slack.views.modals.base_modal.base import ModalForm
+from firefighter.slack.views.modals.utils import handle_update_status_close_request
 
 if TYPE_CHECKING:
     from slack_bolt.context.ack.ack import Ack
@@ -51,7 +53,7 @@ class UpdateStatusFormSlack(UpdateStatusForm):
                 "label_from_instance": priority_label,
             },
         },
-        "component": {
+        "incident_category": {
             "input": {
                 "placeholder": "Select affected issue category",
             }
@@ -73,8 +75,9 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
             initial={
                 "status": incident.status,
                 "priority": incident.priority,
-                "component": incident.component,
-            }
+                "incident_category": incident.incident_category,
+            },
+            incident=incident,
         ).slack_blocks()
         blocks.append(slack_block_separator())
         blocks.append(slack_block_footer())
@@ -97,8 +100,9 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
                 "initial": {
                     "status": incident.status,
                     "priority": incident.priority,
-                    "component": incident.component,
-                }
+                    "incident_category": incident.incident_category,
+                },
+                "incident": incident,
             },
         )
         if slack_form is None:
@@ -107,9 +111,31 @@ class UpdateStatusModal(ModalForm[UpdateStatusFormSlack]):
         if len(form.cleaned_data) == 0:
             # XXX We should have a prompt for empty forms
             return
+
+        # Check if user is trying to close and needs a closure reason
+        if "status" in form.changed_data:
+            target_status = form.cleaned_data["status"]
+            if handle_update_status_close_request(ack, body, incident, target_status):
+                return
+
+            # If trying to close, validate that incident can be closed
+            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])
+                    ack(
+                        response_action="errors",
+                        errors={
+                            "status": f"Cannot close this incident:\n{error_text}"
+                        }
+                    )
+                    return
+
         update_kwargs: dict[str, Any] = {}
         for changed_key in form.changed_data:
-            if changed_key in {"component", "priority"}:
+            if changed_key in {"incident_category", "priority"}:
                 update_kwargs[f"{changed_key}_id"] = form.cleaned_data[changed_key].id
             if changed_key in {"description", "title", "message", "status"}:
                 update_kwargs[changed_key] = form.cleaned_data[changed_key]

firefighter/slack/views/modals/utils.py

@@ -0,0 +1,51 @@
+"""Utilities for modal handling to avoid circular imports."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.forms.update_status import UpdateStatusForm
+from firefighter.slack.views.modals.closure_reason import modal_closure_reason
+
+if TYPE_CHECKING:
+    from slack_sdk.models.views import View
+
+    from firefighter.incidents.models.incident import Incident
+
+
+def get_close_modal_view(body: dict[str, Any], incident: Incident, **kwargs: Any) -> View | None:
+    """Get the appropriate modal view for closing an incident.
+
+    This function determines whether to show the closure reason modal
+    or delegate to the normal close modal.
+    """
+    # Check if closure reason is required
+    if UpdateStatusForm.requires_closure_reason(incident, IncidentStatus.CLOSED):
+        return modal_closure_reason.build_modal_fn(body, incident, **kwargs)
+
+    # Return None to indicate normal close modal should be used
+    return None
+
+
+def handle_close_modal_callback(ack: Any, body: dict[str, Any], incident: Incident, user: Any) -> bool | None:
+    """Handle modal callback, delegating to closure reason modal if needed."""
+    # Check if this is a closure reason modal callback
+    if body.get("view", {}).get("callback_id") == "incident_closure_reason":
+        return modal_closure_reason.handle_modal_fn(ack, body, incident, user)
+
+    # Return None to indicate normal handling should continue
+    return None
+
+
+def handle_update_status_close_request(ack: Any, body: dict[str, Any], incident: Incident, target_status: IncidentStatus) -> bool:
+    """Handle update status request to close incident, showing reason modal if needed.
+
+    Returns True if the request was handled (reason modal shown), False otherwise.
+    """
+    if (target_status == IncidentStatus.CLOSED and
+        UpdateStatusForm.requires_closure_reason(incident, target_status)):
+        # Show closure reason modal instead
+        ack(response_action="push", view=modal_closure_reason.build_modal_fn(body, incident))
+        return True
+
+    return False