firefighter-incident 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

firefighter/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)

firefighter/firefighter/settings/components/common.py

@@ -88,6 +88,11 @@ WSGI_APPLICATION = "firefighter.firefighter.wsgi.application"
 # Database
 # https://docs.djangoproject.com/en/4.2/ref/settings/#databases
 
+db_schema = config("POSTGRES_SCHEMA", default="")
+db_options = {"options": "-c statement_timeout=30000"}
+if db_schema:
+    db_options["options"] += f" -c search_path={db_schema}"
+
 DATABASES: dict[str, dict[str, Any]] = {
     "default": {
         "ENGINE": "django.db.backends.postgresql",
@@ -96,9 +101,7 @@ DATABASES: dict[str, dict[str, Any]] = {
         "PASSWORD": config("POSTGRES_PASSWORD"),
         "HOST": config("POSTGRES_HOST"),
         "PORT": config("POSTGRES_PORT"),
-        "OPTIONS": {
-            "options": "-c statement_timeout=30000",
-        },
+        "OPTIONS": db_options,
     }
 }
 

firefighter/incidents/forms/select_impact.py

@@ -45,7 +45,7 @@ class SelectImpactForm(forms.Form):
                 label=impact_type.emoji + " " + impact_type.name,
                 queryset=impact_type.levels.all().order_by("-order"),
                 help_text=impact_type.help_text,
-                initial=impact_type.levels.get(value=LevelChoices.NONE.value),
+                initial=impact_type.levels.get(value=LevelChoices.LOWEST.value),
             )
             self.fields[field_name].label_from_instance = (  # type: ignore[attr-defined]
                 lambda obj: obj.emoji + " " + obj.name
@@ -57,16 +57,9 @@ class SelectImpactForm(forms.Form):
             impact: dict[str, ImpactLevel] = self.cleaned_data
 
             impact_values = [impact_type.value for impact_type in impact.values()]
-            if "HI" in impact_values:
-                return 1
-            if "MD" in impact_values:
-                return 2
-            if impact_values.count("LO") > 2:
-                return 3
-            if "LO" in impact_values or "NO" in impact_values:
-                return 4
-            return 4
-        return 4
+            priorities = [level.priority for level in LevelChoices if level in impact_values]
+            return min(priorities) if priorities else LevelChoices.LOWEST.priority
+        return LevelChoices.LOWEST.priority
 
     @property
     def business_impact_new(self) -> str | None:

firefighter/incidents/migrations/0005_enable_from_p1_to_p5_priority.py

@@ -0,0 +1,30 @@
+from django.db import migrations
+
+
+def update_priority_settings(apps, schema_editor):
+    Priority = apps.get_model("incidents", "Priority")
+    priorities_to_update = {
+        "P1": ("01:00:00", True, True),
+        "P2": ("04:00:00", True, True),
+        "P3": ("1 day, 00:00:00", True, True),
+        "P4": ("5 days, 00:00:00", True, True),
+        "P5": ("10 days, 00:00:00", True, True),
+    }
+
+    for name, (sla, enabled_create, enabled_update) in priorities_to_update.items():
+        Priority.objects.filter(name=name).update(
+            sla=sla,
+            enabled_create=enabled_create,
+            enabled_update=enabled_update,
+        )
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0004_incidentupdate_environment"),
+    ]
+
+    operations = [
+        migrations.RunPython(update_priority_settings),
+    ]

firefighter/incidents/migrations/0006_update_group_names.py

