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

firefighter/slack/admin.py

@@ -81,7 +81,7 @@ class ConversationAdmin(admin.ModelAdmin[Conversation]):
     list_max_show_all = 500
     search_fields = ["channel_id", "name", "tag"]
 
-    autocomplete_fields = ["components", "members"]
+    autocomplete_fields = ["incident_categories", "members"]
 
     def get_queryset(self, request: HttpRequest) -> QuerySet[Conversation]:
         """Restrict the queryset to only include conversations that are not IncidentChannels. Incident channels are managed in the IncidentChannelAdmin."""
@@ -155,7 +155,7 @@ class IncidentChannelAdmin(ConversationAdmin):
     ]
     list_max_show_all = 500
     search_fields = ["channel_id", "name", "incident__id"]
-    exclude = ("components",)
+    exclude = ("incident_categories",)
     readonly_fields = ("members",)
 
     def get_queryset(self, request: HttpRequest) -> QuerySet[IncidentChannel]:
@@ -208,7 +208,7 @@ class UserGroupAdmin(admin.ModelAdmin[UserGroup]):
         "updated_at",
     )
 
-    autocomplete_fields = ["components", "members"]
+    autocomplete_fields = ["incident_categories", "members"]
     search_fields = ["name", "handle", "description", "usergroup_id", "tag"]
 
     fieldsets = (
@@ -226,7 +226,7 @@ class UserGroupAdmin(admin.ModelAdmin[UserGroup]):
                 )
             },
         ),
