firefighter-incident 0.0.15__tar.gz → 0.0.17__tar.gz

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.15
+Version: 0.0.17
 Summary: Incident Management tool made for Slack using Django
 Project-URL: Repository, https://github.com/ManoManoTech/firefighter-incident
 Project-URL: Documentation, https://manomanotech.github.io/firefighter-incident/latest/

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/_version.py

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

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/incidents/forms/edit.py

@@ -5,8 +5,9 @@ from django import forms
 from firefighter.incidents.models import Environment
 
 
-def initial_environments() -> Environment:
-    return Environment.objects.get(default=True)
+def initial_environments() -> list[Environment]:
+    """Get default environments for the form."""
+    return list(Environment.objects.filter(default=True))
 
 
 class EditMetaForm(forms.Form):
@@ -26,8 +27,9 @@ class EditMetaForm(forms.Form):
         min_length=10,
         max_length=1200,
     )
-    environment = forms.ModelChoiceField(
+    environment = forms.ModelMultipleChoiceField(
         label="Environment",
         queryset=Environment.objects.all(),
         initial=initial_environments,
+        required=True,
     )

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/incidents/forms/unified_incident.py

@@ -287,120 +287,244 @@ class UnifiedIncidentForm(CreateIncidentFormBase):
         response_type: str = "critical",
         *args: Any,
         **kwargs: Any,
-    ) -> None:
-        """Trigger the appropriate incident workflow based on response type.
+    ) -> Incident:
+        """Trigger unified incident workflow for all priorities.
+
+        This unified workflow:
+        1. Always creates an Incident in the database (P1-P5)
+        2. Conditionally creates a Slack channel (P1-P3 only)
+        3. Always creates a Jira ticket linked to the Incident (P1-P5)
 
         Args:
             creator: User creating the incident
             impacts_data: Dictionary of impact data
-            response_type: "critical" or "normal"
+            response_type: "critical" (P1-P3) or "normal" (P4-P5)
             *args: Additional positional arguments (unused)
             **kwargs: Additional keyword arguments (unused)
