replace \n

auth/__init__.py

@@ -1,6 +1,7 @@
-from .static_env import verify_user_pwd, verify_token_zabbix
+from .static_env import verify_user_pwd, verify_token_zabbix, verify_token_scom
 
 __all__ = [
     "verify_user_pwd",
     "verify_token_zabbix",
+    "verify_token_scom",
 ]

auth/static_env.py

@@ -18,6 +18,16 @@ def verify_token_zabbix(token: str = Depends(api_key_header)):
         )
 
 
+def verify_token_scom(token: str = Depends(api_key_header)):
+    if token != conf.scom.token:
+        log.warning("Invalid token")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
 def verify_user_pwd(credentials: HTTPBasicCredentials = Depends(security)):
     if (
         credentials.username != conf.swagger.login

config/.env-template

@@ -15,7 +15,13 @@ OAA_CFG__REDIS__PWD=P@ssw0rd!
 OAA_CFG__TG__BOT_TOKEN=string
 OAA_CFG__TG__CHAT_ID=0
 OAA_CFG__TG__DASHBOARD_TRED_ID=0
+
 OAA_CFG__TG__NET_TRED_ID=0
+OAA_CFG__TG__NET_DASHBOARD_TRED_ID=0
+OAA_CFG__TG__SRV_TRED_ID=0
+OAA_CFG__TG__SRV_DASHBOARD_TRED_ID=0
 
 OAA_CFG__ZBX__TOKEN=string
-OAA_CFG__ZBX__CLOSE_ALERT_PATTERN=^Problem has been resolved
+OAA_CFG__ZBX__CLOSE_ALERT_PATTERN=^Problem has been resolved
+
+OAA_CFG__SCOM__TOKEN=string

config/config.py

@@ -35,6 +35,7 @@ class PrefixConfig(BaseModel):
     tg_v1: str = api_v1 + "/tg"
     ping: str = "/ping"
     zbx: str = api_v1 + "/zbx"
+    scom: str = api_v1 + "/scom"
 
 
 class RedisConfig(BaseModel):
@@ -48,6 +49,9 @@ class TelegramConfig(BaseModel):
     chat_id: int
     dashboard_tred_id: int | None = None
     net_tred_id: int | None = None
+    net_dashboard_tred_id: int | None = None
+    srv_tred_id: int | None = None
+    srv_dashboard_tred_id: int | None = None
 
 
 class FromZabbix(BaseModel):
@@ -55,6 +59,10 @@ class FromZabbix(BaseModel):
     close_alert_pattern: str
 
 
+class FromScom(BaseModel):
+    token: str
+
+
 class SwaggerConfig(BaseModel):
     openapi_url: str = "/openapi.json"
     title: str = "API"
@@ -83,6 +91,7 @@ class Settings(BaseSettings):
     redis: RedisConfig
     tg: TelegramConfig
     zbx: FromZabbix
+    scom: FromScom
 
 
 conf = Settings()

routers/__init__.py

@@ -3,6 +3,7 @@ from fastapi import APIRouter
 from .swagger import router as swagger_router
 from .ping import router as ping_router
 from .from_zbx import router as zbx_router
+from .from_scom import router as scom_router
 from config import conf
 
 
@@ -23,3 +24,9 @@ router.include_router(
     prefix=conf.prefix.zbx,
     tags=["From Zabbix"],
 )
+
+router.include_router(
+    scom_router,
+    prefix=conf.prefix.scom,
+    tags=["From SCOM"],
+)

routers/from_scom.py

@@ -0,0 +1,106 @@
+from fastapi import APIRouter, Depends
+import logging as log
+
+from schemas import scomNetworkMessage, scomServerMessage
+from auth import verify_token_scom
+from redis_db import set_value, pop_value
+from config import conf
+from telegram import send_message
+from telegram import del_message
+
+router = APIRouter()
+
+
+@router.post("/net")
+async def net_send_message(
+    message: scomNetworkMessage,
+    token: str = Depends(verify_token_scom),
+):
+    if message.alert_resolution_state == "New":
+        text = f"‼️{message.alert_resolution_state} {message.alert_source} is not responding"
+        result = await send_message(
+            text=text,
+            chat_id=conf.tg.chat_id,
+            message_thread_id=conf.tg.net_dashboard_tred_id,
+        )
+        if result and result["status"] == 200:
+            await set_value(
+                f"scom:net_dashboard:{message.alert_source}", result["msg_id"]
+            )
+        result = await send_message(
+            text=text,
+            chat_id=conf.tg.chat_id,
+            message_thread_id=conf.tg.net_tred_id,
+        )
+        if result and result["status"] == 200:
+            await set_value(f"scom:net:{message.alert_source}", result["msg_id"])
+        return "ok"
+    else:
+        text = (
+            f"✅{message.alert_resolution_state} {message.alert_source} is responding"
+        )
+        dashboard_msg_id = await pop_value(f"scom:net_dashboard:{message.alert_source}")
+        if dashboard_msg_id:
+            dashboard_msg_id = int(dashboard_msg_id.decode("utf-8"))
+            await del_message(message_id=dashboard_msg_id, chat_id=conf.tg.chat_id)
+        msg_id = await pop_value(f"scom:net:{message.alert_source}")
+        if msg_id:
+            msg_id = int(msg_id.decode("utf-8"))
+            await send_message(
+                text=text,
+                chat_id=conf.tg.chat_id,
+                message_thread_id=conf.tg.net_tred_id,
+                reply_to_message_id=msg_id,
+            )
+    return "ok"
+
+
+@router.post("/srv")
+async def srv_send_message(
+    message: scomServerMessage,
+    token: str = Depends(verify_token_scom),
+):
+    if message.alert_resolution_state == "New":
+        text = f"‼️{message.alert_source}\nAlert: {message.alert_name}\nState: {message.alert_resolution_state}\nDescription: {message.alert_description.replace('\\n', '\n')}"
+        result = await send_message(
+            text=text,
+            chat_id=conf.tg.chat_id,
+            message_thread_id=conf.tg.srv_dashboard_tred_id,
+        )
+        if result and result["status"] == 200:
+            await set_value(
+                f"scom:srv_dashboard:{message.alert_source}-{message.alert_name}",
+                result["msg_id"],
+            )
+        result = await send_message(
+            text=text,
+            chat_id=conf.tg.chat_id,
+            message_thread_id=conf.tg.srv_tred_id,
+        )
+        if result and result["status"] == 200:
+            await set_value(
+                f"scom:srv:{message.alert_source}-{message.alert_name}",
+                result["msg_id"],
+            )
+        return "ok"
+    else:
+        text = f"✅{message.alert_source}\nAlert: {message.alert_name}\nState: {message.alert_resolution_state}\nDescription: {message.alert_description.replace('\\n', '\n')}"
+        dashboard_msg_id = await pop_value(
+            f"scom:srv_dashboard:{message.alert_source}-{message.alert_name}"
+        )
+        if dashboard_msg_id:
+            dashboard_msg_id = int(dashboard_msg_id.decode("utf-8"))
+            await del_message(message_id=dashboard_msg_id, chat_id=conf.tg.chat_id)
+
+        msg_id = await pop_value(
+            f"scom:srv:{message.alert_source}-{message.alert_name}"
+        )
+        if msg_id:
+            msg_id = int(msg_id.decode("utf-8"))
+        await send_message(
+            text=text,
+            chat_id=conf.tg.chat_id,
+            message_thread_id=conf.tg.srv_tred_id,
+            reply_to_message_id=msg_id,
+        )
+        return "ok"

schemas/__init__.py

@@ -2,8 +2,14 @@ from .from_zabbix import (
     MessageToDashboard as zbxMessageToDashboard,
     MessageToNetworkChat as zbxMessageToNetworkChat,
 )
+from .from_scom import (
+    NetworkMessage as scomNetworkMessage,
+    ServerMessage as scomServerMessage,
+)
 
 __all__ = [
     "zbxMessageToDashboard",
     "zbxMessageToNetworkChat",
+    "scomNetworkMessage",
+    "scomServerMessage",
 ]

schemas/from_scom.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    alert_source: str
+    alert_resolution_state: str
+
+
+class NetworkMessage(Message):
+    pass
+
+
+class ServerMessage(Message):
+    alert_name: str
+    alert_description: str

telegram/message.py

@@ -8,6 +8,7 @@ async def send_message(
     text: str,
     chat_id: int,
     message_thread_id: int | None = None,
+    reply_to_message_id: int | None = None,
 ) -> dict | None:
     url = f"https://api.telegram.org/bot{conf.tg.bot_token}/sendMessage"
     params = {
@@ -16,6 +17,10 @@ async def send_message(
     }
     if message_thread_id:
         params["message_thread_id"] = message_thread_id
+    if reply_to_message_id:
+        params["reply_to_message_id"] = reply_to_message_id
+
+    log.info(f"Params: {params}")
     async with aiohttp.ClientSession() as session:
         async with session.post(
             url,