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

firefighter/slack/signals/create_incident_conversation.py

@@ -45,7 +45,12 @@ def create_incident_slack_conversation(
     Args:
         incident (Incident): The incident to open. It should be saved before calling this function, and have its first incident update created.
 
+    Kwargs:
+        jira_extra_fields (dict): Optional dictionary of customer/seller fields for Jira ticket
+
     """
+    # Extract jira_extra_fields from kwargs
+    jira_extra_fields = _kwargs.get("jira_extra_fields", {})
     channel: IncidentChannel | None = IncidentChannel.objects.create_incident_channel(
         incident=incident
     )
@@ -131,5 +136,6 @@ def create_incident_slack_conversation(
         sender=__name__,
         incident=incident,
         channel=channel,
+        jira_extra_fields=jira_extra_fields,
     )
     return None

firefighter/slack/signals/get_users.py

@@ -26,8 +26,8 @@ logger = logging.getLogger(__name__)
 def get_invites_from_slack(incident: Incident, **_kwargs: Any) -> Iterable[User]:
     """New version using cached users instead of querying Slack API."""
     # Prepare sub-queries
-    slack_usergroups: QuerySet[UserGroup] = incident.component.usergroups.all()
-    slack_conversations: QuerySet[Conversation] = incident.component.conversations.all()
+    slack_usergroups: QuerySet[UserGroup] = incident.incident_category.usergroups.all()
+    slack_conversations: QuerySet[Conversation] = incident.incident_category.conversations.all()
 
     # We make sure to exclude the bot user, and avoid duplicates with distinct()
     # Also make sure that all users have related SlackUser and a slack_id

firefighter/slack/signals/incident_updated.py

@@ -44,7 +44,7 @@ def incident_updated_update_status_handler(
     # Update topic if needed
     if (
         "priority_id" in updated_fields
-        or "component_id" in updated_fields
+        or "incident_category_id" in updated_fields
         or "_status" in updated_fields
     ):
         incident.conversation.set_incident_channel_topic()
@@ -159,6 +159,11 @@ def incident_key_events_updated_handler(
     **kwargs: Any,
 ) -> None:
     logger.info("Received incident_key_events_updated signal")
+    # Skip key events for incidents closed directly
+    if incident.closure_reason:
+        logger.info(f"Skipping key events update for incident {incident.id} (direct closure)")
+        return
+
     # Everything in Slack views trigger the Slack handshake, so we delay the import
     from firefighter.slack.views.modals.key_event_message import (  # noqa: PLC0415
         SlackMessageKeyEvents,
@@ -196,7 +201,8 @@ def publish_status_update(
     if (
         incident.ask_for_milestones
         and status_changed
-        and incident.status >= IncidentStatus.FIXED
+        and incident.status >= IncidentStatus.MITIGATED
+        and not incident.closure_reason  # Don't show key events for direct closures
     ):
         from firefighter.slack.views.modals.key_event_message import (  # noqa: PLC0415
             SlackMessageKeyEvents,

firefighter/slack/utils.py

@@ -97,9 +97,9 @@ def channel_name_from_incident(incident: Incident) -> str:
         )
     date_formatted = localtime(incident.created_at).strftime("%Y%m%d")
     if incident.environment is not None and incident.environment.value != "PRD":
-        topic = f"{date_formatted}-{str(incident.id)[:8]}-{incident.environment.value}-{incident.component.name}"
+        topic = f"{date_formatted}-{str(incident.id)[:8]}-{incident.environment.value}-{incident.incident_category.name}"
     else:
-        topic = f"{date_formatted}-{str(incident.id)[:8]}-{incident.component.name}"
+        topic = f"{date_formatted}-{str(incident.id)[:8]}-{incident.incident_category.name}"
 
     # Strip non-alphanumeric characters, cut at 80 chars
     # XXX django.utils.text.slugify should be used instead

firefighter/slack/views/events/home.py

@@ -57,7 +57,7 @@ def update_home_tab(
         Incident.objects.filter(_status__lt=IncidentStatus.CLOSED.value)
         .order_by("-id")
         .select_related(
-            "priority", "component", "environment", "component__group", "conversation"
+            "priority", "incident_category", "environment", "incident_category__group", "conversation"
         )[:30]
     )
     blocks: list[Block] = [
@@ -148,7 +148,7 @@ def _home_incident_element(
                     text=f":rotating_light: *Priority:* {incident.priority.emoji} {incident.priority.name}"
                 ),
                 MarkdownTextObject(
-                    text=f":package: *Issue category:* {incident.component.group.name} - {incident.component.name}"
+                    text=f":package: *Incident category:* {incident.incident_category.group.name} - {incident.incident_category.name}"
                 ),
                 MarkdownTextObject(
                     text=f":speaking_head_in_silhouette: *Last update:* {date_time(incident.updated_at)}"

firefighter/slack/views/modals/__init__.py

@@ -3,6 +3,10 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from firefighter.slack.views.modals.close import CloseModal, modal_close
+from firefighter.slack.views.modals.closure_reason import (
+    ClosureReasonModal,
+    modal_closure_reason,
+)
 from firefighter.slack.views.modals.downgrade_workflow import (
     DowngradeWorkflowModal,
     modal_dowgrade_workflow,

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)
@@ -336,10 +341,65 @@ class SlackForm(Generic[T]):
         ):
             slack_input_kwargs["options"].append(slack_input_kwargs["initial_option"])
 
+        # 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__")
+            ]
+
         field_name = f"{field_name}___{f.initial}{datetime.now().timestamp()}"  # noqa: DTZ005
         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,
@@ -401,6 +461,15 @@ class SlackForm(Generic[T]):
                     OptionGroup(label=str(group_name), options=subgroup)
                 )
 
+        # Ensure we have at least one option group for Slack API
+        if not slack_input_kwargs["option_groups"]:
+            slack_input_kwargs["option_groups"] = [
+                OptionGroup(
+                    label="No options available",
+                    options=[SafeOption(label="Please select an option", value="__placeholder__")]
+                )
+            ]
+
         return SelectElement(action_id=field_name, **slack_input_kwargs)
 
     @classmethod
@@ -512,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)}
         )
@@ -229,8 +242,8 @@ class CloseModal(
         # If fields haven't changed, don't include them in the update.
         update_kwargs = {}
         for changed_key in form.changed_data:
-            if changed_key == "component":
-                update_kwargs["component_id"] = form.cleaned_data[changed_key].id
+            if changed_key == "incident_category":
+                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
@@ -258,7 +271,7 @@ class CloseModal(
         return {
             "title": incident.title,
             "description": incident.description,
-            "component": incident.component,
+            "incident_category": incident.incident_category,
         }
 
     @staticmethod

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,7 +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": OpeningUnifiedModal,  # Will be overridden by RAID app
         },
     },
 }
@@ -224,6 +230,20 @@ class OpenModal(SlackModal):
     ) -> list[Block]:
         if details_form_modal_class is None:
             return []
+
+        # Check if we need incident type selection and if it's been done
+        response_type = open_incident_context.get("response_type")
+        incident_type_value = open_incident_context.get("incident_type")
+
+        # If there are multiple incident types and none is selected, don't show details button yet
+        if (
+            response_type
+            and response_type in INCIDENT_TYPES
+            and len(INCIDENT_TYPES[response_type]) > 1
+            and incident_type_value is None
+        ):
+            return []
+
         return [
             SectionBlock(
                 text=f"{'✅' if details_form_done else '📝'} Finally, add incident details",
@@ -290,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:
@@ -347,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 (
@@ -361,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
     ]:
@@ -374,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
@@ -510,7 +562,8 @@ class OpenModal(SlackModal):
         """Format a single impact value into description text."""
         # Handle object with name and description attributes (impact levels)
         if hasattr(value, "name") and hasattr(value, "description"):
-            if value.name == "NO" or not value.description:
+            # Filter out "no impact" levels using the value field instead of name
+            if (hasattr(value, "value") and value.value == "NO") or value.name == "NO" or not value.description:
                 return ""
 
             description = ""
@@ -548,6 +601,9 @@ class OpenModal(SlackModal):
             return incident_types[next(iter(incident_types.keys()))].get("slack_form")
         if incident_types and incident_type_value is not None:
             return incident_types[incident_type_value].get("slack_form")
+        # Fallback for "normal" response type when no specific incident type is selected
+        if response_type == "normal" and incident_types:
+            return incident_types[next(iter(incident_types.keys()))].get("slack_form")
         logger.debug(
             f"No incident type found for {open_incident_context}. No fallback."
         )
@@ -574,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()
@@ -583,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!