+
+        Returns:
+            The created Incident object
         """
-        if response_type == "critical":
-            self._trigger_critical_incident_workflow(creator, impacts_data)
-        else:
-            self._trigger_normal_incident_workflow(creator, impacts_data)
+        # Step 1: Always create Incident in database (ALL priorities)
+        incident = self._create_incident(creator)
 
-    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)
+        # Save impacts
+        impacts_form = SelectImpactForm(impacts_data)
+        impacts_form.save(incident=incident)
+
+        # Step 2: Conditionally create Slack channel (P1-P3 only)
+        if self._should_create_slack_channel(response_type):
+            self._create_slack_channel(incident, impacts_data)
+
+        # Step 3: Always create Jira ticket (ALL priorities) - UNIFIED
+        self._create_jira_ticket(incident, creator, impacts_data)
+
+        return incident
+
+    def _should_create_slack_channel(self, response_type: str) -> bool:
+        """Determine if incident needs Slack channel based on priority.
+
+        Args:
+            response_type: "critical" or "normal"
+
+        Returns:
+            True if Slack channel should be created (P1-P3), False otherwise (P4-P5)
+        """
+        return response_type == "critical"
+
+    def _create_incident(self, creator: User) -> Incident:
+        """Create Incident object in database for ALL priorities.
+
+        Args:
+            creator: User creating the incident
+
+        Returns:
+            Created Incident object
+        """
         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}")
 
+        # Extract environments and platforms (not stored directly in Incident model)
         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),
+        # Extract Jira-only fields (not stored in Incident model)
+        # Convert suggested_team_routing to JSON-serializable value (name string)
+        team_routing = cleaned_data_copy.pop("suggested_team_routing", None)
+        team_routing_name = team_routing.name if team_routing else None
+
+        self._jira_extra_fields = {
+            "suggested_team_routing": team_routing_name,  # Store name string, not model instance
             "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
+            "environments": [env.value for env in environments],
+            "platforms": platforms,
         }
-        logger.info(f"UNIFIED FORM - jira_extra_fields extracted: {jira_extra_fields}")
+        logger.info(f"UNIFIED FORM - jira_extra_fields extracted: {self._jira_extra_fields}")
 
-        # Use first environment
+        # Use highest priority environment (lowest order value) for main environment field
         if environments:
-            cleaned_data_copy["environment"] = environments[0]
+            cleaned_data_copy["environment"] = min(environments, key=lambda env: env.order)
 
-        # Store custom fields in the incident
+        # Store custom fields in the incident (including all environments)
         cleaned_data_copy["custom_fields"] = {
-            k: v for k, v in jira_extra_fields.items() if v is not None
+            k: v for k, v in self._jira_extra_fields.items() if v is not None
         }
 
+        # Create Incident in database (ALL priorities)
         incident = Incident.objects.declare(created_by=creator, **cleaned_data_copy)
-        impacts_form = SelectImpactForm(impacts_data)
-        impacts_form.save(incident=incident)
+        logger.info(f"UNIFIED FORM - Incident created: {incident.id}")
+
+        return incident
 
+    def _create_slack_channel(
+        self,
+        incident: Incident,
+        impacts_data: dict[str, ImpactLevel],
+    ) -> None:
+        """Create Slack channel for P1-P3 incidents only.
+
+        Args:
+            incident: The created Incident object
+            impacts_data: Dictionary of impact data
+        """
+        logger.info(f"UNIFIED FORM - Creating Slack channel for incident {incident.id}")
+
+        # Signal to create Slack channel (triggers bookmarks, roles message, etc.)
         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
+            jira_extra_fields=self._jira_extra_fields,
+            impacts_data=impacts_data,
         )
 
-    def _trigger_normal_incident_workflow(
+    def _create_jira_ticket(
         self,
+        incident: Incident,
         creator: User,
         impacts_data: dict[str, ImpactLevel],
     ) -> None:
-        """Create a normal incident (P4-P5) with Jira ticket only."""
+        """Create Jira ticket for ALL priorities - UNIFIED method.
+
+        Args:
+            incident: The created Incident object
+            creator: User creating the incident
+            impacts_data: Dictionary of impact data
+        """
+        from firefighter.incidents.forms.select_impact import (  # noqa: PLC0415
+            SelectImpactForm,
+        )
         from firefighter.raid.client import client as jira_client  # noqa: PLC0415
         from firefighter.raid.forms import (  # noqa: PLC0415
+            alert_slack_new_jira_ticket,
             prepare_jira_fields,
-            process_jira_issue,
+            set_jira_ticket_watchers_raid,
         )
+        from firefighter.raid.models import JiraTicket  # noqa: PLC0415
         from firefighter.raid.service import (  # noqa: PLC0415
             get_jira_user_from_user,
         )
+        from firefighter.slack.messages.slack_messages import (  # noqa: PLC0415
+            SlackMessageIncidentDeclaredAnnouncement,
+        )
+
+        logger.info(f"UNIFIED FORM - Creating Jira ticket for incident {incident.id}")
 
+        # Get Jira 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 environments and platforms from jira_extra_fields
+        environments = self._jira_extra_fields.get("environments", [])
+        platforms = self._jira_extra_fields.get("platforms", [])
 
-        # 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
+        # Build description (enhanced for P1-P3 with Slack channel, simple for P4-P5)
+        if hasattr(incident, "conversation"):
+            # P1-P3: Enhanced description with emoji and formatting
+            description = f"""{incident.description}
+
+🧯 This incident has been created for a critical incident.
+📦 Incident category: {incident.incident_category.name}
+{incident.priority.emoji} Priority: {incident.priority.name}
+"""
+        else:
+            # P4-P5: Simple description
+            description = incident.description
 
-        # Prepare all Jira fields using the common function
-        # P4-P5 pass all environments (unlike P1-P3 which pass first only)
+        # Prepare all Jira fields using common function (UNIFIED for all priorities)
         jira_fields = prepare_jira_fields(
-            title=self.cleaned_data["title"],
-            description=self.cleaned_data["description"],
-            priority=self.cleaned_data["priority"].value,
+            title=incident.title,
+            description=description,
+            priority=incident.priority.value,
             reporter=jira_user.id,
-            incident_category=self.cleaned_data["incident_category"].name,
-            environments=environments,  # ✅ P4-P5: pass ALL environments
+            incident_category=incident.incident_category.name,
+            environments=environments,  # All environments for all priorities
             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,
+                "zendesk_ticket_id": self._jira_extra_fields.get("zendesk_ticket_id", ""),
+                "seller_contract_id": self._jira_extra_fields.get("seller_contract_id", ""),
+                "zoho_desk_ticket_id": self._jira_extra_fields.get("zoho_desk_ticket_id", ""),
+                "is_key_account": self._jira_extra_fields.get("is_key_account"),
+                "is_seller_in_golden_list": self._jira_extra_fields.get("is_seller_in_golden_list"),
+                "suggested_team_routing": self._jira_extra_fields.get("suggested_team_routing"),
             },
         )
 
-        # Create Jira issue with all prepared fields
+        # Create Jira issue via API (UNIFIED)
         issue_data = jira_client.create_issue(**jira_fields)
+        logger.info(f"UNIFIED FORM - Jira issue created: {issue_data.get('key')}")
+
+        # Create JiraTicket in DB, linked to Incident (UNIFIED)
+        jira_ticket = JiraTicket.objects.create(**issue_data, incident=incident)
 
-        # 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
+        # Save impact levels
+        impacts_form = SelectImpactForm(impacts_data)
+        impacts_form.save(incident=jira_ticket)
+
+        # Set up Jira watchers
+        set_jira_ticket_watchers_raid(jira_ticket)
+
+        # Add Jira links to incident and Slack channel (if exists)
+        jira_client.jira.add_simple_link(
+            issue=str(jira_ticket.id),
+            object={
+                "url": incident.status_page_url,
+                "title": f"FireFighter incident #{incident.id}",
+            },
         )
+
+        # Send Slack notifications based on priority
+        # P1-P3 incidents have Slack channels, P4-P5 incidents don't
+        if incident.priority.value <= 3:
+            # P1-P3: Add Jira link to Slack channel (if exists)
+            if hasattr(incident, "conversation"):
+                logger.info(f"UNIFIED FORM - Adding Jira link to Slack channel for incident {incident.id}")
+                jira_client.jira.add_simple_link(
+                    issue=str(jira_ticket.id),
+                    object={
+                        "url": incident.conversation.link,
+                        "title": f"Slack conversation #{incident.conversation.name}",
+                    },
+                )
+
+                # Add Jira bookmark to channel
+                incident.conversation.add_bookmark(
+                    title="Jira ticket",
+                    link=jira_ticket.url,
+                    emoji=":jira_new:",
+                )
+
+                # Send incident announcement in channel
+                incident.conversation.send_message_and_save(
+                    SlackMessageIncidentDeclaredAnnouncement(incident)
+                )
+        else:
+            # P4-P5: Send DM and raid_alert notifications
+            logger.info(f"UNIFIED FORM - Sending Slack alerts for P4-P5 incident {incident.id}")
+            alert_slack_new_jira_ticket(jira_ticket)
+
+        logger.info(f"UNIFIED FORM - Jira ticket creation complete for incident {incident.id}")

firefighter_incident-0.0.17/firefighter/incidents/forms/update_status.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import logging
+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
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateStatusForm(forms.Form):
+    message = forms.CharField(
+        label="Update message",
+        widget=forms.Textarea,
+        min_length=10,
+        max_length=1200,
+        required=False,
+    )
+    status = EnumChoiceField(
+        enum_class=IncidentStatus,
+        label="Status",
+        choices=IncidentStatus.choices_lte(IncidentStatus.CLOSED),
+    )
+    priority = forms.ModelChoiceField(
+        label="Priority",
+        queryset=Priority.objects.filter(enabled_update=True),
+    )
+    incident_category = GroupedModelChoiceField(
+        choices_groupby="group",
+        label="Incident category",
+        queryset=IncidentCategory.objects.all()
+        .select_related("group")
+        .order_by(
+            "group__order",
+            "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:
+            self._set_status_choices(incident)
+
+    def _set_status_choices(self, incident: Incident) -> None:
+        """Set the status field choices based on the incident's current state and requirements."""
+        current_status = incident.status
+        status_field = self.fields["status"]
+
+        # Check if incident requires post-mortem (P1/P2 in PRD)
+        requires_postmortem = bool(
+            incident.priority
+            and incident.environment
+            and incident.priority.needs_postmortem
+            and incident.environment.value == "PRD"
+        )
+
+        allowed_statuses = self._get_allowed_statuses(current_status, requires_postmortem=requires_postmortem)
+
+        # If we got a list of enum values, convert to choices and include current status
+        if allowed_statuses:
+            if current_status not in allowed_statuses:
+                allowed_statuses.insert(0, current_status)
+            # Convert values to strings to match what Slack sends in form submissions
+            choices = [(str(s.value), s.label) for s in allowed_statuses]
+            status_field.choices = choices  # type: ignore[attr-defined]
+            logger.debug(
+                f"Set status choices for incident #{incident.id}: {choices} "
+                f"(current_status={current_status}, requires_postmortem={requires_postmortem})"
+            )
+
+    def _get_allowed_statuses(
+        self, current_status: IncidentStatus, *, requires_postmortem: bool
+    ) -> list[IncidentStatus] | None:
+        """Get allowed status transitions based on current status and postmortem requirement.
+
+        Returns None if choices should be set directly (for default fallback cases).
+        """
+        status_field = self.fields["status"]
+
+        # For incidents requiring post-mortem (P1/P2 in PRD)
+        if requires_postmortem:
+            return self._get_postmortem_allowed_statuses(current_status, status_field)
+
+        # For P3+ incidents (no post-mortem needed)
+        return self._get_no_postmortem_allowed_statuses(current_status, status_field)
+
+    def _get_postmortem_allowed_statuses(
+        self, current_status: IncidentStatus, status_field: Any
+    ) -> list[IncidentStatus] | None:
+        """Get allowed statuses for incidents requiring postmortem."""
+        if current_status == IncidentStatus.OPEN:
+            return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.INVESTIGATING:
+            return [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.MITIGATING:
+            return [IncidentStatus.MITIGATED]
+        if current_status == IncidentStatus.MITIGATED:
+            return [IncidentStatus.POST_MORTEM]
+        if current_status == IncidentStatus.POST_MORTEM:
+            return [IncidentStatus.CLOSED]
+
+        # Default: all statuses up to closed
+        self._set_default_choices(status_field, current_status, IncidentStatus.choices_lte(IncidentStatus.CLOSED))
+        return None
+
+    def _get_no_postmortem_allowed_statuses(
+        self, current_status: IncidentStatus, status_field: Any
+    ) -> list[IncidentStatus] | None:
+        """Get allowed statuses for incidents not requiring postmortem."""
+        if current_status == IncidentStatus.OPEN:
+            return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.INVESTIGATING:
+            return [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]
+        if current_status == IncidentStatus.MITIGATING:
+            return [IncidentStatus.MITIGATED]
+        if current_status == IncidentStatus.MITIGATED:
+            return [IncidentStatus.CLOSED]
+
+        # Default fallback
+        self._set_default_choices(
+            status_field, current_status, IncidentStatus.choices_lte_skip_postmortem(IncidentStatus.CLOSED)
+        )
+        return None
+
+    def _set_default_choices(
+        self, status_field: Any, current_status: IncidentStatus, default_choices: Any
+    ) -> None:
+        """Set status field choices to default, ensuring current status is included."""
+        # Convert default_choices to string keys to match Slack form submissions
+        status_field.choices = [(str(choice[0]), choice[1]) for choice in default_choices]
+        existing_values = {choice[0] for choice in status_field.choices}
+        if str(current_status.value) not in existing_values:
+            # Insert current status at the beginning
+            status_field.choices = [(str(current_status.value), current_status.label), *status_field.choices]
+
+    @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}

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/incidents/forms/utils.py