@@ -0,0 +1,102 @@
+import logging
+
+from django.db import migrations
+
+logger = logging.getLogger(__name__)
+
+
+def get_group_mappings() -> dict:
+    """Returns the mapping table for updating existing groups."""
+    return {
+        "Platform": ("Platform", 8),
+        "Visitors": ("Marketplace", 1),
+        "Specialist Offer (Catalog/Seller)": ("Catalog", 4),
+        "Operations": ("Operations", 6),
+        "Money": ("Payment Operations", 5),
+        "Security": ("Security", 10),
+        "Corporate IT": ("Corporate IT", 11),
+        "Other": ("Other", 12),
+        "Data": ("Data", 9),
+    }
+
+
+def get_new_groups() -> dict:
+    """Returns a dictionary of new groups to be created."""
+    return {
+        "Marketing & Communication": 2,
+        "Seller": 3,
+        "Finance": 7,
+    }
+
+
+def add_new_groups(apps, _schema_editor):
+    Group = apps.get_model("incidents", "Group")
+    new_groups = get_new_groups()
+
+    for name, position in new_groups.items():
+        try:
+            logger.info(f"Creating new group: '{name}' with order {position}")
+            new_group = Group(name=name, order=position)
+            new_group.save()
+        except Exception:
+            logger.exception(f"Failed to create new group '{name}'.")
+
+
+def remove_new_groups(apps, _schema_editor):
+    Group = apps.get_model("incidents", "Group")
+    new_group_names = get_new_groups().keys()
+
+    for name in new_group_names:
+        try:
+            logger.info(f"Removing group: '{name}'")
+            group = Group.objects.get(name=name)
+            group.delete()
+        except Exception:
+            logger.exception(f"Group '{name}' does not exist, skipping removal.")
+
+
+def update_groups(apps, _schema_editor):
+    Group = apps.get_model("incidents", "Group")
+    group_mappings = get_group_mappings()
+
+    updated_count = 0
+
+    for old_name, (new_name, position) in group_mappings.items():
+        try:
+            logger.info(f"Updating group: '{old_name}' to '{new_name}'")
+            group = Group.objects.get(name=old_name)
+            group.name = new_name
+            group.order = position
+            group.save()
+            updated_count += 1
+        except Exception:
+            logger.exception(f"Group '{old_name}' does not exist, cannot proceed with updates.")
+
+
+def revert_group_names(apps, _schema_editor):
+    Group = apps.get_model("incidents", "Group")
+    reverse_mappings = {new_name: old_name for old_name, (new_name, _) in get_group_mappings().items()}
+
+    updated_count = 0
+
+    for new_name, old_name in reverse_mappings.items():
+        try:
+            group = Group.objects.get(name=new_name)
+            logger.info(f"Restoring group '{new_name}' back to '{old_name}'")
+            group.name = old_name
+            group.save()
+            updated_count += 1
+        except Exception:
+            logger.exception(f"Group '{new_name}' does not exist, skipping restoration.")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0005_enable_from_p1_to_p5_priority"),
+    ]
+
+    operations = [
+        migrations.RunPython(add_new_groups, remove_new_groups),
+        migrations.RunPython(update_groups, revert_group_names),
+    ]

firefighter/incidents/migrations/0007_update_component_name.py