-        (_("Firefighter attributes"), {"fields": ("tag", "components", "created_at", "updated_at")}),
+        (_("Firefighter attributes"), {"fields": ("tag", "incident_categories", "created_at", "updated_at")}),
     )
 
     def save_model(
@@ -317,7 +317,7 @@ class UserGroupAdmin(admin.ModelAdmin[UserGroup]):
 
 
 class UserGroupInline(admin.StackedInline[UserGroup, Any]):
-    model = UserGroup.components.through  # type: ignore[assignment]
+    model = UserGroup.incident_categories.through  # type: ignore[assignment]
     show_change_link = True
     extra = 0
     verbose_name = "Slack User Group"
@@ -344,7 +344,7 @@ class IncidentChannelInline(admin.StackedInline[IncidentChannel, Any]):
 
 
 class ConversationInline(admin.StackedInline[Conversation, Any]):
-    model: type[Conversation] = Conversation.components.through  # type: ignore[assignment]
+    model: type[Conversation] = Conversation.incident_categories.through  # type: ignore[assignment]
     extra = 0
     verbose_name = "Slack Conversation"
     show_change_link = True
@@ -356,8 +356,8 @@ class ConversationInline(admin.StackedInline[Conversation, Any]):
 
 # Add inlines to incidents models
 firefighter.incidents.admin.user_inlines.append(SlackUserInline)
-firefighter.incidents.admin.component_inlines.append(UserGroupInline)
-firefighter.incidents.admin.component_inlines.append(ConversationInline)
+firefighter.incidents.admin.incident_category_inlines.append(UserGroupInline)
+firefighter.incidents.admin.incident_category_inlines.append(ConversationInline)
 firefighter.incidents.admin.incident_inlines.append(IncidentChannelInline)
 
 # Register Slack models

firefighter/slack/management/commands/switch_test_users.py

@@ -0,0 +1,272 @@
+"""Django management command to switch Slack user IDs for test environment.
+
+This command:
+1. Fetches all users from the test Slack workspace
+2. Generates a mapping file based on email addresses
+3. Updates the database with test Slack user IDs
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+
+from firefighter.incidents.models.user import User
+from firefighter.slack.models.user import SlackUser
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = "Generate and apply Slack user mapping for test environment"
+
+    def add_arguments(self, parser: Any) -> None:
+        parser.add_argument(
+            "--generate-only",
+            action="store_true",
+            help="Only generate the mapping file, don't apply changes",
+        )
+        parser.add_argument(
+            "--mapping-file",
+            type=str,
+            default="slack_test_mapping.json",
+            help="Path to the mapping file (default: slack_test_mapping.json)",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show what would be changed without making actual changes",
+        )
+        parser.add_argument(
+            "--restore",
+            action="store_true",
+            help="Restore original Slack IDs from mapping file",
+        )
+
+    def _raise_mapping_file_not_found(self, mapping_file: Path) -> None:
+        """Raise error when mapping file is not found."""
+        error_msg = f"Mapping file {mapping_file} not found"
+        raise CommandError(error_msg)
+
+    def _raise_slack_token_not_configured(self) -> None:
+        """Raise error when Slack token is not configured."""
+        raise CommandError("SLACK_BOT_TOKEN not configured")
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        """Main command handler."""
+        mapping_file = Path(options["mapping_file"])
+
+        try:
+            if options["restore"]:
+                # Restore original Slack IDs from mapping file
+                if not mapping_file.exists():
+                    self._raise_mapping_file_not_found(mapping_file)
+
+                self.stdout.write("📄 Loading mapping from file...")
+                slack_mapping = self._load_mapping_file(mapping_file)
+
+                self.stdout.write("🔄 Restoring original Slack IDs...")
+                updated_count = self._restore_mapping(slack_mapping, dry_run=options["dry_run"])
+
+                if options["dry_run"]:
+                    self.stdout.write(
+                        self.style.WARNING(f"🔍 DRY RUN: Would restore {updated_count} users")
+                    )
+                else:
+                    self.stdout.write(
+                        self.style.SUCCESS(f"✅ Restored {updated_count} users to original Slack IDs")
+                    )
+                return
+
+            if not settings.SLACK_BOT_TOKEN:
+                self._raise_slack_token_not_configured()
+
+            # Step 1: Generate mapping by querying test Slack workspace
+            self.stdout.write("🔍 Fetching users from test Slack workspace...")
+            slack_mapping = self._generate_slack_mapping()
+
+            # Step 2: Save mapping to file
+            self._save_mapping_file(slack_mapping, mapping_file)
+            self.stdout.write(
+                self.style.SUCCESS(f"✅ Mapping file saved to {mapping_file}")
+            )
+
+            if options["generate_only"]:
+                self.stdout.write("📄 Generation complete. Use --apply to update database.")
+                return
+
+            # Step 3: Apply mapping to database
+            self.stdout.write("📝 Applying mapping to database...")
+            updated_count = self._apply_mapping(slack_mapping, dry_run=options["dry_run"])
+
+            if options["dry_run"]:
+                self.stdout.write(
+                    self.style.WARNING(f"🔍 DRY RUN: Would update {updated_count} users")
+                )
+            else:
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Updated {updated_count} users with test Slack IDs")
+                )
+
+        except SlackApiError as e:
+            error_msg = f"Slack API error: {e.response['error']}"
+            raise CommandError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Error: {e}"
+            raise CommandError(error_msg) from e
+
+    def _generate_slack_mapping(self) -> dict[str, dict[str, Any]]:
+        """Generate mapping by querying test Slack workspace."""
+        client = WebClient(token=settings.SLACK_BOT_TOKEN)
+
+        # Get all users from test Slack workspace
+        try:
+            response = client.users_list()
+            slack_users = response["members"]
+        except SlackApiError as e:
+            error_msg = f"Failed to fetch Slack users: {e.response['error']}"
+            raise CommandError(error_msg) from e
+
+        # Create mapping: email -> test_slack_id
+        slack_email_to_id = {}
+        for slack_user in slack_users:
+            if slack_user.get("deleted") or slack_user.get("is_bot"):
+                continue
+
+            profile = slack_user.get("profile", {})
+            email = profile.get("email")
+            if email:
+                slack_email_to_id[email.lower()] = slack_user["id"]
+
+        self.stdout.write(f"📧 Found {len(slack_email_to_id)} users with emails in test Slack")
+
+        # Get all users from database
+        db_users = User.objects.exclude(email__isnull=True).exclude(email="")
+
+        # Generate mapping for users that exist in both places
+        mapping = {}
+        matched_count = 0
+        not_found_count = 0
+
+        for db_user in db_users:
+            if db_user.email and db_user.email.lower() in slack_email_to_id:
+                test_slack_id = slack_email_to_id[db_user.email.lower()]
+                # Get current slack_id from SlackUser relation
+                current_slack_id = None
+                if hasattr(db_user, "slack_user") and db_user.slack_user:
+                    current_slack_id = db_user.slack_user.slack_id
+
+                mapping[db_user.email] = {
+                    "original_slack_id": current_slack_id,
+                    "test_slack_id": test_slack_id,
+                    "name": f"{db_user.first_name} {db_user.last_name}".strip(),
+                }
+                matched_count += 1
+            else:
+                not_found_count += 1
+
+        self.stdout.write(f"🎯 Matched {matched_count} users between database and test Slack")
+        if not_found_count > 0:
+            self.stdout.write(f"⚠️  {not_found_count} database users not found in test Slack")
+        return mapping
+
+    def _save_mapping_file(self, mapping: dict[str, Any], file_path: Path) -> None:
+        """Save mapping to JSON file."""
+        with file_path.open("w", encoding="utf-8") as f:
+            json.dump(mapping, f, indent=2, ensure_ascii=False)
+
+    def _load_mapping_file(self, file_path: Path) -> dict[str, Any]:
+        """Load mapping from JSON file."""
+        with file_path.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    def _apply_mapping(self, mapping: dict[str, Any], *, dry_run: bool = False) -> int:
+        """Apply the mapping to update database users."""
+        updated_count = 0
+
+        for email, user_data in mapping.items():
+            test_slack_id = user_data["test_slack_id"]
+
+            try:
+                user = User.objects.get(email=email)
+
+                # Get current slack_id from SlackUser relation
+                current_slack_id = None
+                if hasattr(user, "slack_user") and user.slack_user:
+                    current_slack_id = user.slack_user.slack_id
+
+                if current_slack_id == test_slack_id:
+                    continue  # Already has the test ID
+
+                if dry_run:
+                    self.stdout.write(
+                        f"🔄 Would update {email}: {current_slack_id} -> {test_slack_id}"
+                    )
+                elif hasattr(user, "slack_user") and user.slack_user:
+                    user.slack_user.slack_id = test_slack_id
+                    user.slack_user.save(update_fields=["slack_id"])
+                    self.stdout.write(f"✅ Updated {email}: {current_slack_id} -> {test_slack_id}")
+                else:
+                    # Create new SlackUser if it doesn't exist
+                    SlackUser.objects.create(user=user, slack_id=test_slack_id)
+                    self.stdout.write(f"✅ Created SlackUser for {email}: -> {test_slack_id}")
+
+                updated_count += 1
+
+            except User.DoesNotExist:
+                self.stdout.write(f"❌ User not found in database: {email}")
+            except (SlackUser.DoesNotExist, ValueError) as e:
+                self.stdout.write(f"❌ Error updating {email}: {e}")
+
+        return updated_count
+
+    def _restore_mapping(self, mapping: dict[str, Any], *, dry_run: bool = False) -> int:
+        """Restore original Slack IDs from mapping."""
+        updated_count = 0
+
+        for email, user_data in mapping.items():
+            original_slack_id = user_data["original_slack_id"]
+
+            try:
+                user = User.objects.get(email=email)
+
+                # Get current slack_id from SlackUser relation
+                current_slack_id = None
+                if hasattr(user, "slack_user") and user.slack_user:
+                    current_slack_id = user.slack_user.slack_id
+
+                if current_slack_id == original_slack_id:
+                    continue  # Already has the original ID
+
+                if dry_run:
+                    self.stdout.write(
+                        f"🔄 Would restore {email}: {current_slack_id} -> {original_slack_id}"
+                    )
+                elif hasattr(user, "slack_user") and user.slack_user:
+                    if original_slack_id:
+                        user.slack_user.slack_id = original_slack_id
+                        user.slack_user.save(update_fields=["slack_id"])
+                        self.stdout.write(f"✅ Restored {email}: {current_slack_id} -> {original_slack_id}")
+                    else:
+                        # If original was None, delete the SlackUser
+                        user.slack_user.delete()
+                        self.stdout.write(f"✅ Removed SlackUser for {email}: {current_slack_id} -> None")
+                else:
+                    self.stdout.write(f"⚠️  User {email} has no SlackUser to restore")
+                    continue
+
+                updated_count += 1
+
+            except User.DoesNotExist:
+                self.stdout.write(f"❌ User not found in database: {email}")
+            except (SlackUser.DoesNotExist, ValueError) as e:
+                self.stdout.write(f"❌ Error restoring {email}: {e}")
+
+        return updated_count

firefighter/slack/messages/slack_messages.py

@@ -210,13 +210,28 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
     def get_blocks(self) -> list[Block]:
         fields = [
             f"{self.incident.priority.emoji} *Priority:* {self.incident.priority.name}",
-            f":package: *Issue category:* {self.incident.component.name}",
+            f":package: *Incident category:* {self.incident.incident_category.name}",
             f":speaking_head_in_silhouette: *Opened by:* {user_slack_handle_or_name(self.incident.created_by)}",
             f":calendar: *Created at:* {date_time(self.incident.created_at)}",
             f"{SLACK_APP_EMOJI} <{self.incident.status_page_url + '?utm_medium=FireFighter+Slack&utm_source=Slack+Message&utm_campaign=Announcement+Message+In+Channel'}|*{APP_DISPLAY_NAME} Status Page*>",
         ]
         if hasattr(self.incident, "jira_ticket") and self.incident.jira_ticket:
             fields.append(f":jira_new: <{self.incident.jira_ticket.url}|*Jira ticket*>")
+
+        # Add custom fields if present
+        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']}")
+            if custom_fields.get("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']}")
+            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:
+                fields.append(":medal: *Golden List Seller*")
+
         blocks: list[Block] = [
             SectionBlock(
                 text=f"{self.incident.priority.emoji} {self.incident.priority.name} - A new incident has been declared:"
@@ -270,7 +285,7 @@ class SlackMessageIncidentDeclaredAnnouncementGeneral(SlackMessageSurface):
     def get_blocks(self) -> list[Block]:
         fields = [
             f"{self.incident.priority.emoji} *Priority:* {self.incident.priority.name}",
-            f":package: *Issue category:* {self.incident.component.name}",
+            f":package: *Incident category:* {self.incident.incident_category.name}",
             f"{SLACK_APP_EMOJI} <{self.incident.status_page_url + '?utm_medium=FireFighter+Slack&utm_source=Slack+Message&utm_campaign=Announcement+Message+General'}|*{APP_DISPLAY_NAME} Status Page*>",
             f":speaking_head_in_silhouette: *Opened by:* {user_slack_handle_or_name(self.incident.created_by)}",
             f":calendar: *Created at:* {date_time(self.incident.created_at)}",
@@ -442,7 +457,7 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
 
         if self.in_channel:
             self.title_text = "A new incident update has been posted"
-        elif incident.status == IncidentStatus.FIXED and status_changed:
+        elif incident.status == IncidentStatus.MITIGATED and status_changed:
             self.title_text = f":large_green_circle:  Incident #{incident.slack_channel_name} has been {incident.status.label}.  :large_green_circle:"
         elif old_priority is not None and old_priority.value > 3:
             self.title_text = f"Incident #{incident.slack_channel_name} has escalated from {old_priority.name} to {incident.priority.name}."
@@ -483,10 +498,10 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                         text=f":rotating_light: *Priority:* {self.incident.priority.emoji} {self.incident.priority.name}"
                     )
                 )
-            if self.incident_update.component:
+            if self.incident_update.incident_category:
                 fields.append(
                     MarkdownTextObject(
-                        text=f":package: *Issue category:* {self.incident.component.group.name} - {self.incident.component.name}"
+                        text=f":package: *Incident category:* {self.incident.incident_category.group.name} - {self.incident.incident_category.name}"
                     )
                 )
             if self.incident_update.environment:
@@ -509,7 +524,7 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                                 value=str(self.incident.id),
                                 action_id=UpdateStatusModal.open_action,
                             )
-                            if self.in_channel
+                            if self.in_channel and self.incident.status != IncidentStatus.CLOSED
                             else None
                         ),
                     ),
@@ -691,7 +706,7 @@ class SlackMessageDeployWarning(SlackMessageSurface):
         blocks = [
             HeaderBlock(
                 text=PlainTextObject(
-                    text=f":warning: Deploy warning {'(Mitigated) ' if self.incident.status == IncidentStatus.FIXED else ''}:warning:",
+                    text=f":warning: Deploy warning {'(Mitigated) ' if self.incident.status == IncidentStatus.MITIGATED else ''}:warning:",
                     emoji=True,
                 )
             ),
@@ -702,7 +717,7 @@ class SlackMessageDeployWarning(SlackMessageSurface):
             ),
         ]
 
-        if self.incident.status >= IncidentStatus.FIXED:
+        if self.incident.status >= IncidentStatus.MITIGATED:
             blocks.extend(
                 [
                     SectionBlock(
@@ -735,7 +750,7 @@ class SlackMessagesSOS(SlackMessageSurface):
             ),
             SectionBlock(
                 text=MarkdownTextObject(
-                    text=f"Hello {self.usergroup_target}\nIncident responders have asked for help on a critical incident. This incident is a *{self.incident.priority.name}* and concerns the *{self.incident.component.group.name}/{self.incident.component}* domain.\n\nPlease help the team working to mitigate it :lovecommunity:"
+                    text=f"Hello {self.usergroup_target}\nIncident responders have asked for help on a critical incident. This incident is a *{self.incident.priority.name}* and concerns the *{self.incident.incident_category.group.name}/{self.incident.incident_category}* domain.\n\nPlease help the team working to mitigate it :lovecommunity:"
                 )
             ),
         ]

firefighter/slack/migrations/0005_add_incident_categories_fields.py

@@ -0,0 +1,33 @@
+# Generated manually on 2025-08-19 - Add incident_categories fields to Slack models
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0022_add_incident_category_fields"),
+        ("slack", "0004_alter_usergroup_components"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="conversation",
+            name="incident_categories",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Incident categories that are related to this conversation. When creating a new incident with one of these incident categories, members will be invited to the conversation.",
+                to="incidents.incidentcategory",
+            ),
+        ),
+        migrations.AddField(
+            model_name="usergroup",
+            name="incident_categories",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Incident created with this usergroup automatically add the group members to these incident categories.",
+                related_name="usergroups",
+                to="incidents.incidentcategory",
+            ),
+        ),
+    ]

firefighter/slack/migrations/0006_copy_components_to_incident_categories.py

@@ -0,0 +1,57 @@
+# Generated manually on 2025-08-19 - Copy component relationships to incident_categories
+
+from django.db import migrations
+
+
+def copy_components_to_incident_categories(apps, schema_editor):
+    """Copy all component M2M relationships to incident_categories M2M relationships"""
+    Conversation = apps.get_model("slack", "Conversation")
+    UserGroup = apps.get_model("slack", "UserGroup")
+
+    # Copy conversation components to incident_categories
+    conversations_updated = 0
+    for conversation in Conversation.objects.prefetch_related("components").all():
+        # Copy all component relationships to incident_categories (same UUIDs)
+        incident_category_ids = list(conversation.components.values_list("id", flat=True))
+        conversation.incident_categories.set(incident_category_ids)
+        if incident_category_ids:
+            conversations_updated += 1
+
+    # Copy usergroup components to incident_categories
+    usergroups_updated = 0
+    for usergroup in UserGroup.objects.prefetch_related("components").all():
+        incident_category_ids = list(usergroup.components.values_list("id", flat=True))
+        usergroup.incident_categories.set(incident_category_ids)
+        if incident_category_ids:
+            usergroups_updated += 1
+
+
+def reverse_copy_components_to_incident_categories(apps, schema_editor):
+    """Reverse: copy incident_categories relationships back to components"""
+    Conversation = apps.get_model("slack", "Conversation")
+    UserGroup = apps.get_model("slack", "UserGroup")
+
+    # Copy conversation incident_categories back to components
+    for conversation in Conversation.objects.prefetch_related("incident_categories").all():
+        component_ids = list(conversation.incident_categories.values_list("id", flat=True))
+        conversation.components.set(component_ids)
+
+    # Copy usergroup incident_categories back to components
+    for usergroup in UserGroup.objects.prefetch_related("incident_categories").all():
+        component_ids = list(usergroup.incident_categories.values_list("id", flat=True))
+        usergroup.components.set(component_ids)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("slack", "0005_add_incident_categories_fields"),
+        ("incidents", "0023_populate_incident_category_references"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            copy_components_to_incident_categories,
+            reverse_copy_components_to_incident_categories,
+        ),
+    ]

firefighter/slack/migrations/0007_remove_components_fields.py

@@ -0,0 +1,22 @@
+# Generated manually on 2025-08-19 - Remove components fields from Slack models
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("slack", "0006_copy_components_to_incident_categories"),
+        ("incidents", "0024_remove_component_fields_and_model"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="conversation",
+            name="components",
+        ),
+        migrations.RemoveField(
+            model_name="usergroup",
+            name="components",
+        ),
+    ]

firefighter/slack/migrations/0008_alter_conversation_incident_categories_and_more.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.23 on 2025-09-17 17:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0026_alter_incidentcategory_options_and_more"),
+        ("slack", "0007_remove_components_fields"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="conversation",
+            name="incident_categories",
+            field=models.ManyToManyField(
+                blank=True,
+                related_name="conversations",
+                to="incidents.incidentcategory",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="usergroup",
+            name="incident_categories",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Incident created with this usergroup automatically add the group members to these issue categories.",
+                related_name="usergroups",
+                to="incidents.incidentcategory",
+            ),
+        ),
+    ]

firefighter/slack/models/conversation.py

@@ -11,7 +11,7 @@ from django_stubs_ext.db.models import TypedModelMeta
 from slack_sdk.errors import SlackApiError
 
 from firefighter.firefighter.utils import get_in
-from firefighter.incidents.models import Component, User
+from firefighter.incidents.models import IncidentCategory, User
 from firefighter.slack.messages.base import SlackMessageStrategy, SlackMessageSurface
 from firefighter.slack.models.user import SlackUser
 from firefighter.slack.slack_app import DefaultWebClient, SlackApp, slack_client
@@ -188,8 +188,8 @@ class Conversation(models.Model):
     updated_at = models.DateTimeField(auto_now=True)
 
     members = models.ManyToManyField(User, blank=True)
-    components = models.ManyToManyField["Component", "Component"](
-        Component, related_name="conversations", blank=True
+    incident_categories = models.ManyToManyField["IncidentCategory", "IncidentCategory"](
+        IncidentCategory, related_name="conversations", blank=True
     )
     tag = models.CharField(
         max_length=80,

firefighter/slack/models/incident_channel.py

@@ -100,7 +100,7 @@ class IncidentChannel(Conversation):
         self, client: WebClient = DefaultWebClient
     ) -> SlackResponse | None:
         incident: Incident = self.incident
-        topic = f"Incident - {incident.priority.emoji} {incident.priority.name}  - {incident.status.label} - {incident.component.group.name} - {incident.component.name} - {SLACK_APP_EMOJI} <{incident.status_page_url + '?utm_medium=FireFighter+Slack&utm_source=Slack+Topic&utm_campaign=Slack+Topic+Link'}| {APP_DISPLAY_NAME} Status>"
+        topic = f"Incident - {incident.priority.emoji} {incident.priority.name}  - {incident.status.label} - {incident.incident_category.group.name} - {incident.incident_category.name} - {SLACK_APP_EMOJI} <{incident.status_page_url + '?utm_medium=FireFighter+Slack&utm_source=Slack+Topic&utm_campaign=Slack+Topic+Link'}| {APP_DISPLAY_NAME} Status>"
 
         if len(topic) > 250:
             logger.warning(

firefighter/slack/models/user.py

@@ -147,7 +147,7 @@ class SlackUserManager(models.Manager["SlackUser"]):
         # If we have no Slack User, let's go ahead and create a User and its associated SlackUser
         user, _created = User.objects.get_or_create(
             email=email,
-            username=email.split("@")[0],
+            username=email.split("@", maxsplit=1)[0],
             defaults={
                 "name": clean_user_info["name"],
             },

firefighter/slack/models/user_group.py

@@ -8,7 +8,7 @@ from django.db import models
 from django_stubs_ext.db.models import TypedModelMeta
 
 from firefighter.firefighter.utils import get_first_in, get_in
-from firefighter.incidents.models import Component, User
+from firefighter.incidents.models import IncidentCategory, User
 from firefighter.slack.slack_app import DefaultWebClient, SlackApp, slack_client
 
 if TYPE_CHECKING:
@@ -167,8 +167,8 @@ class UserGroup(models.Model):
         help_text="Is this an external group, from an external Slack Workspace? Corresponds to the `is_external` field in the Slack API.",
     )
 
-    components = models.ManyToManyField["Component", "Component"](
-        Component,
+    incident_categories = models.ManyToManyField["IncidentCategory", "IncidentCategory"](
+        IncidentCategory,
         related_name="usergroups",
         blank=True,
         help_text="Incident created with this usergroup automatically add the group members to these issue categories.",

firefighter/slack/rules.py

@@ -31,7 +31,7 @@ def should_publish_in_general_channel(
     ):
         # If it has just been Mitigated
         if (
-            incident.status == IncidentStatus.FIXED
+            incident.status == IncidentStatus.MITIGATED
             and incident_update is not None
             and incident_update.status is not None
         ):
@@ -50,5 +50,5 @@ def should_publish_in_it_deploy_channel(incident: Incident) -> bool:
         incident.environment.value == "PRD"
         and incident.priority.value <= 1
         and not incident.private
-        and incident.component.deploy_warning
+        and incident.incident_category.deploy_warning
     )