firefighter-incident 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

firefighter/incidents/templates/pages/incident_detail.html

@@ -102,7 +102,7 @@
       <div class="lg:col-start-8 lg:col-span-5 space-y-6 ">
         {% component "card" card_title="External resources" id="incident-integrations" %}
           {% fill "card_content" %}
-            {% if not incident.conversation and not incident.postmortem_for and pagerduty_incident_set.count == 0 %}
+            {% if not incident.conversation and not has_confluence_pm and not has_jira_pm and not has_jira_ticket and pagerduty_incident_set.count == 0 %}
               <div class="px-4 py-5 sm:px-6 col-span-2">
                 <h4 class="text-center font-medium text-sm text-neutral-500 dark:text-neutral-100">
                   No external resources for this incident.
@@ -144,7 +144,7 @@
                     </div>
                   </li>
                 {% endif %}
-                {% if incident.postmortem_for %}
+                {% if has_confluence_app and incident.postmortem_for %}
                   <li class="py-4 flex items-center">
                     <div class="h-10 w-10 flex shrink-0">
                       <svg xmlns="http://www.w3.org/2000/svg" class="h-8 w-8 m-auto" viewBox="0 0 20 20" fill="currentColor">
@@ -157,6 +157,19 @@
                     </div>
                   </li>
                 {% endif %}
+                {% if has_jira_app and incident.jira_postmortem_for %}
+                  <li class="py-4 flex items-center">
+                    <div class="h-10 w-10 flex shrink-0">
+                      <svg xmlns="http://www.w3.org/2000/svg" class="h-8 w-8 m-auto" viewBox="0 0 20 20" fill="currentColor">
+                        <path fill-rule="evenodd" d="M4 4a2 2 0 012-2h4.586A2 2 0 0112 2.586L15.414 6A2 2 0 0116 7.414V16a2 2 0 01-2 2H6a2 2 0 01-2-2V4zm2 6a1 1 0 011-1h6a1 1 0 110 2H7a1 1 0 01-1-1zm1 3a1 1 0 100 2h6a1 1 0 100-2H7z" clip-rule="evenodd" />
+                      </svg>
+                    </div>
+                    <div class="ml-3">
+                      <p class="text-sm font-medium text-neutral-900 dark:text-neutral-100">Post-mortem</p>
+                      <p class="text-sm text-neutral-500 dark:text-neutral-300"> <a href="{{ incident.jira_postmortem_for.issue_url }}" target="_blank" rel="noopener noreferrer" class="underline" >{{ incident.jira_postmortem_for.jira_issue_key|truncatechars:70 }}</a></p>
+                    </div>
+                  </li>
+                {% endif %}
                 {% if incident.jira_ticket %}
                   <li class="py-4 flex items-center">
                     <div class="h-10 w-10 flex shrink-0">

firefighter/incidents/views/views.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import re
+from contextlib import suppress
 from typing import TYPE_CHECKING, Any, cast
 
 from django.conf import settings
@@ -194,8 +195,35 @@ class IncidentDetailView(CustomDetailView[Incident]):
 
         incident: Incident = context["incident"]
 
+        # Check if external resources exist
+        has_confluence_app = "firefighter.confluence" in settings.INSTALLED_APPS
+        has_jira_app = "firefighter.jira_app" in settings.INSTALLED_APPS
+
+        # Safely check for post-mortem existence
+        # We suppress exceptions because accessing OneToOne relations can fail
+        # in various ways if the related app is not installed or tables don't exist
+        has_confluence_pm = False
+        if has_confluence_app:
+            with suppress(AttributeError, ImportError, LookupError):
+                has_confluence_pm = bool(incident.postmortem_for)
+
+        has_jira_pm = False
+        if has_jira_app:
+            with suppress(AttributeError, ImportError, LookupError):
+                has_jira_pm = bool(incident.jira_postmortem_for)
+
+        has_jira_ticket = False
+        if has_jira_app:
+            with suppress(AttributeError, ImportError, LookupError):
+                has_jira_ticket = bool(incident.jira_ticket)
+
         additional_context = {
             "page_title": f"Incident #{incident.id}",
+            "has_confluence_app": has_confluence_app,
+            "has_jira_app": has_jira_app,
+            "has_confluence_pm": has_confluence_pm,
+            "has_jira_pm": has_jira_pm,
+            "has_jira_ticket": has_jira_ticket,
         }
 
         return {**context, **additional_context}

firefighter/raid/client.py

@@ -126,6 +126,11 @@ class RaidJiraClient(JiraClient):
     def get_projects(self) -> list[Project]:
         return self.jira.projects()
 