@@ -77,8 +77,22 @@ class EnumChoiceField(TypedChoiceField):
         self.enum_class = enum_class
         if "choices" not in kwargs:
             kwargs["choices"] = enum_class.choices
+
+        # Customize error messages for better UX
+        if "error_messages" not in kwargs:
+            kwargs["error_messages"] = {}
+        if "invalid_choice" not in kwargs["error_messages"]:
+            kwargs["error_messages"]["invalid_choice"] = (
+                "The selected value is not valid. Please select a value from the dropdown list."
+            )
+
         super().__init__(*args, coerce=self.coerce_func, **kwargs)
 
+    def validate(self, value: Any) -> None:
+        """Log validation for debugging."""
+        logger.debug(f"EnumChoiceField.validate: value={value!r} (type={type(value).__name__}), choices={self.choices}")
+        return super().validate(value)
+
     def to_python(self, value: Any) -> int | str | Any:
         """Return a value from the enum class."""
         if value in self.empty_values:

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/incidents/models/incident.py

@@ -582,6 +582,9 @@ class Incident(models.Model):
     ) -> IncidentUpdate:
         updated_fields: list[str] = []
 
+        # Save old priority BEFORE modifying the incident
+        old_priority = self.priority if priority_id is not None else None
+
         def _update_incident_field(
             incident: Incident, field_name: str, value: Any, updated_fields: list[str]
         ) -> None:
