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

firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.14'
-__version_tuple__ = version_tuple = (0, 0, 14)
+__version__ = version = '0.0.15'
+__version_tuple__ = version_tuple = (0, 0, 15)
 
 __commit_id__ = commit_id = None

firefighter/api/serializers.py

@@ -218,6 +218,7 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
     status = serializers.SerializerMethodField()
     created_by = UserSerializer(read_only=True)
     slack_channel_name = serializers.SerializerMethodField()
+    postmortem_url = serializers.SerializerMethodField()
 
     created_by_email = CreatableSlugRelatedField[User](
         source="created_by",
@@ -252,6 +253,13 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
     def get_slack_channel_name(obj: Incident) -> str:
         return f"#{obj.slack_channel_name}" if obj.slack_channel_name else ""
 
+    @staticmethod
+    def get_postmortem_url(obj: Incident) -> str | None:
+        """Return the Confluence post-mortem page URL if it exists."""
+        if hasattr(obj, "postmortem_for"):
+            return obj.postmortem_for.page_url
+        return None
+
     def create(self, validated_data: dict[str, Any]) -> Incident:
         return Incident.objects.declare(**validated_data)
 
@@ -279,6 +287,7 @@ class IncidentSerializer(TaggitSerializer, serializers.ModelSerializer[Incident]
             "status",
             "slack_channel_name",
             "status_page_url",
+            "postmortem_url",
             "status",
             "environment_id",
             "incident_category_id",

firefighter/confluence/signals/incident_updated.py

@@ -39,7 +39,7 @@ def incident_updated_handler(
         if (
             "_status" in updated_fields
             and incident_update.status
-            in {IncidentStatus.FIXED, IncidentStatus.POST_MORTEM}
+            in {IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM}
             and incident.needs_postmortem
         ):
             if not hasattr(incident, "postmortem_for"):
@@ -48,7 +48,7 @@ def incident_updated_handler(
         elif (
             "_status" in updated_fields
             and incident_update.status
-            in {IncidentStatus.FIXED, IncidentStatus.POST_MORTEM}
+            in {IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM}
             and not incident.needs_postmortem
         ):
             publish_fixed_next_actions(incident)

firefighter/incidents/enums.py

@@ -6,8 +6,8 @@ from django.db import models
 class IncidentStatus(models.IntegerChoices):
     OPEN = 10, "Open"
     INVESTIGATING = 20, "Investigating"
-    FIXING = 30, "Mitigating"
-    FIXED = 40, "Mitigated"
+    MITIGATING = 30, "Mitigating"
+    MITIGATED = 40, "Mitigated"
     POST_MORTEM = 50, "Post-mortem"
     CLOSED = 60, "Closed"
 
@@ -30,3 +30,23 @@ class IncidentStatus(models.IntegerChoices):
     @staticmethod
     def choices_lt(val: int) -> list[tuple[int, str]]:
         return [i for i in IncidentStatus.choices if i[0] < val]
+
+    @staticmethod
+    def choices_lte(val: int) -> list[tuple[int, str]]:
+        return [i for i in IncidentStatus.choices if i[0] <= val]
+
+    @staticmethod
+    def choices_lte_skip_postmortem(val: int) -> list[tuple[int, str]]:
+        """Return choices up to val but excluding POST_MORTEM (for P3+ incidents)."""
+        return [i for i in IncidentStatus.choices if i[0] <= val and i[0] != IncidentStatus.POST_MORTEM]
+
+
+class ClosureReason(models.TextChoices):
+    """Reasons for direct incident closure bypassing normal workflow."""
+
+    RESOLVED = "resolved", "Resolved normally"
+    DUPLICATE = "duplicate", "Duplicate incident"
+    FALSE_POSITIVE = "false_positive", "False alarm - no actual issue"
+    SUPERSEDED = "superseded", "Superseded by another incident"
+    EXTERNAL = "external", "External dependency/known issue"
+    CANCELLED = "cancelled", "Cancelled - no longer relevant"

firefighter/incidents/forms/closure_reason.py

@@ -0,0 +1,45 @@
+"""Form for incident closure with reason when closing from early statuses."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from django import forms
+
+from firefighter.incidents.enums import ClosureReason
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models import Incident
+
+
+class IncidentClosureReasonForm(forms.Form):
+    """Form for closing an incident with a mandatory reason from early statuses."""
+
+    closure_reason = forms.ChoiceField(
+        label="Closure Reason",
+        choices=ClosureReason.choices,
+        required=True,
+        help_text="Select the reason for closing this incident",
+    )
+    closure_reference = forms.CharField(
+        label="Reference (optional)",
+        max_length=100,
+        required=False,
+        help_text="Reference incident ID or external link for context (e.g., #1234 or URL)",
+    )
+    message = forms.CharField(
+        label="Closure Message",
+        widget=forms.Textarea,
+        required=True,
+        help_text="Brief explanation of why this incident is being closed",
+    )
+
+    def __init__(self, *args: Any, incident: Incident | None = None, **kwargs: Any) -> None:  # noqa: ARG002
+        super().__init__(*args, **kwargs)
+
+        # Exclude RESOLVED from choices as it's for normal workflow closure
+        closure_field = self.fields["closure_reason"]
+        if hasattr(closure_field, "choices"):
+            closure_field.choices = [
+                choice for choice in ClosureReason.choices
+                if choice[0] != ClosureReason.RESOLVED
+            ]

firefighter/incidents/forms/unified_incident.py

@@ -0,0 +1,406 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+from typing import cast as typing_cast
+
+from django import forms
+from django.db import models
+
+from firefighter.incidents.forms.create_incident import CreateIncidentFormBase
+from firefighter.incidents.forms.select_impact import SelectImpactForm
+from firefighter.incidents.forms.utils import GroupedModelChoiceField
+from firefighter.incidents.models import Environment, IncidentCategory, Priority
+from firefighter.incidents.models.impact import LevelChoices
+from firefighter.incidents.models.incident import Incident
+from firefighter.incidents.signals import create_incident_conversation
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models.impact import ImpactLevel
+    from firefighter.incidents.models.user import User
+    from firefighter.jira_app.models import JiraUser
+
+logger = logging.getLogger(__name__)
+
+
+class PlatformChoices(models.TextChoices):
+    """Platform choices for incidents."""
+
+    FR = "platform-FR", ":fr: FR"
+    DE = "platform-DE", ":de: DE"
+    IT = "platform-IT", ":it: IT"
+    ES = "platform-ES", ":es: ES"
+    UK = "platform-UK", ":uk: UK"
+    ALL = "platform-All", ":earth_africa: ALL"
+    INTERNAL = "platform-Internal", ":logo-manomano: Internal"
+
+
+def initial_environments() -> list[Environment]:
+    """Get default environments."""
+    return list(Environment.objects.filter(default=True))
+
+
+def initial_priority() -> Priority:
+    """Get default priority."""
+    return Priority.objects.get(default=True)
+
+
+def initial_platform() -> str:
+    """Get default platform."""
+    return PlatformChoices.ALL.value
+
+
+class UnifiedIncidentForm(CreateIncidentFormBase):
+    """Unified form for all incident types and priorities (P1-P5).
+
+    This form dynamically shows/hides fields based on:
+    - Priority/response_type (critical vs normal)
+    - Selected impacts (customer, seller, employee)
+
+    Common fields (always shown):
+    - title, description, incident_category
+    - environment (multiple choice)
+    - platform (multiple choice, default ALL)
+    - priority (hidden)
+
+    Conditional fields:
+    - suggested_team_routing (P4-P5 only)
+    - zendesk_ticket_id (if customer impact selected)
+    - seller_contract_id, is_key_account, etc. (if seller impact selected)
+    """
+
+    # === Common fields (ALL priorities) ===
+    title = forms.CharField(
+        label="Title",
+        max_length=128,
+        min_length=10,
+        widget=forms.TextInput(attrs={"placeholder": "What's going on?"}),
+    )
+
+    description = forms.CharField(
+        label="Summary",
+        widget=forms.Textarea(
+            attrs={
+                "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."
+            }
+        ),
+        min_length=10,
+        max_length=1200,
+    )
+
+    incident_category = GroupedModelChoiceField(
+        choices_groupby="group",
+        label="Incident category",
+        queryset=(
+            IncidentCategory.objects.all()
+            .select_related("group")
+            .order_by(
+                "group__order",
+                "name",
+            )
+        ),
+    )
+
+    environment = forms.ModelMultipleChoiceField(
+        label="Environment",
+        queryset=Environment.objects.all(),
+        initial=initial_environments,
+        required=True,
+    )
+
+    platform = forms.MultipleChoiceField(
+        label="Platform",
+        choices=PlatformChoices.choices,
+        initial=[PlatformChoices.ALL.value],
+        required=True,
+    )
+
+    priority = forms.ModelChoiceField(
+        label="Priority",
+        queryset=Priority.objects.filter(enabled_create=True),
+        initial=initial_priority,
+        widget=forms.HiddenInput(),
+    )
+
+    # === Conditional: Normal incidents only (P4-P5) ===
+    suggested_team_routing: forms.ModelChoiceField[Any] = forms.ModelChoiceField(
+        queryset=None,  # Will be set in __init__
+        label="Feature Team or Train",
+        required=False,  # Conditionally required based on response_type
+    )
+
+    # === Conditional: Customer impact ===
+    zendesk_ticket_id = forms.CharField(
+        label="Zendesk Ticket ID",
+        max_length=128,
+        min_length=2,
+        required=False,
+    )
+
+    # === Conditional: Seller impact ===
+    seller_contract_id = forms.CharField(
+        label="Seller Contract ID",
+        max_length=128,
+        min_length=0,
+        required=False,  # Conditionally required in clean()
+    )
+
+    is_key_account = forms.BooleanField(
+        label="Is it a Key Account?",
+        required=False,
+    )
+
+    is_seller_in_golden_list = forms.BooleanField(
+        label="Is the seller in the Golden List?",
+        required=False,
+    )
+
+    zoho_desk_ticket_id = forms.CharField(
+        label="Zoho Desk Ticket ID",
+        max_length=128,
+        min_length=1,
+        required=False,
+    )
+
+    field_order = [
+        "incident_category",
+        "environment",
+        "platform",
+        "title",
+        "description",
+        "suggested_team_routing",
+        "zendesk_ticket_id",
+        "seller_contract_id",
+        "is_key_account",
+        "is_seller_in_golden_list",
+        "zoho_desk_ticket_id",
+    ]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize form with dynamic queryset for suggested_team_routing."""
+        super().__init__(*args, **kwargs)
+
+        # Set queryset for suggested_team_routing
+        try:
+            from firefighter.raid.models import FeatureTeam  # noqa: PLC0415
+
+            field = typing_cast("forms.ModelChoiceField[Any]", self.fields["suggested_team_routing"])
+            field.queryset = FeatureTeam.objects.only("name").order_by("name")
+        except ImportError:
+            # RAID module not available
+            logger.warning("RAID module not available, suggested_team_routing will not work")
+
+    def get_visible_fields_for_impacts(
+        self, impacts_data: dict[str, ImpactLevel | str], response_type: str
+    ) -> list[str]:
+        """Determine which fields should be visible based on impacts and response type.
+
+        Args:
+            impacts_data: Dictionary of impact type → impact level (ImpactLevel object or UUID string)
+            response_type: "critical" or "normal"
+
+        Returns:
+            List of field names that should be visible
+        """
+        visible_fields = [
+            "title",
+            "description",
+            "incident_category",
+            "environment",
+            "platform",
+            "priority",
+        ]
+
+        # Add suggested_team_routing for normal incidents (P4-P5)
+        if response_type == "normal":
+            visible_fields.append("suggested_team_routing")
+
+        # Check impact selections
+        customer_impact = None
+        seller_impact = None
+
+        for field_name, impact_level in impacts_data.items():
+            if "customers_impact" in field_name:
+                customer_impact = impact_level
+            elif "sellers_impact" in field_name:
+                seller_impact = impact_level
+
+        # Helper to check if impact is not NONE
+        def has_impact(impact: ImpactLevel | str | None) -> bool:
+            if impact is None:
+                return False
+
+            # If it's a UUID string, fetch the ImpactLevel from database
+            if isinstance(impact, str):
+                from firefighter.incidents.models.impact import (  # noqa: PLC0415
+                    ImpactLevel as ImpactLevelModel,
+                )
+
+                try:
+                    impact_obj = ImpactLevelModel.objects.get(id=impact)
+                except ImpactLevelModel.DoesNotExist:
+                    return False
+                else:
+                    return impact_obj.value != LevelChoices.NONE.value
+
+            # Otherwise it's an ImpactLevel object
+            return impact.value != LevelChoices.NONE.value
+
+        # Add customer-specific fields
+        if has_impact(customer_impact):
+            visible_fields.append("zendesk_ticket_id")
+
+        # Add seller-specific fields
+        if has_impact(seller_impact):
+            visible_fields.extend([
+                "seller_contract_id",
+                "is_key_account",
+                "is_seller_in_golden_list",
+                "zoho_desk_ticket_id",
+            ])
+
+        return visible_fields
+
+    def clean(self) -> dict[str, Any]:
+        """Custom validation based on response type and impacts."""
+        cleaned_data = super().clean()
+        if cleaned_data is None:
+            cleaned_data = {}
+
+        # Get response_type from initial data if available
+        initial = self.initial or {}
+        response_type = initial.get("response_type", "critical")
+
+        # Validate suggested_team_routing is required for normal incidents
+        if response_type == "normal" and not cleaned_data.get("suggested_team_routing"):
+            self.add_error(
+                "suggested_team_routing",
+                "Feature Team is required for P4/P5 incidents",
+            )
+
+        return cleaned_data
+
+    def trigger_incident_workflow(
+        self,
+        creator: User,
+        impacts_data: dict[str, ImpactLevel],
+        response_type: str = "critical",
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        """Trigger the appropriate incident workflow based on response type.
+
+        Args:
+            creator: User creating the incident
+            impacts_data: Dictionary of impact data
+            response_type: "critical" or "normal"
+            *args: Additional positional arguments (unused)
+            **kwargs: Additional keyword arguments (unused)
+        """
+        if response_type == "critical":
+            self._trigger_critical_incident_workflow(creator, impacts_data)
+        else:
+            self._trigger_normal_incident_workflow(creator, impacts_data)
+
+    def _trigger_critical_incident_workflow(
+        self,
+        creator: User,
+        impacts_data: dict[str, ImpactLevel],
+    ) -> None:
+        """Create a critical incident (P1-P3) with Slack channel."""
+        # Create incident with first environment only (critical incidents use single env)
+        cleaned_data_copy = self.cleaned_data.copy()
+        logger.info(f"UNIFIED FORM - cleaned_data keys: {list(self.cleaned_data.keys())}")
+        logger.info(f"UNIFIED FORM - cleaned_data values: {self.cleaned_data}")
+
+        environments = cleaned_data_copy.pop("environment", [])
+        platforms = cleaned_data_copy.pop("platform", [])
+
+        # Extract customer/seller fields for Jira ticket (not stored in Incident model)
+        jira_extra_fields = {
+            "suggested_team_routing": cleaned_data_copy.pop("suggested_team_routing", None),
+            "zendesk_ticket_id": cleaned_data_copy.pop("zendesk_ticket_id", None),
+            "seller_contract_id": cleaned_data_copy.pop("seller_contract_id", None),
+            "is_key_account": cleaned_data_copy.pop("is_key_account", None),
+            "is_seller_in_golden_list": cleaned_data_copy.pop("is_seller_in_golden_list", None),
+            "zoho_desk_ticket_id": cleaned_data_copy.pop("zoho_desk_ticket_id", None),
+            # Pass full lists for Jira ticket creation
+            "environments": [env.value for env in environments],  # Convert QuerySet to list of values
+            "platforms": platforms,  # Already a list of strings
+        }
+        logger.info(f"UNIFIED FORM - jira_extra_fields extracted: {jira_extra_fields}")
+
+        # Use first environment
+        if environments:
+            cleaned_data_copy["environment"] = environments[0]
+
+        # Store custom fields in the incident
+        cleaned_data_copy["custom_fields"] = {
+            k: v for k, v in jira_extra_fields.items() if v is not None
+        }
+
+        incident = Incident.objects.declare(created_by=creator, **cleaned_data_copy)
+        impacts_form = SelectImpactForm(impacts_data)
+        impacts_form.save(incident=incident)
+
+        create_incident_conversation.send(
+            "unified_incident_form",
+            incident=incident,
+            jira_extra_fields=jira_extra_fields,
+            impacts_data=impacts_data,  # Pass impacts_data for business_impact computation
+        )
+
+    def _trigger_normal_incident_workflow(
+        self,
+        creator: User,
+        impacts_data: dict[str, ImpactLevel],
+    ) -> None:
+        """Create a normal incident (P4-P5) with Jira ticket only."""
+        from firefighter.raid.client import client as jira_client  # noqa: PLC0415
+        from firefighter.raid.forms import (  # noqa: PLC0415
+            prepare_jira_fields,
+            process_jira_issue,
+        )
+        from firefighter.raid.service import (  # noqa: PLC0415
+            get_jira_user_from_user,
+        )
+
+        jira_user: JiraUser = get_jira_user_from_user(creator)
+
+        # Extract environments and platforms
+        environments_qs = self.cleaned_data.get("environment", [])
+        environments = [env.value for env in environments_qs]  # Convert QuerySet to list of values
+        platforms = self.cleaned_data.get("platform", [])
+
+        # Extract suggested team routing (convert FeatureTeam instance to string)
+        team_routing = self.cleaned_data.get("suggested_team_routing")
+        team_routing_name = team_routing.name if team_routing else None
+
+        # Prepare all Jira fields using the common function
+        # P4-P5 pass all environments (unlike P1-P3 which pass first only)
+        jira_fields = prepare_jira_fields(
+            title=self.cleaned_data["title"],
+            description=self.cleaned_data["description"],
+            priority=self.cleaned_data["priority"].value,
+            reporter=jira_user.id,
+            incident_category=self.cleaned_data["incident_category"].name,
+            environments=environments,  # ✅ P4-P5: pass ALL environments
+            platforms=platforms,
+            impacts_data=impacts_data,
+            optional_fields={
+                "zendesk_ticket_id": self.cleaned_data.get("zendesk_ticket_id", ""),
+                "seller_contract_id": self.cleaned_data.get("seller_contract_id", ""),
+                "zoho_desk_ticket_id": self.cleaned_data.get("zoho_desk_ticket_id", ""),
+                "is_key_account": self.cleaned_data.get("is_key_account"),
+                "is_seller_in_golden_list": self.cleaned_data.get("is_seller_in_golden_list"),
+                "suggested_team_routing": team_routing_name,
+            },
+        )
+
+        # Create Jira issue with all prepared fields
+        issue_data = jira_client.create_issue(**jira_fields)
+
+        # Process the created Jira ticket (create JiraTicket in DB, save impacts, alert Slack)
+        process_jira_issue(
+            issue_data, creator, jira_user=jira_user, impacts_data=impacts_data
+        )

firefighter/incidents/forms/update_status.py

@@ -1,11 +1,16 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any
+
 from django import forms
 
 from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.forms.utils import EnumChoiceField, GroupedModelChoiceField
 from firefighter.incidents.models import IncidentCategory, Priority
 
+if TYPE_CHECKING:
+    from firefighter.incidents.models import Incident
+
 
 class UpdateStatusForm(forms.Form):
     message = forms.CharField(
@@ -18,7 +23,7 @@ class UpdateStatusForm(forms.Form):
     status = EnumChoiceField(
         enum_class=IncidentStatus,
         label="Status",
-        choices=IncidentStatus.choices_lt(IncidentStatus.CLOSED),
+        choices=IncidentStatus.choices_lte(IncidentStatus.CLOSED),
     )
     priority = forms.ModelChoiceField(
         label="Priority",
@@ -34,3 +39,84 @@ class UpdateStatusForm(forms.Form):
             "name",
         ),
     )
+
+    def __init__(self, *args: Any, incident: Incident | None = None, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        # Dynamically adjust status choices based on incident requirements
+        if incident:
+            current_status = incident.status
+
+            # Check if incident requires post-mortem (P1/P2 in PRD)
+            # We check the conditions directly rather than using incident.needs_postmortem
+            # because that property also checks if confluence is installed
+            requires_postmortem = (
+                incident.priority
+                and incident.environment
+                and incident.priority.needs_postmortem
+                and incident.environment.value == "PRD"
+            )
+
+            # Get the status field (we know it's an EnumChoiceField)
+            status_field = self.fields["status"]
+
+            # For incidents requiring post-mortem (P1/P2 in PRD)
+            if requires_postmortem:
+                if current_status == IncidentStatus.OPEN:
+                    # From Opened: can go to INVESTIGATING or CLOSED (with reason)
+                    allowed_statuses = [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+                elif current_status == IncidentStatus.INVESTIGATING:
+                    # From Investigating: can go to MITIGATING or CLOSED (with reason)
+                    allowed_statuses = [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+                elif current_status == IncidentStatus.MITIGATING:
+                    # From Mitigating: can only go to MITIGATED
+                    allowed_statuses = [IncidentStatus.MITIGATED]
+                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+                elif current_status == IncidentStatus.MITIGATED:
+                    # From Mitigated: can only go to POST_MORTEM
+                    allowed_statuses = [IncidentStatus.POST_MORTEM]
+                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+                elif current_status == IncidentStatus.POST_MORTEM:
+                    # From Post-mortem: can only go to CLOSED
+                    allowed_statuses = [IncidentStatus.CLOSED]
+                    status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+                else:
+                    # Default: all statuses up to closed
+                    status_field.choices = IncidentStatus.choices_lte(IncidentStatus.CLOSED)  # type: ignore[attr-defined]
+            # For P3+ incidents (no post-mortem needed)
+            elif current_status == IncidentStatus.OPEN:
+                # From Opened: can go to INVESTIGATING or CLOSED (with reason)
+                allowed_statuses = [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+            elif current_status == IncidentStatus.INVESTIGATING:
+                # From Investigating: can go to MITIGATING or CLOSED (with reason)
+                allowed_statuses = [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+            elif current_status == IncidentStatus.MITIGATING:
+                # From Mitigating: can only go to MITIGATED
+                allowed_statuses = [IncidentStatus.MITIGATED]
+                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+            elif current_status == IncidentStatus.MITIGATED:
+                # From Mitigated: can go to CLOSED (P3+ doesn't need post-mortem)
+                allowed_statuses = [IncidentStatus.CLOSED]
+                status_field.choices = [(s.value, s.label) for s in allowed_statuses]  # type: ignore[attr-defined]
+            else:
+                # Default fallback
+                status_field.choices = IncidentStatus.choices_lte_skip_postmortem(IncidentStatus.CLOSED)  # type: ignore[attr-defined]
+
+    @staticmethod
+    def requires_closure_reason(incident: Incident, target_status: IncidentStatus) -> bool:
+        """Check if closing this incident to the target status requires a closure reason.
+
+        Based on the workflow diagram:
+        - P1/P2 and P3/P4/P5: require reason when closing from Opened or Investigating
+        """
+        if target_status != IncidentStatus.CLOSED:
+            return False
+
+        current_status = incident.status
+
+        # Require reason if closing from Opened or Investigating (for any priority)
+        return current_status.value in {IncidentStatus.OPEN, IncidentStatus.INVESTIGATING}