+    def update_issue_fields(self, issue_id: str | int, **fields: Any) -> None:
+        """Update Jira issue fields (supports custom fields like customfield_11064)."""
+        issue = self.jira.issue(str(issue_id))
+        issue.update(fields=fields)
+
     @staticmethod
     def add_attachments_to_issue(issue_id: str | int, urls: list[str]) -> None:
         """Add attachments to a Jira issue.

firefighter/raid/serializers.py

@@ -4,14 +4,18 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from django.conf import settings
+from django.core.cache import cache
 from rest_framework import serializers
 
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.models.priority import Priority
 from firefighter.incidents.models.user import User
 from firefighter.jira_app.client import (
     JiraAPIError,
     JiraUserNotFoundError,
     SlackNotificationError,
 )
+from firefighter.jira_app.service_postmortem import jira_postmortem_service
 from firefighter.raid.client import client as jira_client
 from firefighter.raid.forms import (
     alert_slack_comment_ticket,
@@ -19,14 +23,35 @@ from firefighter.raid.forms import (
     alert_slack_update_ticket,
 )
 from firefighter.raid.models import JiraTicket
-from firefighter.raid.utils import get_domain_from_email
+from firefighter.raid.utils import get_domain_from_email, normalize_cache_value
 from firefighter.slack.models.user import SlackUser
 
 if TYPE_CHECKING:
+    from firefighter.incidents.models.incident import Incident
     from firefighter.jira_app.models import JiraUser
 
 
 JIRA_USER_IDS: dict[str, str] = settings.RAID_JIRA_USER_IDS
+JIRA_TO_IMPACT_STATUS_MAP: dict[str, IncidentStatus] = {
+    "Incoming": IncidentStatus.OPEN,
+    "Pending resolution": IncidentStatus.OPEN,
+    "in progress": IncidentStatus.MITIGATING,
+    "Reporter validation": IncidentStatus.MITIGATED,
+    "Closed": IncidentStatus.CLOSED,
+}
+JIRA_TO_IMPACT_PRIORITY_MAP: dict[str, int] = {
+    "1": 1,
+    "2": 2,
+    "3": 3,
+    "4": 4,
+    "5": 5,
+    # Legacy Jira names still supported
+    "Highest": 1,
+    "High": 2,
+    "Medium": 3,
+    "Low": 4,
+    "Lowest": 5,
+}
 
 logger = logging.getLogger(__name__)
 
@@ -138,8 +163,11 @@ class LandbotIssueRequestSerializer(serializers.ModelSerializer[JiraTicket]):
         default="SBI",
     )
     priority = serializers.IntegerField(
-        min_value=1, max_value=5, write_only=True, allow_null=True,
-        help_text="Priority level 1-5 (1=Critical, 2=High, 3=Medium, 4=Low, 5=Lowest)"
+        min_value=1,
+        max_value=5,
+        write_only=True,
+        allow_null=True,
+        help_text="Priority level 1-5 (1=Critical, 2=High, 3=Medium, 4=Low, 5=Lowest)",
     )
     business_impact = serializers.ChoiceField(
         write_only=True, choices=["High", "Medium", "Low"], allow_null=True
@@ -279,34 +307,291 @@ class JiraWebhookUpdateSerializer(serializers.Serializer[Any]):
     )
 
     def create(self, validated_data: dict[str, Any]) -> bool:
-        jira_field_modified = validated_data["changelog"].get("items")[0].get("field")
-        if jira_field_modified in {
-            "Priority",
-            "project",
-            "description",
-            "status",
-        }:
-            jira_ticket_key = validated_data["issue"].get("key")
-            status = alert_slack_update_ticket(
-                jira_ticket_id=validated_data["issue"].get("id"),
-                jira_ticket_key=jira_ticket_key,
-                jira_author_name=validated_data["user"].get("displayName"),
-                jira_field_modified=jira_field_modified,
-                jira_field_from=validated_data["changelog"]
-                .get("items")[0]
-                .get("fromString"),
-                jira_field_to=validated_data["changelog"]
-                .get("items")[0]
-                .get("toString"),
-            )
-            if status is not True:
-                logger.error(
-                    f"Could not alert in Slack for the update/s in the Jira ticket {jira_ticket_key}"
+        changes = validated_data.get("changelog", {}).get("items") or []
+        if not changes:
+            logger.debug("Jira webhook had no changelog items; skipping.")
+            return True
+
+        jira_ticket_key = validated_data["issue"].get("key")
+        incident = (
+            self._get_incident_from_jira_ticket(jira_ticket_key)
+            if jira_ticket_key
+            else None
+        )
+        if incident is None:
+            # No linked incident: still emit Slack alerts for tracked fields (status/priority).
+            for change_item in changes:
+                field = (change_item.get("field") or "").lower()
+                to_val = change_item.get("toString")
+                from_val = change_item.get("fromString")
+                is_status = field == "status"
+                is_priority = (
+                    self._parse_priority_value(to_val) is not None
+                    or self._parse_priority_value(from_val) is not None
                 )
+                if not (is_status or is_priority):
+                    continue
+                if not self._alert_slack_update(
+                    validated_data, jira_ticket_key, change_item
+                ):
+                    raise SlackNotificationError("Could not alert in Slack")
+            return True
+
+        for change_item in changes:
+            if not self._sync_jira_fields_to_incident(
+                validated_data, jira_ticket_key, incident, change_item
+            ):
+                continue
+
+        return True
+
+    @staticmethod
+    def _alert_slack_update(
+        validated_data: dict[str, Any],
+        jira_ticket_key: str | None,
+        change_item: dict[str, Any],
+    ) -> bool:
+        ticket_id = validated_data["issue"].get("id")
+        ticket_key = jira_ticket_key or ""
+        jira_author_name = str(validated_data["user"].get("displayName") or "")
+        jira_field_modified = str(change_item.get("field") or "")
+        jira_field_from = str(change_item.get("fromString") or "")
+        jira_field_to = str(change_item.get("toString") or "")
+
+        if ticket_id is None or ticket_key == "" or jira_field_modified == "":
+            logger.error(
+                "Missing required Jira changelog data: id=%s key=%s field=%s",
+                ticket_id,
+                jira_ticket_key,
+                change_item.get("field"),
+            )
+            return False
+
+        status = alert_slack_update_ticket(
+            jira_ticket_id=int(ticket_id),
+            jira_ticket_key=ticket_key,
+            jira_author_name=jira_author_name,
+            jira_field_modified=jira_field_modified,
+            jira_field_from=jira_field_from,
+            jira_field_to=jira_field_to,
+        )
+        if status is not True:
+            logger.error(
+                "Could not alert in Slack for the update/s in the Jira ticket %s",
+                jira_ticket_key or "unknown",
+            )
+            return False
+        return True
+
+    def _sync_jira_fields_to_incident(
+        self,
+        validated_data: dict[str, Any],
+        jira_ticket_key: str | None,
+        incident: Incident,
+        change_item: dict[str, Any],
+    ) -> bool:
+        field = (change_item.get("field") or "").lower()
+
+        # Loop prevention: skip if this exact change was just sent Impact -> Jira
+        if self._skip_due_to_recent_impact_change(jira_ticket_key, field, change_item):
+            logger.debug(
+                "Skipping Jira→Impact sync for %s on %s due to recent Impact change",
+                field,
+                jira_ticket_key,
+            )
+            return False
+
+        # Detect and apply status/priority updates only
+        if field == "status":
+            if not self._alert_slack_update(
+                validated_data, jira_ticket_key, change_item
+            ):
                 raise SlackNotificationError("Could not alert in Slack")
+            return self._handle_status_update(validated_data, incident, change_item)
+
+        to_val = change_item.get("toString")
+        from_val = change_item.get("fromString")
+        if (
+            self._parse_priority_value(to_val) is not None
+            or self._parse_priority_value(from_val) is not None
+        ):
+            if not self._alert_slack_update(
+                validated_data, jira_ticket_key, change_item
+            ):
+                raise SlackNotificationError("Could not alert in Slack")
+            return self._handle_priority_update(validated_data, incident, change_item)
+
+        return False
 
+    @staticmethod
+    def _get_incident_from_jira_ticket(jira_ticket_key: str) -> Incident | None:
+        try:
+            jira_ticket = JiraTicket.objects.select_related("incident").get(
+                key=jira_ticket_key
+            )
+        except JiraTicket.DoesNotExist:
+            logger.warning(
+                "Received Jira webhook for %s but no JiraTicket found; skipping",
+                jira_ticket_key,
+            )
+            return None
+
+        incident = getattr(jira_ticket, "incident", None)
+        if incident is None:
+            logger.warning(
+                "Jira ticket %s not linked to an incident; skipping sync",
+                jira_ticket_key,
+            )
+            return None
+
+        return incident
+
+    def _handle_status_update(
+        self,
+        _validated_data: dict[str, Any],
+        incident: Incident,
+        change_item: dict[str, Any],
+    ) -> bool:
+        jira_status_to = change_item.get("toString") or ""
+        impact_status = JIRA_TO_IMPACT_STATUS_MAP.get(jira_status_to)
+        if impact_status is None:
+            logger.debug(
+                "Jira status '%s' has no Impact mapping; skipping incident sync",
+                jira_status_to,
+            )
+            return True
+
+        if incident.status == impact_status:
+            logger.debug(
+                "Incident %s already at status %s from Jira webhook; no-op",
+                incident.id,
+                incident.status.label,
+            )
+            return True
+
+        if incident.needs_postmortem and impact_status == IncidentStatus.CLOSED:
+            if not hasattr(incident, "jira_postmortem_for"):
+                logger.warning(
+                    "Skipping Jira→Impact close for incident %s: postmortem is required but no Jira PM linked.",
+                    incident.id,
+                )
+                # Returning True: webhook handled but intentionally skipped due to missing Jira PM link.
+                return True
+            try:
+                is_ready, current_status = jira_postmortem_service.is_postmortem_ready(
+                    incident.jira_postmortem_for
+                )
+                if not is_ready:
+                    logger.warning(
+                        "Skipping Jira→Impact close for incident %s: Jira PM %s not ready (status=%s).",
+                        incident.id,
+                        incident.jira_postmortem_for.jira_issue_key,
+                        current_status,
+                    )
+                    # Returning True: webhook handled but close sync deferred until PM ready.
+                    return True
+            except Exception:
+                logger.exception(
+                    "Failed to verify Jira post-mortem readiness for incident %s; skipping close sync",
+                    incident.id,
+                )
+                # Returning True: webhook handled; failure is logged, no retry desired here.
+                return True
+
+        incident.create_incident_update(
+            created_by=None,
+            status=impact_status,
+            message=f"Status synced from Jira ({jira_status_to})",
+            event_type="jira_status_sync",
+        )
         return True
 
+    def _handle_priority_update(
+        self,
+        _validated_data: dict[str, Any],
+        incident: Incident,
+        change_item: dict[str, Any],
+    ) -> bool:
+        jira_priority_to = change_item.get("toString") or ""
+
+        impact_priority_value = self._parse_priority_value(jira_priority_to)
+
+        if impact_priority_value is None:
+            logger.debug(
+                "Jira priority '%s' has no Impact mapping; skipping incident sync",
+                jira_priority_to,
+            )
+            return True
+        if incident.priority and incident.priority.value == impact_priority_value:
+            logger.debug(
+                "Incident %s already at priority %s from Jira webhook; no-op",
+                incident.id,
+                incident.priority.value,
+            )
+            return True
+
+        try:
+            impact_priority = Priority.objects.get(value=impact_priority_value)
+        except Priority.DoesNotExist:
+            logger.warning(
+                "No Impact priority with value %s; skipping Jira→Impact priority sync",
+                impact_priority_value,
+            )
+            return True
+
+        incident.create_incident_update(
+            created_by=None,
+            priority_id=impact_priority.id,
+            message=f"Priority synced from Jira ({jira_priority_to})",
+            event_type="jira_priority_sync",
+        )
+        return True
+
+    @staticmethod
+    def _skip_due_to_recent_impact_change(
+        jira_ticket_key: str | None, field: str, change_item: dict[str, Any]
+    ) -> bool:
+        if not jira_ticket_key:
+            return False
+        try:
+            jira_ticket = JiraTicket.objects.select_related("incident").get(
+                key=jira_ticket_key
+            )
+        except JiraTicket.DoesNotExist:
+            return False
+
+        incident = getattr(jira_ticket, "incident", None)
+        if not incident:
+            return False
+
+        raw_value = change_item.get("toString")
+        # Normalize value consistently with Impact→Jira writes
+        if field == "status":
+            value_for_cache = raw_value
+        else:
+            parsed = JiraWebhookUpdateSerializer._parse_priority_value(raw_value)
+            value_for_cache = parsed if parsed is not None else raw_value
+
+        cache_key = f"sync:impact_to_jira:{incident.id}:{field}:{normalize_cache_value(value_for_cache)}"
+        if cache.get(cache_key):
+            cache.delete(cache_key)
+            return True
+        return False
+
+    @staticmethod
+    def _parse_priority_value(raw: Any) -> int | None:
+        """Try to extract a priority value (1-5) from Jira changelog strings."""
+        if raw is None:
+            return None
+        try:
+            parsed = int(raw)
+            if 1 <= parsed <= 5:
+                return parsed
+        except (TypeError, ValueError):
+            pass
+
+        return JIRA_TO_IMPACT_PRIORITY_MAP.get(str(raw))
+
     def update(self, instance: Any, validated_data: Any) -> Any:
         raise NotImplementedError