Feat: wire first modernized feature to platforms providers (#1078)

* feat: implement platform providers activation and initialization

* feat: reorder import statements

* feat: remove geolocate helper and refactor SRE command handling

* feat: enhance geolocate response formatting with country code, postal code, and no data message

* feat: remove deprecated geolocate helper tests and rename conflicting tests

Author: gcharest

app/infrastructure/platforms/providers/slack.py

@@ -3,8 +3,9 @@
 Provides integration with Slack using the Bolt SDK for Socket Mode.
 """
 
-import structlog
 from typing import Any, Callable, Dict, Optional
+
+import structlog
 from slack_bolt import App
 from slack_bolt.adapter.socket_mode import SocketModeHandler
 

app/modules/sre/__init__.py

@@ -0,0 +1,22 @@
+"""SRE module - Platform command registration."""
+
+from infrastructure.services import hookimpl
+from modules.sre.platforms import slack, teams, discord
+
+
+@hookimpl
+def register_slack_commands(provider):
+    """Register SRE module Slack commands."""
+    slack.register_commands(provider)
+
+
+@hookimpl
+def register_teams_commands(provider):
+    """Register SRE module Teams commands."""
+    teams.register_commands(provider)
+
+
+@hookimpl
+def register_discord_commands(provider):
+    """Register SRE module Discord commands."""
+    discord.register_commands(provider)

app/modules/sre/geolocate_helper.py

@@ -3,16 +3,21 @@
 This module contains the main command for the SRE bot. It is responsible for handling the `/sre` command and its subcommands.
 """
 
+from typing import Any, Dict
+
 import structlog
-from core.config import settings
-from infrastructure.commands.router import CommandRouter
+from slack_bolt import Ack, App, Respond
+from slack_sdk import WebClient
+
 from infrastructure.commands.providers.slack import SlackCommandProvider
+from infrastructure.commands.router import CommandRouter
+from infrastructure.platforms.models import CommandPayload
+from infrastructure.services import get_platform_service
+from core.config import settings
+from modules.dev.core import dev_router
 from modules.groups import create_slack_provider
 from modules.incident import incident_helper
-from modules.sre import geolocate_helper, webhook_helper
-from modules.dev.core import dev_router
-from slack_bolt import Ack, App, Respond
-from slack_sdk import WebClient
+from modules.sre import webhook_helper
 
 PREFIX = settings.PREFIX
 GIT_SHA = settings.GIT_SHA
@@ -92,30 +97,6 @@ def handle(self, platform_payload):
         )
 
 
-class GeolocateProvider(SlackCommandProvider):
-    """Adapter for geolocate helper."""
-
-    def __init__(self):
-        super().__init__(settings=settings, config={"enabled": True})
-        self.registry = None
-
-    def handle(self, platform_payload):
-        """Handle geolocate command."""
-        self.acknowledge(platform_payload)
-
-        command = platform_payload["command"]
-        respond = platform_payload["respond"]
-
-        text = command.get("text", "")
-        args = text.split() if text else []
-
-        if not args:
-            respond("Please provide an IP address.\n" "SVP fournir une adresse IP")
-            return
-
-        geolocate_helper.geolocate(args, respond)
-
-
 class VersionProvider(SlackCommandProvider):
     """Adapter for version command."""
 
@@ -150,13 +131,6 @@ def handle(self, platform_payload):
     description_key="sre.subcommands.webhooks.description",
 )
 
-sre_router.register_subcommand(
-    name="geolocate",
-    provider=GeolocateProvider(),
-    platform="slack",
-    description="Geolocate an IP address",
-    description_key="sre.subcommands.geolocate.description",
-)
 
 sre_router.register_subcommand(
     name="version",
@@ -175,16 +149,74 @@ def handle(self, platform_payload):
 )
 
 
-def register(bot: App):
+def register(bot: App) -> None:
     bot.command(f"/{PREFIX}sre")(sre_command)
 
 
