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

firefighter/slack/views/modals/base_modal/form_utils.py

@@ -26,6 +26,7 @@ from slack_sdk.models.blocks.block_elements import (
     InputInteractiveElement,
     PlainTextInputElement,
     SelectElement,
+    StaticMultiSelectElement,
     UserSelectElement,
 )
 from slack_sdk.models.blocks.blocks import ActionsBlock, Block, InputBlock, SectionBlock
@@ -178,6 +179,10 @@ class SlackForm(Generic[T]):
                 return self._process_slack_model_grouped_choice_field(
                     field_name, f, slack_input_kwargs
                 )
+            case forms.ModelMultipleChoiceField() | forms.MultipleChoiceField():
+                return self._process_slack_multiple_choice_field(
+                    field_name, f, slack_input_kwargs
+                )
             case forms.ModelChoiceField() | forms.ChoiceField() | EnumChoiceField():
                 if (
                     isinstance(f, forms.ModelChoiceField)
@@ -346,6 +351,55 @@ class SlackForm(Generic[T]):
         field_name = field_name[:254]
         return SelectElement(action_id=field_name, **slack_input_kwargs)
 
+    @classmethod
+    def _process_slack_multiple_choice_field(
+        cls,
+        field_name: str,
+        f: forms.ModelMultipleChoiceField | forms.MultipleChoiceField,  # type: ignore[type-arg]
+        slack_input_kwargs: dict[str, Any],
+    ) -> InputInteractiveElement:
+        """Process multiple choice fields (ModelMultipleChoiceField, MultipleChoiceField)."""
+        if not isinstance(f, forms.ModelMultipleChoiceField | forms.MultipleChoiceField):
+            err_msg = f"Field {field_name} is not a ModelMultipleChoiceField or MultipleChoiceField"  # type: ignore[unreachable]
+            raise TypeError(err_msg)
+
+        # Handle initial values (list of objects or values)
+        if f.initial:
+            initial_options: list[SafeOption] = []
+            # f.initial can be a list, queryset, or callable
+            initial_value = f.initial() if callable(f.initial) else f.initial
+
+            if isinstance(f, forms.ModelMultipleChoiceField):
+                # For ModelMultipleChoiceField, initial is a list/queryset of model instances
+                initial_options.extend(SafeOption(
+                            label=f.label_from_instance(obj),
+                            value=str(obj.pk),
+                        ) for obj in initial_value)
+            elif isinstance(f, forms.MultipleChoiceField):
+                # For MultipleChoiceField, initial is a list of choice values
+                for val in initial_value:
+                    choice_label = str(next(c[1] for c in f.choices if c[0] == val))
+                    initial_options.append(
+                        SafeOption(label=choice_label, value=str(val))
+                    )
+
+            if initial_options:
+                slack_input_kwargs["initial_options"] = initial_options
+
+        # Build all options
+        slack_input_kwargs["options"] = [
+            SafeOption(label=str(c[1]), value=str(c[0]))
+            for c in filter(lambda co: co[0] != "", f.choices)
+        ]
+
+        # Ensure we have at least one option for Slack API
+        if not slack_input_kwargs["options"]:
+            slack_input_kwargs["options"] = [
+                SafeOption(label="Please select an option", value="__placeholder__")
+            ]
+
+        return StaticMultiSelectElement(action_id=field_name, **slack_input_kwargs)
+
     @classmethod
     def _process_model_user_field(
         cls,
@@ -527,6 +581,15 @@ def slack_view_submission_to_dict(
             )
         elif input_field.get("type") == "static_select":
             data[action_id_stripped] = get_in(input_field, ["selected_option", "value"])
+        elif input_field.get("type") == "multi_static_select":
+            # Handle multiple selections - return list of values
+            selected_options = input_field.get("selected_options", [])
+            data[action_id_stripped] = [opt.get("value") for opt in selected_options]
+        elif input_field.get("type") == "checkboxes":
+            # Handle checkboxes (BooleanField) - return True if "True" is in selected_options
+            selected_options = input_field.get("selected_options", [])
+            # For BooleanField, we have only one option with value="True"
+            data[action_id_stripped] = any(opt.get("value") == "True" for opt in selected_options)
         elif input_field.get("type") == "users_select":
             user_id = get_in(
                 input_field,

firefighter/slack/views/modals/close.py

@@ -25,6 +25,10 @@ from firefighter.slack.views.modals.base_modal.mixins import (
 )
 from firefighter.slack.views.modals.postmortem import PostMortemModal
 from firefighter.slack.views.modals.update_status import UpdateStatusModal
+from firefighter.slack.views.modals.utils import (
+    get_close_modal_view,
+    handle_close_modal_callback,
+)
 
 if TYPE_CHECKING:
     from slack_bolt.context.ack.ack import Ack
@@ -77,6 +81,11 @@ class CloseModal(
     def build_modal_fn(
         self, body: dict[str, Any], incident: Incident, **kwargs: Any
     ) -> View:
+        # Check if closure reason modal should be shown instead
+        closure_view = get_close_modal_view(body, incident, **kwargs)
+        if closure_view:
+            return closure_view
+
         can_be_closed, reasons = incident.can_be_closed
         if not can_be_closed:
             reason_blocks: list[Block] = []
@@ -142,12 +151,12 @@ class CloseModal(
                 elif reason[0] == "STATUS_NOT_MITIGATED":
                     reason_blocks += [
                         SectionBlock(
-                            text=f":warning: *Status is not _{IncidentStatus.FIXED.label}_* :warning:\n"
+                            text=f":warning: *Status is not _{IncidentStatus.MITIGATED.label}_* :warning:\n"
                         ),
                         ContextBlock(
                             elements=[
                                 MarkdownTextObject(
-                                    text=f"You can only close an incident when its status is _{IncidentStatus.FIXED.label}_ or _{IncidentStatus.POST_MORTEM.label}_. The _{IncidentStatus.POST_MORTEM.label}_ status is not mandatory for this incident."
+                                    text=f"You can only close an incident when its status is _{IncidentStatus.MITIGATED.label}_ or _{IncidentStatus.POST_MORTEM.label}_. The _{IncidentStatus.POST_MORTEM.label}_ status is not mandatory for this incident."
                                 )
                             ]
                         ),
@@ -220,6 +229,10 @@ class CloseModal(
         self, ack: Ack, body: dict[str, Any], incident: Incident, user: User
     ) ->  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)
+        if closure_result is not None:
+            return closure_result
         slack_form = self.handle_form_errors(
             ack, body, forms_kwargs={"initial": self._get_initial_form_values(incident)}
         )

firefighter/slack/views/modals/closure_reason.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from slack_sdk.errors import SlackApiError
+from slack_sdk.models.blocks.basic_components import MarkdownTextObject, Option
+from slack_sdk.models.blocks.block_elements import (
+    PlainTextInputElement,
+    StaticSelectElement,
+)
+from slack_sdk.models.blocks.blocks import (
+    Block,
+    ContextBlock,
+    DividerBlock,
+    InputBlock,
+    SectionBlock,
+)
+from slack_sdk.models.views import View
+
+from firefighter.incidents.enums import ClosureReason, IncidentStatus
+from firefighter.slack.slack_templating import slack_block_footer, slack_block_separator
+from firefighter.slack.utils import respond
+from firefighter.slack.views.modals.base_modal.base import SlackModal
+from firefighter.slack.views.modals.base_modal.mixins import (
+    IncidentSelectableModalMixin,
+)
+
+if TYPE_CHECKING:
+    from slack_bolt.context.ack.ack import Ack
+
+    from firefighter.incidents.models.incident import Incident, User
+
+logger = logging.getLogger(__name__)
+
+
+class ClosureReasonModal(IncidentSelectableModalMixin, SlackModal):
+    """Modal for closing an incident with a mandatory reason from early statuses."""
+
+    open_action: str = "closure_reason_incident"
+    open_shortcut = "closure_reason_incident"
+    callback_id: str = "incident_closure_reason"
+
+    def build_modal_fn(
+        self, body: dict[str, Any], incident: Incident, **kwargs: Any  # noqa: ARG002
+    ) -> View:
+        """Build the closure reason modal."""
+        # Build closure reason options (exclude RESOLVED)
+        closure_options = [
+            Option(
+                value=choice[0],
+                label=choice[1],
+            )
+            for choice in ClosureReason.choices
+            if choice[0] != ClosureReason.RESOLVED
+        ]
+
+        blocks: list[Block] = [
+            SectionBlock(
+                text=f"*Closure Reason Required for Incident #{incident.id}*\n_{incident.title}_"
+            ),
+            ContextBlock(
+                elements=[
+                    MarkdownTextObject(
+                        text=f"⚠️ This incident is currently in *{incident.status.label}* status.\nA closure reason is required to close incidents from this status."
+                    )
+                ]
+            ),
+            DividerBlock(),
+            InputBlock(
+                block_id="closure_reason",
+                label="Closure Reason",
+                element=StaticSelectElement(
+                    action_id="select_closure_reason",
+                    options=closure_options,
+                    placeholder="Select a reason...",
+                ),
+                hint="Why is this incident being closed directly?",
+            ),
+            InputBlock(
+                block_id="closure_reference",
+                label="Reference (optional)",
+                element=PlainTextInputElement(
+                    action_id="input_closure_reference",
+                    placeholder="e.g., #1234 or https://...",
+                    max_length=100,
+                ),
+                hint="Related incident ID or external reference",
+                optional=True,
+            ),
+            InputBlock(
+                block_id="closure_message",
+                label="Closure Message",
+                element=PlainTextInputElement(
+                    action_id="input_closure_message",
+                    multiline=True,
+                    placeholder="Brief explanation of why this incident is being closed...",
+                ),
+                hint="This message will be added to the incident timeline",
+            ),
+            slack_block_separator(),
+            slack_block_footer(),
+        ]
+
+        return View(
+            type="modal",
+            title=f"Close #{incident.id}"[:24],
+            submit="Close Incident",
+            callback_id=self.callback_id,
+            private_metadata=str(incident.id),
+            blocks=blocks,
+        )
+
+    def handle_modal_fn(  # type: ignore[override]
+        self, ack: Ack, body: dict[str, Any], incident: Incident, user: User
+    ) -> bool | None:
+        """Handle the closure reason modal submission."""
+        # 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
+        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", "")
+            or ""
+        )
+        message = state_values["closure_message"]["input_closure_message"]["value"]
+
+        try:
+            # Update incident with closure fields
+            incident.closure_reason = closure_reason
+            incident.closure_reference = closure_reference
+            incident.save(update_fields=["closure_reason", "closure_reference"])
+
+            # Create incident update with closure
+            incident.create_incident_update(
+                created_by=user,
+                status=IncidentStatus.CLOSED,
+                message=message,
+                event_type="closure_reason",
+            )
+
+        except Exception:
+            logger.exception(
+                "Error closing incident #%s with reason", incident.id
+            )
+            respond(
+                body=body,
+                text=f"❌ Failed to close incident #{incident.id}",
+            )
+            return False
+        else:
+            # Send confirmation message
+            try:
+                respond(
+                    body=body,
+                    text=(
+                        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 "")
+                    ),
+                )
+            except SlackApiError as e:
+                if e.response.get("error") == "messages_tab_disabled":
+                    logger.warning(
+                        "Cannot send DM to user %s - messages tab disabled",
+                        user.email,
+                    )
+                else:
+                    # Re-raise for other Slack API errors
+                    raise
+
+            logger.info(
+                "Incident #%s closed with reason by %s: %s",
+                incident.id,
+                user.email,
+                closure_reason,
+            )
+            return True
+
+    def get_select_modal_title(self) -> str:
+        return "Close with Reason"
+
+    def get_select_title(self) -> str:
+        return "Select an incident to close with a specific reason"
+
+
+modal_closure_reason = ClosureReasonModal()

firefighter/slack/views/modals/open.py

@@ -33,7 +33,7 @@ from firefighter.slack.views.modals.base_modal.modal_utils import update_modal
 from firefighter.slack.views.modals.opening.check_current_incidents import (
     CheckCurrentIncidentsModal,
 )
-from firefighter.slack.views.modals.opening.details.critical import OpeningCriticalModal
+from firefighter.slack.views.modals.opening.details.unified import OpeningUnifiedModal
 from firefighter.slack.views.modals.opening.types import OpeningData, ResponseType
 
 if TYPE_CHECKING:
@@ -53,13 +53,13 @@ INCIDENT_TYPES: dict[ResponseType, dict[str, dict[str, Any]]] = {
     "critical": {
         "critical": {
             "label": "Critical",
-            "slack_form": OpeningCriticalModal,
+            "slack_form": OpeningUnifiedModal,
         },
     },
     "normal": {
         "normal": {
             "label": "Normal",
-            "slack_form": OpeningCriticalModal,
+            "slack_form": OpeningUnifiedModal,  # Will be overridden by RAID app
         },
     },
 }
@@ -310,17 +310,34 @@ class OpenModal(SlackModal):
         if open_incident_context.get("response_type") == "critical":
             slack_msg = None
             if details_form_done and details_form_class and details_form:
+                # Create a copy of cleaned_data to avoid modifying the form
+                cleaned_data_copy = details_form.cleaned_data.copy()
+
+                # Extract first environment from QuerySet (UnifiedIncidentForm uses ModelMultipleChoiceField)
+                environments = cleaned_data_copy.pop("environment", [])
+                if environments:
+                    cleaned_data_copy["environment"] = environments[0] if hasattr(environments, "__getitem__") else environments.first()
+
+                # Remove fields that are not part of Incident model
+                cleaned_data_copy.pop("platform", None)
+                cleaned_data_copy.pop("zendesk_ticket_id", None)
+                cleaned_data_copy.pop("seller_contract_id", None)
+                cleaned_data_copy.pop("zoho_desk_ticket_id", None)
+                cleaned_data_copy.pop("is_key_account", None)
+                cleaned_data_copy.pop("is_seller_in_golden_list", None)
+                cleaned_data_copy.pop("suggested_team_routing", None)
+
                 incident = Incident(
                     status=IncidentStatus.OPEN,  # type: ignore
                     created_by=user,
-                    **details_form.cleaned_data,
+                    **cleaned_data_copy,
                 )
                 users_list: set[User] = {*incident.build_invite_list(), user}
                 slack_msg = f"> :slack: A dedicated Slack channel will be created, and around {len(users_list)} responders will be invited to help.\n"
 
             if slack_msg is None:
                 slack_msg = "> :slack: A dedicated Slack channel will be created, and responders will be invited to help.\n"
-            text = "> :jira_new: An associated Jira ticket will also be created."
+            text = slack_msg + "> :jira_new: An associated Jira ticket will also be created."
             if not is_during_office_hours(timezone.now()):
                 text += "\n> :pagerduty: If you need it, you'll be able to escalate the incident to our 24/7 on-call response teams."
         else:
@@ -367,7 +384,9 @@ class OpenModal(SlackModal):
                 details_form_class,
                 details_form,
             ) = self._validate_details_form(
-                details_form_modal_class, open_incident_context["details_form_data"]
+                details_form_modal_class,
+                open_incident_context["details_form_data"],
+                open_incident_context,
             )
 
         return (
@@ -381,6 +400,7 @@ class OpenModal(SlackModal):
     def _validate_details_form(
         details_form_modal_class: type[SetIncidentDetails[Any]] | None,
         details_form_data: dict[str, Any],
+        open_incident_context: OpeningData,
     ) -> tuple[
         bool, type[CreateIncidentFormBase] | None, CreateIncidentFormBase | None
     ]:
@@ -394,7 +414,19 @@ class OpenModal(SlackModal):
         if not details_form_class:
             return False, None, None
 
-        details_form: CreateIncidentFormBase = details_form_class(details_form_data)
+        # Pass impacts_data and response_type to form if it supports them (UnifiedIncidentForm)
+        # Check if __init__ accepts these parameters
+        import inspect  # noqa: PLC0415
+        init_params = inspect.signature(details_form_class.__init__).parameters
+        form_kwargs: dict[str, Any] = {}
+        if "impacts_data" in init_params:
+            form_kwargs["impacts_data"] = open_incident_context.get("impact_form_data") or {}
+        if "response_type" in init_params:
+            form_kwargs["response_type"] = open_incident_context.get("response_type", "critical")
+
+        details_form: CreateIncidentFormBase = details_form_class(
+            details_form_data, **form_kwargs
+        )
         is_valid = details_form.is_valid()
 
         return is_valid, details_form_class, details_form
@@ -598,8 +630,17 @@ class OpenModal(SlackModal):
                 details_form_modal_class.form_class
             )
             if details_form_class:
+                # Pass impacts_data and response_type to form if it supports them (UnifiedIncidentForm)
+                import inspect  # noqa: PLC0415
+                init_params = inspect.signature(details_form_class.__init__).parameters
+                form_kwargs: dict[str, Any] = {}
+                if "impacts_data" in init_params:
+                    form_kwargs["impacts_data"] = data.get("impact_form_data") or {}
+                if "response_type" in init_params:
+                    form_kwargs["response_type"] = data.get("response_type", "critical")
+
                 details_form: CreateIncidentFormBase = details_form_class(
-                    details_form_data_raw
+                    details_form_data_raw, **form_kwargs
                 )
                 details_form.is_valid()
                 ack()
@@ -607,10 +648,16 @@ class OpenModal(SlackModal):
                     if hasattr(details_form, "trigger_incident_workflow") and callable(
                         details_form.trigger_incident_workflow
                     ):
-                        details_form.trigger_incident_workflow(
-                            creator=user,
-                            impacts_data=data.get("impact_form_data") or {},
-                        )
+                        # Pass response_type to trigger_incident_workflow if it accepts it
+                        trigger_params = inspect.signature(details_form.trigger_incident_workflow).parameters
+                        workflow_kwargs: dict[str, Any] = {
+                            "creator": user,
+                            "impacts_data": data.get("impact_form_data") or {},
+                        }
+                        if "response_type" in trigger_params:
+                            workflow_kwargs["response_type"] = data.get("response_type", "critical")
+
+                        details_form.trigger_incident_workflow(**workflow_kwargs)
                 except:  # noqa: E722
                     logger.exception("Error triggering incident workflow")
                     # XXX warn the user via DM!

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()