firefighter-incident 0.0.29__py3-none-any.whl → 0.0.31__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.29'
-__version_tuple__ = version_tuple = (0, 0, 29)
+__version__ = version = '0.0.31'
+__version_tuple__ = version_tuple = (0, 0, 31)
 
 __commit_id__ = commit_id = None

firefighter/incidents/forms/update_status.py

@@ -43,9 +43,14 @@ class UpdateStatusForm(forms.Form):
         ),
     )
 
-    def __init__(self, *args: Any, incident: Incident | None = None, **kwargs: Any) -> None:
+    def __init__(
+        self, *args: Any, incident: Incident | None = None, **kwargs: Any
+    ) -> None:
         super().__init__(*args, **kwargs)
 
+        # Store incident for later use in clean()
+        self.incident = incident
+
         # Dynamically adjust status choices based on incident requirements
         if incident:
             self._set_status_choices(incident)
@@ -62,8 +67,9 @@ class UpdateStatusForm(forms.Form):
             and incident.priority.needs_postmortem
             and incident.environment.value == "PRD"
         )
-
-        allowed_statuses = self._get_allowed_statuses(current_status, requires_postmortem=requires_postmortem)
+        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:
@@ -72,10 +78,6 @@ class UpdateStatusForm(forms.Form):
             # 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
@@ -84,19 +86,17 @@ class UpdateStatusForm(forms.Form):
 
         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)
+            return self._get_postmortem_allowed_statuses(current_status)
 
         # For P3+ incidents (no post-mortem needed)
-        return self._get_no_postmortem_allowed_statuses(current_status, status_field)
+        return self._get_no_postmortem_allowed_statuses(current_status)
 
     def _get_postmortem_allowed_statuses(
-        self, current_status: IncidentStatus, status_field: Any
+        self, current_status: IncidentStatus
     ) -> list[IncidentStatus] | None:
-        """Get allowed statuses for incidents requiring postmortem."""
+        """Get allowed statuses for incidents requiring postmortem (P1/P2)."""
         if current_status == IncidentStatus.OPEN:
             return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
         if current_status == IncidentStatus.INVESTIGATING:
@@ -104,18 +104,22 @@ class UpdateStatusForm(forms.Form):
         if current_status == IncidentStatus.MITIGATING:
             return [IncidentStatus.MITIGATED]
         if current_status == IncidentStatus.MITIGATED:
-            return [IncidentStatus.POST_MORTEM]
+            # P1/P2 can: go to POST_MORTEM (required) OR reopen to INVESTIGATING/MITIGATING (with reason)
+            return [
+                IncidentStatus.POST_MORTEM,      # Required next step
+                IncidentStatus.INVESTIGATING,   # Reopen option (with reason)
+                IncidentStatus.MITIGATING,      # Reopen option (with reason)
+            ]
         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))
+        # For any other status, return None to use the default choices
         return None
 
     def _get_no_postmortem_allowed_statuses(
-        self, current_status: IncidentStatus, status_field: Any
+        self, current_status: IncidentStatus
     ) -> list[IncidentStatus] | None:
-        """Get allowed statuses for incidents not requiring postmortem."""
+        """Get allowed statuses for incidents not requiring postmortem (P3/P4/P5)."""
         if current_status == IncidentStatus.OPEN:
             return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
         if current_status == IncidentStatus.INVESTIGATING:
@@ -123,12 +127,14 @@ class UpdateStatusForm(forms.Form):
         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)
-        )
+            # P3/P4/P5 can: go to CLOSED (normal next step) OR reopen to INVESTIGATING/MITIGATING (with reason)
+            return [
+                IncidentStatus.CLOSED,          # Normal next step for P3+
+                IncidentStatus.INVESTIGATING,   # Reopen option (with reason)
+                IncidentStatus.MITIGATING,      # Reopen option (with reason)
+            ]
+
+        # For any other status, return None to use the default choices
         return None
 
     def _set_default_choices(
@@ -136,14 +142,21 @@ class UpdateStatusForm(forms.Form):
     ) -> 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]
+        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]
+            status_field.choices = [
+                (str(current_status.value), current_status.label),
+                *status_field.choices,
+            ]
 
     @staticmethod
-    def requires_closure_reason(incident: Incident, target_status: IncidentStatus) -> bool:
+    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:
@@ -155,4 +168,39 @@ class UpdateStatusForm(forms.Form):
         current_status = incident.status
 
         # Require reason if closing from Opened or Investigating (for any priority)