+def _dispatch_platform_command(
+    command: Dict[str, Any],
+    respond: Respond,
+) -> bool:
+    text = (command.get("text") or "").strip()
+    if text:
+        parts = text.split(maxsplit=1)
+        command_name = f"sre.{parts[0]}"
+        remaining_text = parts[1] if len(parts) > 1 else ""
+    else:
+        command_name = "sre"
+        remaining_text = ""
+
+    try:
+        platform_service = get_platform_service()
+        slack_provider = platform_service.get_provider("slack")
+    except Exception as exc:  # pylint: disable=broad-except
+        logger.debug("platform_provider_unavailable", error=str(exc))
+        return False
+
+    payload = CommandPayload(
+        text=remaining_text,
+        user_id=command.get("user_id", ""),
+        user_email=command.get("user_email"),
+        channel_id=command.get("channel_id"),
+        user_locale=command.get("locale", "en-US"),
+        response_url=command.get("response_url"),
+        platform_metadata=dict(command),
+    )
+
+    response = slack_provider.dispatch_command(command_name, payload)
+    unknown_command_message = f"Unknown command: {command_name}"
+    if response.message == unknown_command_message:
+        return False
+
+    response_type = "ephemeral" if response.ephemeral else "in_channel"
+    if response.blocks:
+        respond(
+            text=response.message or "",
+            blocks=response.blocks,
+            response_type=response_type,
+        )
+        return True
+    if response.attachments:
+        respond(
+            text=response.message or "",
+            attachments=response.attachments,
+            response_type=response_type,
+        )
+        return True
+    if response.message:
+        respond(text=response.message, response_type=response_type)
+        return True
+
+    respond(text="", response_type=response_type)
+    return True
+
+
 def sre_command(
     ack: Ack,
-    command,
+    command: Dict[str, Any],
     respond: Respond,
     client: WebClient,
-):
+) -> None:
     """Main /sre command handler - delegates all subcommands to router."""
     ack()
     logger.info(
@@ -204,6 +236,9 @@ def sre_command(
         "ack": ack,
     }
 
+    if _dispatch_platform_command(command, respond):
+        return
+
     # Router handles ALL subcommands (new + legacy)
     # Router automatically generates help for empty commands or `/sre help`
     sre_router.handle(payload)

app/modules/sre/sre.py

@@ -102,6 +102,12 @@ def _format_success_blocks(data: GeolocateResponse) -> list[Dict[str, Any]]:
         fields.append({"type": "mrkdwn", "text": f"*City:*\n{data.city}"})
     if data.country:
         fields.append({"type": "mrkdwn", "text": f"*Country:*\n{data.country}"})
+    if data.country_code:
+        fields.append(
+            {"type": "mrkdwn", "text": f"*Country Code:*\n{data.country_code}"}
+        )
+    if data.postal_code:
+        fields.append({"type": "mrkdwn", "text": f"*Postal Code:*\n{data.postal_code}"})
     if data.latitude and data.longitude:
         fields.append(
             {
@@ -112,6 +118,14 @@ def _format_success_blocks(data: GeolocateResponse) -> list[Dict[str, Any]]:
     if data.time_zone:
         fields.append({"type": "mrkdwn", "text": f"*Time Zone:*\n{data.time_zone}"})
 
+    if not fields:
+        fields.append(
+            {
+                "type": "mrkdwn",
+                "text": "*Details:*\nNo location data available for this IP.",
+            }
+        )
+
     return [
         {
             "type": "header",

app/packages/geolocate/platforms/slack.py

@@ -15,7 +15,11 @@
     register_infrastructure_handlers,
 )
 from infrastructure.logging.setup import configure_logging
-from infrastructure.services import get_settings
+from infrastructure.services import (
+    discover_and_register_platforms,
+    get_platform_service,
+    get_settings,
+)
 from jobs import scheduled_tasks
 from modules import (
     atip,
@@ -137,6 +141,46 @@ def _activate_providers(
         logger.error("group_providers_activation_failed", error=str(exc))
         raise
 
+    try:
+        platform_service = get_platform_service()
+        platform_providers = platform_service.load_providers()
+        app.state.platform_service = platform_service
+        app.state.platform_providers = platform_providers
+
+        # Initialize all enabled providers (establishes connections)
+        init_results = platform_service.initialize_all_providers()
+        initialized = [
+            name for name, result in init_results.items() if result.is_success
+        ]
+        failed = [
+            name for name, result in init_results.items() if not result.is_success
+        ]
+
+        if failed:
+            logger.warning(
+                "platform_providers_initialization_partial_failure",
+                initialized=initialized,
+                failed=failed,
+            )
+
+        # Discover and register platform commands for ALL enabled providers
+        # The discover function handles None providers gracefully
+        discover_and_register_platforms(
+            slack_provider=platform_providers.get("slack"),  # type: ignore
+            teams_provider=platform_providers.get("teams"),  # type: ignore
+            discord_provider=platform_providers.get("discord"),  # type: ignore
+        )
+
+        logger.info(
+            "platform_providers_activated",
+            count=len(platform_providers),
+            providers=list(platform_providers.keys()),
+            initialized=initialized,
+        )
+    except Exception as exc:
+        logger.error("platform_providers_activation_failed", error=str(exc))
+        raise
+
     try:
         command_providers = load_command_providers(settings=settings)
         app.state.command_providers = command_providers

app/server/lifespan.py

@@ -7,7 +7,6 @@
 from unittest.mock import MagicMock, patch
 from modules.sre.sre import (
     VersionProvider,
-    GeolocateProvider,
     LegacyWebhooksProvider,
     LegacyIncidentProvider,
 )
@@ -41,53 +40,6 @@ def test_version_provider_responds_to_version_command(self, mock_ack, mock_respo
         assert "SRE Bot version:" in call_args
 
 
-class TestGeolocateProvider:
-    """Tests for geolocate command provider integration."""
-
-    def test_geolocate_provider_initialization(self):
-        """Geolocate provider should initialize without errors."""
-        provider = GeolocateProvider()
-        assert provider is not None
-        assert provider.registry is None
-
-    @patch("modules.sre.geolocate_helper.geolocate")
-    def test_geolocate_provider_delegates_with_ip(
-        self, mock_geolocate, mock_ack, mock_respond
-    ):
-        """Geolocate provider should delegate to helper with IP."""
-        provider = GeolocateProvider()
-
-        payload = {
-            "command": {"text": "192.168.1.1"},
-            "respond": mock_respond,
-            "ack": mock_ack,
-            "client": MagicMock(),
-        }
-
-        provider.handle(payload)
-
-        mock_ack.assert_called_once()
-        mock_geolocate.assert_called_once_with(["192.168.1.1"], mock_respond)
-
-    def test_geolocate_provider_handles_missing_ip(self, mock_ack, mock_respond):
-        """Geolocate provider should handle missing IP gracefully."""
-        provider = GeolocateProvider()
-
-        payload = {
-            "command": {"text": ""},
-            "respond": mock_respond,
-            "ack": mock_ack,
-            "client": MagicMock(),
-        }
-
-        provider.handle(payload)
-
-        mock_ack.assert_called_once()
-        mock_respond.assert_called_once_with(
-            "Please provide an IP address.\nSVP fournir une adresse IP"
-        )
-
-
 class TestLegacyWebhooksProvider:
     """Tests for legacy webhooks command provider integration."""