@@ -0,0 +1,148 @@
+import logging
+
+from django.db import migrations
+
+logger = logging.getLogger(__name__)
+
+
+def get_component_mappings() -> list:
+    """
+    Returns a list of tuples for updating existing component names and their attributes.
+
+    Each tuple contains:
+        - old_name (str): The current name of the component.
+        - new_name (str): The new name to assign to the component.
+        - slack_channel (str): The associated Slack channel for the component.
+        - group_name (str): The name of the group to which the component belongs.
+
+    Returns:
+        list: A list of tuples, each representing the details for a component update.
+    """
+    return [
+        ("Commercial Animation (Mabaya cat. integration & ad request, ...)", "Commercial Animation", "impact-commercial-animation", "Marketplace"),
+        ("Mobile Apps", "Mobile Apps", "impact-mobile-apps", "Marketplace"),
+        ("Spartacux Foundations", "Spartacux Foundations", "impact-spartacux-foundations", "Marketplace"),
+        ("Tracking", "Tracking", "impact-tracking", "Marketplace"),
+        ("HUB Integrators", "HUB Integrators", "impact-hub-integrators", "Seller"),
+        ("Seller Account and Feeds", "Seller Catalog and Offer Management", "impact-seller-catalog-offer-management", "Seller"),
+        ("Toolbox", "Seller Admin and Experience", "impact-seller-admin-experience", "Seller"),
+        ("Seller Services (Mabaya BO, Subscriptions, MF)", "Seller Services", "impact-seller-services", "Seller"),
+        ("Catalog Performance", "Catalog Performance", "impact-catalog-performance", "Catalog"),
+        ("Offer (Price, Stock)", "Offer (Price & Stock)", "impact-offer-price-stock", "Catalog"),
+        ("Back Office", "BO Catalog - Master Experience", "impact-bo-catalog-master-experience", "Catalog"),
+        ("Order Lifecycle", "Order management", "impact-order-management", "Operations"),
+        ("Delivery Experience", "Delivery experience", "impact-delivery-experience", "Operations"),
+        ("Cloud Infrastructure", "Cloud Infrastructure", "impact-cloud-infrastructure", "Platform"),
+        ("Spinak", "Spinak", "impact-spinak", "Platform"),
+        ("CDN", "CDN", "impact-cdn", "Platform"),
+        ("Gitlab", "Gitlab", "impact-gitlab", "Platform"),
+    ]
+
+
+def get_new_components() -> dict:
+    """
+    Returns a dictionary of new components to be created.
+
+    Each entry in the dictionary maps a component name to a tuple containing:
+    - group_name: The name of the group the component belongs to.
+    - slack_channel: The associated Slack channel for the component.
+
+    Returns:
+        dict: A mapping of component names to (group name, slack channel) tuples.
+    """
+    return {
+        "Traffic acquisition": ("Marketing & Communication", "impact-traffic-acquisition"),
+        "Company reputation": ("Marketing & Communication", "impact-company-reputation"),
+        "Loyalty and coupons": ("Payment Operations", "impact-loyalty-coupons"),
+        "Payouts to seller": ("Payment Operations", "impact-payouts-to-seller"),
+        "Refunds": ("Payment Operations", "impact-refunds"),
+        "Returns": ("Operations", "impact-returns"),
+        "Customer service": ("Operations", "impact-customer-service"),
+        "Inventory": ("Operations", "impact-inventory"),
+        "VAT": ("Finance", "impact-vat"),
+        "Seller's invoices": ("Finance", "impact-sellers-invoices"),
+        "Customer's invoices": ("Finance", "impact-customers-invoices"),
+        "Accounting": ("Finance", "impact-accounting"),
+        "Revenue": ("Finance", "impact-revenue"),
+        "Compromised laptop / server": ("Security", "impact-compromised-laptop-server"),
+    }
+
+
+def add_new_components(apps, schema_editor):
+    Component = apps.get_model("incidents", "Component")
+    Group = apps.get_model("incidents", "Group")
+    new_components = get_new_components()
+
+    for name, (group_name, _slack) in new_components.items():
+        logger.info(f"Creating new component: '{name}' belonging to group '{group_name}'")
+        try:
+            group_instance = Group.objects.get(name=group_name)
+            new_component = Component(name=name, group=group_instance)
+            new_component.save()
+        except Exception:
+            logger.exception(f"Failed to create new group: '{group_name}'.")
+
+
+def remove_new_components(apps, schema_editor):
+    Component = apps.get_model("incidents", "Component")
+    new_component_names = get_new_components().keys()
+
+    for name in new_component_names:
+        try:
+            component = Component.objects.get(name=name)
+            logger.info(f"Removing component: '{name}'")
+            component.delete()
+        except Exception:
+            logger.exception(f"Component '{name}' does not exist, skipping removal.")
+
+
+def update_component_names(apps, schema_editor):
+    Component = apps.get_model("incidents", "Component")
+    Group = apps.get_model("incidents", "Group")
+    component_mappings = get_component_mappings()
+
+    updated_count = 0
+
+    for old_name, new_name, _slack_channel, group_name in component_mappings:
+        try:
+            component = Component.objects.get(name=old_name)
+            logger.info(f"Updating: '{old_name}' to '{new_name}'")
+            component.name = new_name
+
+            # WARN: this operaration is impossible to revert
+            group_instance = Group.objects.get(name=group_name)
+            component.group = group_instance
+            component.save()
+            updated_count += 1
+        except Exception:
+            logger.exception(f"Component '{old_name}' does not exist, cannot proceed with updates.")
+
+
+def revert_component_names(apps, schema_editor):
+    Component = apps.get_model("incidents", "Component")
+    reverse_mappings = {new_name: old_name for old_name, new_name, _, _ in get_component_mappings()}
+
+    updated_count = 0
+
+    for new_name, old_name in reverse_mappings.items():
+
+        try:
+            component = Component.objects.get(name=new_name)
+            logger.info(f"Restoring '{new_name}' back to '{old_name}'")
+            component.name = old_name
+            component.save()
+            updated_count += 1
+        except Exception:
+            logger.exception(f"Component '{new_name}' does not exist, skipping restoration.")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0006_update_group_names"),
+    ]
+
+    operations = [
+        migrations.RunPython(update_component_names, revert_component_names),
+        migrations.RunPython(add_new_components, remove_new_components),
+    ]