-        return current_status.value in {IncidentStatus.OPEN, IncidentStatus.INVESTIGATING}
+        return current_status.value in {
+            IncidentStatus.OPEN,
+            IncidentStatus.INVESTIGATING,
+        }
+
+    def clean_message(self) -> str:
+        """Validate message field, ensuring reopening from MITIGATED has sufficient justification."""
+        message = self.cleaned_data.get("message", "").strip()
+
+        # Get the incident and status from form data/initialization
+        incident = getattr(self, "incident", None)
+        status_value = self.data.get("status")  # Use raw form data as cleaned_data may not be ready yet
+
+        if incident and status_value:
+            current_status = incident.status
+
+            # Convert status value to enum if it's a string/number
+            try:
+                if isinstance(status_value, str):
+                    status = IncidentStatus(int(status_value))
+                else:
+                    status = IncidentStatus(status_value)
+            except (ValueError, TypeError):
+                # Invalid status value, let other validation handle it
+                return message
+
+            # If reopening from MITIGATED to earlier phases, require substantial justification
+            if (current_status == IncidentStatus.MITIGATED and
+                status in {IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING} and
+                len(message) < 10):
+                raise forms.ValidationError(
+                    "A detailed justification (minimum 10 characters) is required when reopening "
+                    "an incident from MITIGATED status."
+                )
+
+        return message

firefighter/incidents/views/views.py

@@ -82,7 +82,9 @@ class IncidentStatisticsView(FilterView):
     filterset_class = IncidentFilterSet
     model = Incident
     queryset = (
-        Incident.objects.select_related("priority", "incident_category__group", "environment")
+        Incident.objects.select_related(
+            "priority", "incident_category__group", "environment"
+        )
         .all()
         .order_by("-id")
     )
@@ -123,7 +125,9 @@ class DashboardView(generic.ListView[Incident]):
     )
     queryset = (
         Incident.objects.filter(_status__lt=IncidentStatus.CLOSED)
-        .select_related("priority", "incident_category__group", "environment", "created_by")
+        .select_related(
+            "priority", "incident_category__group", "environment", "created_by"
+        )
         .order_by("_status", "priority__value")
         .annotate(latest_event_ts=Subquery(sub.values("event_ts")))
     )

firefighter/slack/messages/slack_messages.py

@@ -124,7 +124,10 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
                     ),
                 )
             )
-        elif hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+        elif (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
             jira_pm = self.incident.jira_postmortem_for
             blocks.append(
                 SectionBlock(
@@ -138,28 +141,30 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
             )
 
         # Continue with remaining steps
-        blocks.extend([
-            SectionBlock(
-                text=f"3. Submit the key events to {APP_DISPLAY_NAME}",
-                **accessory_kwargs,
-            ),
-            SectionBlock(
-                text="4. Once everything has been submitted, close the incident",
-                accessory=ButtonElement(
-                    text="Close incident",
-                    value=str(self.incident.id),
-                    action_id=CloseModal.open_action,
+        blocks.extend(
+            [
+                SectionBlock(
+                    text=f"3. Submit the key events to {APP_DISPLAY_NAME}",
+                    **accessory_kwargs,
                 ),
-            ),
-            DividerBlock(),
-            ContextBlock(
-                elements=[
-                    MarkdownTextObject(
-                        text=":bulb: Updating the status and creating a post-mortem is crucial for the Platform Operations Report presented during the Tech Weekly."
-                    )
-                ]
-            ),
-        ])
+                SectionBlock(
+                    text="4. Once everything has been submitted, close the incident",
+                    accessory=ButtonElement(
+                        text="Close incident",
+                        value=str(self.incident.id),
+                        action_id=CloseModal.open_action,
+                    ),
+                ),
+                DividerBlock(),
+                ContextBlock(
+                    elements=[
+                        MarkdownTextObject(
+                            text=":bulb: Updating the status and creating a post-mortem is crucial for the Platform Operations Report presented during the Tech Weekly."
+                        )
+                    ]
+                ),
+            ]
+        )
 
         if POSTMORTEM_HELP_URL:
             blocks.insert(
@@ -223,11 +228,7 @@ class SlackMessageIncidentFixedNextActions(SlackMessageSurface):
                 postmortem_text += " on Jira."
 
             blocks.append(
-                ContextBlock(
-                    elements=[
-                        MarkdownTextObject(text=postmortem_text)
-                    ]
-                )
+                ContextBlock(elements=[MarkdownTextObject(text=postmortem_text)])
             )
 
         return blocks
@@ -261,11 +262,17 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         if hasattr(self.incident, "custom_fields") and self.incident.custom_fields:
             custom_fields = self.incident.custom_fields
             if custom_fields.get("zendesk_ticket_id"):
-                fields.append(f":ticket: *Zendesk Ticket:* {custom_fields['zendesk_ticket_id']}")
+                fields.append(
+                    f":ticket: *Zendesk Ticket:* {custom_fields['zendesk_ticket_id']}"
+                )
             if custom_fields.get("seller_contract_id"):
-                fields.append(f":memo: *Seller Contract:* {custom_fields['seller_contract_id']}")
+                fields.append(
+                    f":memo: *Seller Contract:* {custom_fields['seller_contract_id']}"
+                )
             if custom_fields.get("zoho_desk_ticket_id"):
-                fields.append(f":ticket: *Zoho Desk Ticket:* {custom_fields['zoho_desk_ticket_id']}")
+                fields.append(
+                    f":ticket: *Zoho Desk Ticket:* {custom_fields['zoho_desk_ticket_id']}"
+                )
             if custom_fields.get("is_key_account") is True:
                 fields.append(":star: *Key Account*")
             if custom_fields.get("is_seller_in_golden_list") is True:
@@ -296,10 +303,17 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         pm_fields = []
 
         if hasattr(self.incident, "postmortem_for") and self.incident.postmortem_for:
-            pm_fields.append(f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-mortem*>")
+            pm_fields.append(
+                f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-mortem*>"
+            )
 
-        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
-            pm_fields.append(f":jira_new: <{self.incident.jira_postmortem_for.issue_url}|*Jira Post-mortem ({self.incident.jira_postmortem_for.jira_issue_key})*>")
+        if (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
+            pm_fields.append(
+                f":jira_new: <{self.incident.jira_postmortem_for.issue_url}|*Jira Post-mortem ({self.incident.jira_postmortem_for.jira_issue_key})*>"
+            )
 
         if not pm_fields:
             return []
@@ -582,7 +596,8 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                                 value=str(self.incident.id),
                                 action_id=UpdateStatusModal.open_action,
                             )
-                            if self.in_channel and self.incident.status != IncidentStatus.CLOSED
+                            if self.in_channel
+                            and self.incident.status != IncidentStatus.CLOSED
                             else None
                         ),
                     ),
@@ -600,6 +615,32 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                     ]
                 )
             )
