api/endpoints/xc.py

#!/usr/bin/env python3.12

import logging
from fastapi import FastAPI, Request, HTTPException
from pydantic import BaseModel
from aiohttp import ClientSession, ClientTimeout
from .constructors import ValidXCRequest
# pylint: disable=invalid-name

class XC(FastAPI):
    """XC (CrossComm) Endpoints"""   
    def __init__(self, app: FastAPI, util, constants, glob_state) -> None:  # pylint: disable=super-init-not-called
        self.app = app
        self.util = util
        self.constants = constants
        self.glob_state = glob_state


        self.endpoints: dict = {
            "xc": self.xc_handler,
            }
        
        for endpoint, handler in self.endpoints.items():
            app.add_api_route(f"/{endpoint}", handler, methods=["POST"],
                              include_in_schema=False)

    async def xc_handler(self, data: ValidXCRequest, request: Request) -> dict:
        """Handle XC Commands"""
        
        try:
                key: str = data.key
                bid: int = data.bid
                cmd: str = data.cmd
                cmd_data: dict = data.data
                if not self.util.check_key(path=request.url.path, req_type=0, key=key):
                    raise HTTPException(status_code=403, detail="Unauthorized")
                
                BID_ADDR_MAP: dict = {
                    0: '10.10.10.101:5991', # Patrick (a.k.a. Thomas a.k.a.  Aces)
                    # TODO: add Havoc?
                }

                if not bid in BID_ADDR_MAP:
                    return {
                        'err': True,
                        'errorText': 'Invalid bot id'
                    }

                bot_api_url: str = f'http://{BID_ADDR_MAP[bid]}/'
                async with ClientSession() as  session:
                    async with await session.post(f"{bot_api_url}{cmd}", json=cmd_data, headers={
                        'Content-Type': 'application/json; charset=utf-8'
                    }, timeout=ClientTimeout(connect=5, sock_read=5)) as request:
                        response: dict = await request.json()
                        return {
                            'success': True,
                            'response': response
                        }
        except Exception as e:
            logging.debug("Error: %s", str(e))