firefighter/incidents/migrations/0008_impact_level.py

@@ -0,0 +1,273 @@
+# Generated by Django 4.2.7 on 2023-12-04 11:09
+
+
+import logging
+import uuid
+
+from django.db import migrations, models
+
+from firefighter.incidents.models.impact import LevelChoices
+
+logger = logging.getLogger(__name__)
+
+
+def remap_incidents(apps, schema_editor):
+    ImpactLevel = apps.get_model("incidents", "ImpactLevel")
+    Impact = apps.get_model("incidents", "Impact")
+
+    to_delete_name = "Few employees with minor issues"
+    to_delete_value = LevelChoices.LOW.value
+    impactlevel_to_delete = ImpactLevel.objects.filter(name=to_delete_name).first()
+
+    new_name = "Significant issues for some employees"
+    new_value = LevelChoices.MEDIUM.value  # before remapping of impact level because after remapping "Significant issues for some employees" will refer to "LO"
+    impactlevel = ImpactLevel.objects.filter(name=new_name).first()
+
+    if impactlevel_to_delete is None:
+        logger.error(f"Failed to find ImpactLevel to delete {to_delete_value} {to_delete_name}.")
+        return
+    if impactlevel is None:
+        logger.error(f"Failed to find ImpactLevel {new_value} {new_name}.")
+        return
+    impacts = Impact.objects.filter(impact_level=impactlevel_to_delete)
+
+    for impact in impacts:
+        try:
+            impact.impact_level = impactlevel
+            impact.save()
+        except Exception:
+            logger.exception(f"Failed to find ImpactLevel {new_value} {new_name}.")
+
+    try:
+        impactlevel_to_delete.delete()
+    except Exception:
+        logger.exception(f"Failed to delete impact level {to_delete_value} {to_delete_name}.")
+
+
+def update_impact_levels(apps, schema_editor):
+    ImpactLevel = apps.get_model("incidents", "ImpactLevel")
+
+    emoji_mapping = {
+        "HT": "⏫",
+        "HI": "🔼",
+        "MD": "▶️",
+        "LO": "🔽",
+        "LT": "⏬",
+    }
+
+    updates = [
+        {
+            "old_name": "Critical issue for many customers",
+            "old_value": "HI",
+            "new_name": None,
+            "new_value": "HT",
+            "new_order": 20,
+        },
+        {
+            "old_name": "Some customers have issues",
+            "old_value": "MD",
+            "new_name": "Some customers with major issues",
+            "new_value": "HI",
+            "new_order": 15,
+        },
+        {
+            "old_name": "Few customers with minor issues",
+            "old_value": "LO",
+            "new_name": "Some customers with significant issues",
+            "new_value": "MD",
+            "new_order": 10,
+        },
+        {
+            "old_name": "No impact on customers",
+            "old_value": "N/A",
+            "new_name": None,
+            "new_value": "LT",
+            "new_order": 0,
+        },
+        {
+            "old_name": "Key services inaccessible for most",
+            "old_value": "HI",
+            "new_name": "Critical issues for many sellers",
+            "new_value": "HT",
+            "new_order": 20,
+        },
+        {
+            "old_name": "Some sellers have significant issues",
+            "old_value": "MD",
+            "new_name": "Some sellers with major issues",
+            "new_value": "HI",
+            "new_order": 15,
+        },
+        {
+            "old_name": "Few sellers with minor issues",
+            "old_value": "LO",
+            "new_name": "Some sellers with significant issues",
+            "new_value": "MD",
+            "new_order": 10,
+        },
+        {
+            "old_name": "No impact on sellers",
+            "old_value": "N/A",
+            "new_name": None,
+            "new_value": "LT",
+            "new_order": 0,
+        },
+        {
+            "old_name": "Significant issues for some employees",
+            "old_value": "MD",
+            "new_name": "Major issues for internal users",
+            "new_value": "LO",
+            "new_order": 10,
+        },
+        {
+            "old_name": "Critical internal tools down",
+            "old_value": "HI",
+            "new_name": "Critical issues for internal users",
+            "new_value": "MD",
+            "new_order": 15,
+        },
+        {
+            "old_name": "No impact on employees",
+            "old_value": "N/A",
+            "new_name": "Minor issues for internal users",
+            "new_value": "LT",
+            "new_order": 0,
+        },
+        {
+            "old_name": "Whole business or revenue at risk",
+            "old_value": "HI",
+            "new_name": "Critical business impact",
+            "new_value": "HT",
+            "new_order": 20,
+        },
+        {
+            "old_name": "Significant business or revenue loss",
+            "old_value": "MD",
+            "new_name": "Major business impact",
+            "new_value": "HI",
+            "new_order": 15,
+        },
+        {
+            "old_name": "Minor impact on business or revenue",
+            "old_value": "LO",
+            "new_name": "Significant business impact",
+            "new_value": "MD",
+            "new_order": 10,
+        },
+        {
+            "old_name": "No impact on business or revenue",
+            "old_value": "N/A",
+            "new_name": None,
+            "new_value": "LT",
+            "new_order": 0,
+        },
+    ]
+
+    for update in updates:
+        old_name = update["old_name"]
+        try:
+            impact_level = ImpactLevel.objects.filter(name=old_name).first()
+            if not impact_level:
+                logger.error(f"Failed to find ImpactLevel with old name:'{old_name}'.")
+                continue
+            if update["new_name"] is not None:
+                impact_level.name = old_name
+            impact_level.value = update["new_value"]
+            impact_level.order = update["new_order"]
+            impact_level.emoji = emoji_mapping.get(update["new_value"], impact_level.emoji)
+            impact_level.save()
+        except Exception:
+            logger.exception(f"Failed to update ImpactLevel '{old_name}'.")
+
+    logger.info("Successfully updated new ImpactLevels.")
+
+
+def add_impact_levels(apps, schema_editor):
+
+    ImpactLevel = apps.get_model("incidents", "ImpactLevel")
+    ImpactType = apps.get_model("incidents", "ImpactType")
+
+    adds = [
+        {
+
+            "name": "Some customers with minor issues",
+            "value": LevelChoices.LOW.value,
+            "order": 5,
+            "impact_type_id": 3,
+            "emoji": LevelChoices.LOW.emoji
+        },
+        {
+            "name": "Some sellers with minor issues",
+            "value": LevelChoices.LOW.value,
+            "order": 5,
+            "impact_type_id": 2,
+            "emoji": LevelChoices.LOW.emoji
+        },
+        {
+            "name": "Minor business impact",
+            "value": LevelChoices.LOW.value,
+            "order": 5,
+            "impact_type_id": 1,
+            "emoji": LevelChoices.LOW.emoji
+        },
+    ]
+
+    for add in adds:
+        name = add["name"]
+        try:
+            impact_level = ImpactLevel.objects.filter(name=name).first()
+
+            impact_type_id = add["impact_type_id"]
+            impact_type = ImpactType.objects.filter(id=impact_type_id).first()
+            if not impact_type:
+                logger.error(f"There is no impact type id:'{impact_type_id}'.")
+                continue
+            if impact_level:
+                logger.error(f"There is already an impact level with name:'{name}'.")
+                continue
+            new_impact_level = ImpactLevel(
+                name=name,
+                value=add["value"],
+                order=add["order"],
+                emoji=add["emoji"],
+                impact_type=impact_type,
+            )
+            new_impact_level.save()
+        except Exception:
+            logger.exception(f"Failed to create new ImpactLevel {name}.")
+
+    logger.info("Successfully created new ImpactLevels.")
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("incidents", "0007_update_component_name"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="impactlevel",
+            name="emoji",
+            field=models.CharField(default="▶", max_length=5),
+        ),
+        migrations.RemoveConstraint(
+          model_name="impactlevel",
+          name="incidents_impactlevel_value_valid",
+        ),
+        migrations.AddConstraint(
+            model_name="impactlevel",
+            constraint=models.CheckConstraint(
+                check=models.Q(("value__in", ["HT", "HI", "MD", "LO", "LT", "NO"])),
+                name="incidents_impactlevel_value_valid",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="impactlevel",
+            name="id",
+            field=models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False),
+        ),
+        migrations.RunPython(remap_incidents),
+        migrations.RunPython(update_impact_levels),
+        migrations.RunPython(add_impact_levels),
+    ]