+
+        # Add post mortem reminder if incident is back to MITIGATED and a post mortem already exists
+        if (self.incident.status == IncidentStatus.MITIGATED
+            and hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for):
+            jira_pm = self.incident.jira_postmortem_for
+            blocks.extend([
+                DividerBlock(),
+                SectionBlock(
+                    text=(
+                        f":memo: *Reminder:* This incident already has an existing post mortem:\n"
+                        f"• Jira: <{jira_pm.issue_url}|{jira_pm.jira_issue_key}>\n\n"
+                        f"Please update it with any new findings from this reopening."
+                    )
+                ),
+                SectionBlock(
+                    text="Need guidance on how to fill Post-Mortems in Jira?",
+                    accessory=ButtonElement(
+                        text="Open documentation",
+                        url="https://manomano.atlassian.net/wiki/spaces/TC/pages/5639635000/How+to+fill+Post-Mortems+in+Jira",
+                        value="jira_postmortem_documentation",
+                        action_id="open_link",
+                    ),
+                )
+            ])
+
         return blocks
 
     def get_metadata(self) -> Metadata:
@@ -636,16 +677,12 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
 
         # Add Confluence link if available
         if hasattr(self.incident, "postmortem_for"):
-            parts.append(
-                f"• Confluence: {self.incident.postmortem_for.page_url}"
-            )
+            parts.append(f"• Confluence: {self.incident.postmortem_for.page_url}")
 
         # Add Jira link if available
         if hasattr(self.incident, "jira_postmortem_for"):
             jira_pm = self.incident.jira_postmortem_for
-            parts.append(
-                f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})"
-            )
+            parts.append(f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})")
 
         return "\n".join(parts)
 
@@ -653,7 +690,10 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
         blocks: list[Block] = [SectionBlock(text=self.get_text())]
 
         # Add documentation link if Jira post-mortem exists