@@ -596,8 +599,6 @@ class Incident(models.Model):
         _update_incident_field(self, "description", description, updated_fields)
         _update_incident_field(self, "environment_id", environment_id, updated_fields)
 
-        old_priority = self.priority if priority_id is not None else None
-
         if updated_fields:
             self.save(update_fields=[*updated_fields, "updated_at"])
 

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/raid/apps.py

@@ -17,7 +17,6 @@ class RaidConfig(AppConfig):
         import firefighter.raid.tasks
         import firefighter.raid.urls
         from firefighter.raid.signals import (
-            incident_created,
             incident_updated,
         )
         from firefighter.slack.views.modals.open import INCIDENT_TYPES

firefighter_incident-0.0.17/firefighter/slack/signals/__init__.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+import django.dispatch
+
+from firefighter.slack.signals.incident_closed import incident_closed_slack
+
+if TYPE_CHECKING:
+    from firefighter.slack.signals import incident_updated
+
+incident_channel_done = django.dispatch.Signal()
+
+__all__ = ["incident_channel_done", "incident_closed_slack", "incident_updated"]
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy import to avoid circular dependencies."""
+    if name == "incident_updated":
+        return importlib.import_module(".incident_updated", package="firefighter.slack.signals")
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)

{firefighter_incident-0.0.15 → firefighter_incident-0.0.17}/firefighter/slack/signals/incident_updated.py

@@ -38,6 +38,11 @@ def incident_updated_update_status_handler(
     updated_fields: list[str],
     **kwargs: Any,
 ) -> None:
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        logger.debug(f"Skipping Slack channel update for incident {incident.id} (no conversation)")
+        return
+
     # Update Slack channel if needed
     incident.conversation.rename_if_needed()
 
@@ -65,7 +70,25 @@ def incident_updated_check_dowmgrade_handler(
     updated_fields: list[str],
     **kwargs: Any,
 ) -> None:
-    if not incident_update.priority or incident_update.priority.value <= 2:
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        return
+
+    # Only show downgrade hint when downgrading from critical (P1/P2/P3) to normal (P4/P5)
+    old_priority: Priority | None = kwargs.get("old_priority")
+
+    # Check if priority was actually changed
+    if not incident_update.priority or "priority_id" not in updated_fields:
+        return
+
+    # New priority must be P4 or P5 (normal incident)
+    new_priority_is_normal = incident_update.priority.value >= 4
+
+    # Old priority must have been P1, P2, or P3 (critical incident)
+    old_priority_was_critical = old_priority is not None and old_priority.value <= 3
+
+    # Only show hint if downgrading from critical to normal
+    if not (new_priority_is_normal and old_priority_was_critical):
         return
 
     try:
@@ -103,6 +126,10 @@ def incident_updated_update_roles_handler(
     updated_fields: list[str],
     **kwargs: Any,
 ) -> None:
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        return
+
     # Publish a message to the conversation
     update_roles_message = SlackMessageIncidentRolesUpdated(
         incident=incident,
@@ -135,6 +162,10 @@ def incident_updated_reinvite_handler(
     updated_fields: list[str],
     **kwargs: Any,
 ) -> None:
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        return
+
     if incident.conversation.type == ConversationType.PRIVATE_CHANNEL:
         return
 
@@ -159,6 +190,12 @@ def incident_key_events_updated_handler(
     **kwargs: Any,
 ) -> None:
     logger.info("Received incident_key_events_updated signal")
+
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        logger.debug(f"Skipping key events update for incident {incident.id} (no conversation)")
+        return
+
     # Skip key events for incidents closed directly
     if incident.closure_reason:
         logger.info(f"Skipping key events update for incident {incident.id} (direct closure)")
@@ -180,6 +217,11 @@ def publish_status_update(
     old_priority: Priority | None = None,
 ) -> None:
     """Publishes an update to the incident status."""
+    # Skip Slack operations for incidents without channels (e.g., P4-P5)
+    if not hasattr(incident, "conversation"):
+        logger.debug(f"Skipping status update publication for incident {incident.id} (no conversation)")
+        return
+
     message = SlackMessageIncidentStatusUpdated(
         incident=incident,
         incident_update=incident_update,