-        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+        if (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
             blocks.append(
                 SectionBlock(
                     text="Need guidance on how to fill Post-Mortems in Jira? See our documentation",
@@ -707,7 +747,9 @@ class SlackMessageIncidentPostMortemCreatedAnnouncement(SlackMessageSurface):
             SectionBlock(
                 text=f"📔 *Post-mortem created for incident #{self.incident.id}*"
             ),
-            SectionBlock(text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*"),
+            SectionBlock(
+                text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*"
+            ),
             DividerBlock(),
             SectionBlock(fields=fields),
         ]
@@ -770,17 +812,19 @@ class SlackMessagePostMortemReminder5Days(SlackMessageSurface):
             blocks.append(ActionsBlock(elements=pm_links))
 
         # Add action buttons
-        blocks.extend([
-            DividerBlock(),
-            SectionBlock(
-                text="Update the incident status or close it once the post-mortem is complete.",
-                accessory=ButtonElement(
-                    text="Update status",
-                    value=str(self.incident.id),
-                    action_id=UpdateStatusModal.open_action,
+        blocks.extend(
+            [
+                DividerBlock(),
+                SectionBlock(
+                    text="Update the incident status or close it once the post-mortem is complete.",
+                    accessory=ButtonElement(
+                        text="Update status",
+                        value=str(self.incident.id),
+                        action_id=UpdateStatusModal.open_action,
+                    ),
                 ),
-            ),
-        ])
+            ]
+        )
 
         return blocks
 

{firefighter_incident-0.0.29.dist-info → firefighter_incident-0.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.29
+Version: 0.0.31
 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.29.dist-info → firefighter_incident-0.0.31.dist-info}/RECORD

@@ -6,7 +6,7 @@ gunicorn.conf.py,sha256=vHsTGjaKOr8FDMp6fTKYTX4AtokmPgYvvt5Mr0Q6APc,273
 main.py,sha256=CsbprHoOYhjCLpTJmq9Z_aRYFoFgWxoz2pDLuwm8Eqg,1558
 manage.py,sha256=5ivHGD13C6nJ8QvltKsJ9T9akA5he8da70HLWaEP3k8,689
 firefighter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-firefighter/_version.py,sha256=p4kcB0BmpcnphBIseH7188jNCCOqFZSly7Pka9LrUDM,706
+firefighter/_version.py,sha256=nmSHmaFWTuD8SY4lecbyWq4JEPaihzn-zXy2K9lJGYo,706
 firefighter/api/__init__.py,sha256=JQW0Bv6xwGqy7ioxx3h6UGMzkkJ4DntDpbvV1Ncgi8k,136
 firefighter/api/admin.py,sha256=x9Ysy-GiYjb0rynmFdS9g56e6n24fkN0ouGy5QD9Yrc,4629
 firefighter/api/apps.py,sha256=P5uU1_gMrDfzurdMbfqw1Bnb2uNKKcMq17WBPg2sLhc,204
@@ -145,7 +145,7 @@ firefighter/incidents/forms/select_impact.py,sha256=pH7neqP3d4Bxol4FuizD0Zcp6OP5
 firefighter/incidents/forms/unified_incident.py,sha256=3xDB3IFJVwrRe9C_G52SjQ9-Xeqe1ivAGb0e8xtXJaY,19564
 firefighter/incidents/forms/update_key_events.py,sha256=1Xmnxe5OgZqLFS2HmMzQm3VGFPQipsdrLgKSwdh-fKc,4441
 firefighter/incidents/forms/update_roles.py,sha256=Q26UPfwAj-8N23RNZLQkvmHGnS1_j_X5KQWjJmPjMKY,3635
-firefighter/incidents/forms/update_status.py,sha256=7GSno_EqD2Brd6wWcSb3zsP6nz8_mUTXXnl0QCRhv48,6682
+firefighter/incidents/forms/update_status.py,sha256=j9kGPaDECTrsZogBlgP5MbZdpDIkq3x6aS4cllq0quU,8529
 firefighter/incidents/forms/utils.py,sha256=15e_dBebVd9SvX03DYd0FyZ8s0YpxyBlZfIzEZattwg,4267
 firefighter/incidents/management/__init__.py,sha256=A2LtnedT5NvTcNAN5nXMkPwK56JBNLuptcyObvq7zcc,40
 firefighter/incidents/management/commands/__init__.py,sha256=wc5DFEklUo-wB-6VAAmsV5UTbo5s3t936Lu61z4lojs,29
@@ -264,7 +264,7 @@ firefighter/incidents/views/date_filter.py,sha256=fUhTjkBulMokI5tAHuqNDVv1dyspjm
 firefighter/incidents/views/date_utils.py,sha256=tiRTlh7PmRv4eAH0asiSX3Gn7ajsal9egm4S1d7s3_s,5759
 firefighter/incidents/views/errors.py,sha256=yDuH0YOdGf-voVNEC51yR9Ie3OU-az7g2EqWs_uV1Kk,7855
 firefighter/incidents/views/reports.py,sha256=1Iegx04w-oHw4cj7u9w2_s7T_e9FH5I6RRPTwDZwZhg,20973
-firefighter/incidents/views/views.py,sha256=Gx1qAYQmN6B60-smnG_Lc_xvzXN2Lrfr6J11wEBCufQ,10987
+firefighter/incidents/views/views.py,sha256=4AR3i9SiC9AnrzZCRIhx147rus4_dXS0IRWsQ8ilkjg,11031
 firefighter/incidents/views/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 firefighter/incidents/views/components/details.py,sha256=gFEezmL1TcVYnM_ryLNNMaynuIdjYV31Qzx_GfzrQiA,1040
 firefighter/incidents/views/components/list.py,sha256=u8HfXetmdL59h_4AZIhiHmKcmrPRZXgekPfnucB4Rek,2207
@@ -364,7 +364,7 @@ firefighter/slack/management/commands/generate_manifest.py,sha256=zFWHAC7ioozcDd
 firefighter/slack/management/commands/switch_test_users.py,sha256=2KTSvCBxsEvZa61J8p0r3huPNhwuytcj2J7IawwZWpQ,11064
 firefighter/slack/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 firefighter/slack/messages/base.py,sha256=biH-YEAaldJ-OLHEs5ZjW-gtUYUbjOqxrAEflqV2XS0,4593
-firefighter/slack/messages/slack_messages.py,sha256=9-zbxBuzDweKQZiwc2DMdiQcsnd23CGCi4YWhGgJx60,43713
+firefighter/slack/messages/slack_messages.py,sha256=y3z54F2RH5--YOab0tv7fp18bICe3wHulRq6JZ5NYmE,45341
 firefighter/slack/migrations/0001_initial_oss.py,sha256=XmTPgq7zCME2xDwzRFoVi4OegSIG9eSKoyTNoW05Qtg,12933
 firefighter/slack/migrations/0002_usergroup_tag.py,sha256=098tmGA81mT-R2uhb6uQfZ7gKiRG9bFhEwQ8rrp4SKM,583
 firefighter/slack/migrations/0003_alter_usergroup_tag.py,sha256=ncH3KUWEPZHlbdcAtOJ0KGt5H6EX-cKspTGU3osrAhE,591
@@ -471,12 +471,13 @@ firefighter_tests/test_incidents/test_forms/conftest.py,sha256=YYF5Lm-Jmt-HM9zt_
 firefighter_tests/test_incidents/test_forms/test_closure_reason.py,sha256=H6RObqazFAit_pvo7N-lotiSsLOYMafZIk23A5Wiodg,3533
 firefighter_tests/test_incidents/test_forms/test_form_select_impact.py,sha256=DTaPGrJi8mXHfh7mhvDTKYVvDCxqarILauE59UDlwqo,3210
 firefighter_tests/test_incidents/test_forms/test_form_utils.py,sha256=tisEDCacCrG5usEyPkFLCZeG9ebp9b9N27dcUtGmYA4,2467
+firefighter_tests/test_incidents/test_forms/test_mitigated_reopening.py,sha256=TkcpY6qVlNh8L-gemSpmOmACYb61qf_Iy3XbbRruYsg,8035
 firefighter_tests/test_incidents/test_forms/test_unified_incident_form.py,sha256=tb2LSn4rtGbYblAdYXthD0UlKL4h-_u-Bj8nqvDVlGM,22701
 firefighter_tests/test_incidents/test_forms/test_unified_incident_form_integration.py,sha256=q7NKYeCgFMpfSj3V3zGWFA4wr3OzC4yEGCU1zB5RRsY,33082
 firefighter_tests/test_incidents/test_forms/test_unified_incident_form_p4_p5.py,sha256=3MUWwvoZiXZFhoDmYzBS-1lPS8tj28ZF_f30dzsFOZY,15937
 firefighter_tests/test_incidents/test_forms/test_update_key_events.py,sha256=rHRGRU9iFXDdMr_kK3pMB7gyeZuMf7Dyq8bRZkddBC4,1644
 firefighter_tests/test_incidents/test_forms/test_update_status_workflow.py,sha256=q0xXU2BbBG8B0uvvyBWlo4HM8ckbcNAP05Fq8oJNtOw,16270
-firefighter_tests/test_incidents/test_forms/test_workflow_transitions.py,sha256=priKh7QYZxGDPu2SvPC8pGnqOsZWg5cLkyC40pDvLAU,7184
+firefighter_tests/test_incidents/test_forms/test_workflow_transitions.py,sha256=4-2IUDRePTsr9cXeN2-sq0wBxN2MjsgJrS3SI-NeR4Y,7298
 firefighter_tests/test_incidents/test_models/test_incident_category.py,sha256=aRoBOhb8fNjLF9CMPZ1FXM8AT51Cd80XPsY2Y3wHY_M,5701
 firefighter_tests/test_incidents/test_models/test_incident_model.py,sha256=AWyWfQYcHNP9GPizIo0wRxNGTJTEJnAwNSd4UmRq-dk,8626
 firefighter_tests/test_incidents/test_models/test_migrations/test_incident_migrations.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -509,6 +510,7 @@ firefighter_tests/test_slack/test_conversation_tags.py,sha256=nNqTZRRBfF6Z4wpFSY
 firefighter_tests/test_slack/test_signals_downgrade.py,sha256=mgl4H5vwr2kImf6g4IZbhv7YEPmMzbYSaVr8E6taL88,5420
 firefighter_tests/test_slack/test_slack_utils.py,sha256=9PLobMNXh3xDyFuwzcQFpKJhe4j__sIgf_WRHIpANJw,3957
 firefighter_tests/test_slack/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+firefighter_tests/test_slack/messages/test_postmortem_reminder.py,sha256=ZMFMankzpgwZFDP-OWAE5c8sHeT_sHhX_2YH-3Y1lcQ,5053
 firefighter_tests/test_slack/messages/test_slack_messages.py,sha256=uyxfeAy1BQxx1zcCzlSJWn5YF1EnH-5Kt2XoIn9dekM,17484
 firefighter_tests/test_slack/test_models/test_conversations.py,sha256=t3ttmgwiu7c-N55iU3XZPmrkEhvkTzJoXszJncy4Bts,793
 firefighter_tests/test_slack/test_models/test_incident_channel.py,sha256=qWoGe9iadmK6-R8usWvjH87AHRkvhG_dHQeC3kHeJrs,17487
@@ -526,8 +528,8 @@ firefighter_tests/test_slack/views/modals/test_send_sos.py,sha256=_rE6jD-gOzcGyh
 firefighter_tests/test_slack/views/modals/test_status.py,sha256=oQzPfwdg2tkbo9nfkO1GfS3WydxqSC6vy1AZjZDKT30,2226
 firefighter_tests/test_slack/views/modals/test_update_status.py,sha256=vbHGx6dkM_0swE1vJ0HrkhI1oJzD_WHZuIQ-_arAxXo,55686
 firefighter_tests/test_slack/views/modals/test_utils.py,sha256=DJd2n9q6fFu8UuCRdiq9U_Cn19MdnC5c-ydLLrk6rkc,5218
-firefighter_incident-0.0.29.dist-info/METADATA,sha256=vMdQRWVVxjc_sHtb6YnFH7Z_iZB0xAwsFPG0inDS6SQ,5570
-firefighter_incident-0.0.29.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-firefighter_incident-0.0.29.dist-info/entry_points.txt,sha256=c13meJbv7YNmYz7MipMOQwzQ5IeFOPXUBYAJ44XMQsM,61
-firefighter_incident-0.0.29.dist-info/licenses/LICENSE,sha256=krRiGp-a9-1nH1bWpBEdxyTKLhjLmn6DMVVoIb0zF90,1087
-firefighter_incident-0.0.29.dist-info/RECORD,,
+firefighter_incident-0.0.31.dist-info/METADATA,sha256=PXaBxOpByn9P2xmf3hHCF7wgTHOVU8GolikIDgNf5QM,5570
+firefighter_incident-0.0.31.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+firefighter_incident-0.0.31.dist-info/entry_points.txt,sha256=c13meJbv7YNmYz7MipMOQwzQ5IeFOPXUBYAJ44XMQsM,61
+firefighter_incident-0.0.31.dist-info/licenses/LICENSE,sha256=krRiGp-a9-1nH1bWpBEdxyTKLhjLmn6DMVVoIb0zF90,1087
+firefighter_incident-0.0.31.dist-info/RECORD,,

firefighter_tests/test_incidents/test_forms/test_mitigated_reopening.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import uuid
+
+import pytest
+from django.test import TestCase
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory
+from firefighter.incidents.forms.update_status import UpdateStatusForm
+from firefighter.incidents.models import Environment, Priority
+
+
+def create_unique_priority(value: int, *, needs_postmortem: bool = False) -> Priority:
+    """Create a Priority with unique constraints handled properly."""
+    return Priority.objects.create(
+        value=value,
+        name=f"Priority-{value}-{uuid.uuid4().hex[:8]}",
+        order=value,
+        needs_postmortem=needs_postmortem,
+        description=f"Test priority {value}"
+    )
+
+
+def create_unique_environment(value: str, *, exact_value: bool = False) -> Environment:
+    """Create an Environment with unique constraints handled properly.
+
+    Args:
+        value: Base value for the environment
+        exact_value: If True, use the value exactly and get_or_create (for testing specific logic)
+    """
+    if exact_value:
+        # For testing specific environment logic, use exact value with get_or_create
+        # This handles the case where fixtures already created an environment with this value
+        unique_suffix = uuid.uuid4().hex[:8]
+        environment, _ = Environment.objects.get_or_create(
+            value=value,  # Exact value needed for logic testing
+            defaults={
+                "name": f"Environment {value} {unique_suffix}",
+                "description": f"Test environment {value} {unique_suffix}"
+            }
+        )
+        return environment
+
+    # Default case: create unique environment
+    unique_suffix = uuid.uuid4().hex[:8]
+    return Environment.objects.create(
+        value=f"{value}-{unique_suffix}",
+        name=f"Environment {value} {unique_suffix}",
+        description=f"Test environment {value} {unique_suffix}"
+    )
+
+
+@pytest.mark.django_db
+class TestMitigatedReopeningWorkflow(TestCase):
+    """Test the new workflow allowing reopening from MITIGATED status."""
+
+    def test_p1_mitigated_allows_reopening_and_postmortem(self):
+        """P1 incidents should be able to go to POST_MORTEM OR reopen to INVESTIGATING/MITIGATING."""
+        # Create P1 priority with needs_postmortem=True
+        priority = create_unique_priority(value=1001, needs_postmortem=True)
+        # IMPORTANT: Use exact "PRD" value for environment since requires_postmortem logic checks for exact match
+        environment = create_unique_environment("PRD", exact_value=True)
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+        form = UpdateStatusForm(incident=incident)
+
+        # Get available statuses
+        status_choices = dict(form.fields["status"].choices)
+        available_statuses = {IncidentStatus(int(k)) for k in status_choices}
+
+        # P1 incidents should have POST_MORTEM (required for P1/P2)
+        assert IncidentStatus.POST_MORTEM in available_statuses
+        # P1 incidents should ALSO have direct reopening options (NEW behavior)
+        assert IncidentStatus.INVESTIGATING in available_statuses
+        assert IncidentStatus.MITIGATING in available_statuses
+
+    def test_can_reopen_from_mitigated_to_mitigating_p3(self):
+        """P3 incidents can return from MITIGATED to MITIGATING."""
+        priority = create_unique_priority(value=3001, needs_postmortem=False)
+        environment = create_unique_environment("STG")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+        form = UpdateStatusForm(incident=incident)
+
+        # Get available statuses
+        status_choices = dict(form.fields["status"].choices)
+        available_statuses = {IncidentStatus(int(k)) for k in status_choices}
+
+        # Should include both return options and CLOSED
+        assert IncidentStatus.INVESTIGATING in available_statuses
+        assert IncidentStatus.MITIGATING in available_statuses
+        assert IncidentStatus.CLOSED in available_statuses
+        # P3 should not include POST_MORTEM
+        assert IncidentStatus.POST_MORTEM not in available_statuses
+
+    def test_form_validation_requires_message_for_reopening(self):
+        """Form validation requires message when reopening from MITIGATED."""
+        priority = create_unique_priority(value=5001, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test without message - should fail
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "",  # Empty message should cause validation error
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is False, f"Form should be invalid but got valid=True, errors={form.errors}"
+        assert "message" in form.errors
+
+    def test_form_validation_requires_minimum_message_length(self):
+        """Form validation requires minimum message length for reopening."""
+        priority = create_unique_priority(value=5002, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test with message too short - should fail
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "short",  # Less than 10 chars
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is False
+        assert "message" in form.errors
+
+    def test_form_validation_accepts_valid_reopening_message(self):
+        """Form validation accepts valid message for reopening."""
+        priority = create_unique_priority(value=5003, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test with valid message - should pass
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "Investigation revealed additional issues requiring further analysis",
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is True
+
+    def test_form_validation_normal_transitions_unaffected(self):
+        """Normal transitions not from MITIGATED should be unaffected."""
+        priority = create_unique_priority(value=5004, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        # Test from INVESTIGATING to MITIGATING (normal flow)
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.INVESTIGATING,
+            priority=priority,
+            environment=environment
+        )
+
+        form_data = {
+            "status": str(IncidentStatus.MITIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "",  # Empty message should be OK for normal transitions
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is True

firefighter_tests/test_incidents/test_forms/test_workflow_transitions.py

@@ -50,7 +50,7 @@ class TestCompleteWorkflowTransitions(TestCase):
             (IncidentStatus.OPEN, [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]),
             (IncidentStatus.INVESTIGATING, [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]),
             (IncidentStatus.MITIGATING, [IncidentStatus.MITIGATED]),
-            (IncidentStatus.MITIGATED, [IncidentStatus.POST_MORTEM]),
+            (IncidentStatus.MITIGATED, [IncidentStatus.POST_MORTEM, IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING]),
             (IncidentStatus.POST_MORTEM, [IncidentStatus.CLOSED]),
         ]
 
@@ -99,7 +99,7 @@ class TestCompleteWorkflowTransitions(TestCase):
             (IncidentStatus.OPEN, [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]),
             (IncidentStatus.INVESTIGATING, [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]),
             (IncidentStatus.MITIGATING, [IncidentStatus.MITIGATED]),
-            (IncidentStatus.MITIGATED, [IncidentStatus.CLOSED]),
+            (IncidentStatus.MITIGATED, [IncidentStatus.CLOSED, IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING]),
         ]
 
         for current_status, expected_statuses in transitions:

firefighter_tests/test_slack/messages/test_postmortem_reminder.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import pytest
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models import IncidentUpdate
+from firefighter.jira_app.models import JiraPostMortem
+from firefighter.slack.factories import IncidentChannelFactory
+from firefighter.slack.messages.slack_messages import SlackMessageIncidentStatusUpdated
+
+
+@pytest.mark.django_db
+class TestSlackMessagePostMortemReminder:
+    """Test post mortem reminder functionality in status update messages."""
+
+    def test_shows_postmortem_reminder_when_returning_to_mitigated_with_existing_postmortem(self):
+        """Test that post mortem reminder is shown when incident returns to MITIGATED and has existing post mortem."""
+        # Create an incident in MITIGATED status
+        incident = IncidentFactory.create(_status=IncidentStatus.MITIGATED)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an existing Jira post mortem
+        jira_postmortem = JiraPostMortem.objects.create(
+            incident=incident,
+            jira_issue_key="INCIDENT-123",
+            jira_issue_id="10001",
+        )
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            _status=IncidentStatus.MITIGATED,
+            created_by=user,
+            message="Incident is back to mitigated after investigation"
+        )
+
+        # Create the message
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=True,
+            status_changed=True,
+        )
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Convert blocks to text for easier searching
+        blocks_text = str(blocks)
+
+        # Should contain the post mortem reminder
+        assert "Reminder" in blocks_text
+        assert "already has an existing post mortem" in blocks_text
+        assert jira_postmortem.jira_issue_key in blocks_text
+        assert jira_postmortem.issue_url in blocks_text
+        assert "Open documentation" in blocks_text
+        assert "https://manomano.atlassian.net/wiki/spaces/TC/pages/5639635000" in blocks_text
+
+    def test_no_postmortem_reminder_when_mitigated_without_existing_postmortem(self):
+        """Test that no post mortem reminder is shown when incident is MITIGATED but has no existing post mortem."""
+        # Create an incident in MITIGATED status (no post mortem)
+        incident = IncidentFactory.create(_status=IncidentStatus.MITIGATED)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            _status=IncidentStatus.MITIGATED,
+            created_by=user
+        )
+
+        # Create the message
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=True,
+            status_changed=True,
+        )
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Convert blocks to text for easier searching
+        blocks_text = str(blocks)
+
+        # Should NOT contain the post mortem reminder
+        assert "Reminder" not in blocks_text
+        assert "already has an existing post mortem" not in blocks_text
+
+    def test_no_postmortem_reminder_when_not_mitigated_with_existing_postmortem(self):
+        """Test that no post mortem reminder is shown when incident has post mortem but is not in MITIGATED status."""
+        # Create an incident in INVESTIGATING status
+        incident = IncidentFactory.create(_status=IncidentStatus.INVESTIGATING)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an existing Jira post mortem
+        JiraPostMortem.objects.create(
+            incident=incident,
+            jira_issue_key="INCIDENT-123",
+            jira_issue_id="10001",
+        )
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            _status=IncidentStatus.INVESTIGATING,
+            created_by=user
+        )
+
+        # Create the message
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=True,
+            status_changed=True,
+        )
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Convert blocks to text for easier searching
+        blocks_text = str(blocks)
+
+        # Should NOT contain the post mortem reminder
+        assert "Reminder" not in blocks_text
+        assert "already has an existing post mortem" not in blocks_text