turnosxpress/sysadmin/src/controllers/wap.controller.ts

import axios from "axios";
import { Request, Response } from "express";
import { WapService } from "../services/wap.service";
import { CreateWapServerParams, PaginateWapServerParams, UpdateWapServerParams, WapServerByIdParams, WapServerDeleteParams, WapServerOrganizationActionParams } from "src/models/WapServers.Model";

const wapService = new WapService();

const getErrorStatus = (error: unknown): number => {
    if (axios.isAxiosError(error) && error.response?.status) {
        return error.response.status;
    }

    return 500;
};

const getErrorMessage = (error: unknown): string => {
    const responseData = axios.isAxiosError(error) ? error.response?.data : undefined;

    if (typeof responseData === "string") {
        return responseData;
    }

    return responseData?.desc || responseData?.message || responseData?.error || (error as Error)?.message || "Internal Server Error";
};

export class WapController {
    public getServers = async (req: Request, res: Response): Promise<void> => {
        try {
            let data: PaginateWapServerParams = req.body as PaginateWapServerParams;
            const servers = await wapService.getWapServers(data);
            res.json(servers);
        } catch (error) {
            console.error("Error fetching wap servers:", error);
            res.status(500).json({ success: false, message: "Internal Server Error" });
        }
    };

    public auditServer = async (req: Request, res: Response): Promise<void> => {
        try {
            const data: WapServerByIdParams = req.body as WapServerByIdParams;
            const audit = await wapService.auditWapServer(data);
            res.json(audit);
        } catch (error) {
            console.error("Error auditing wap server:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public updateServer = async (req: Request, res: Response): Promise<void> => {
        try {
            const result = await wapService.updateWapServer(req.body as UpdateWapServerParams);
            res.json(result);
        } catch (error) {
            console.error("Error updating wap server:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public createServer = async (req: Request, res: Response): Promise<void> => {
        try {
            const result = await wapService.createWapServer(req.body as CreateWapServerParams);
            res.json(result);
        } catch (error) {
            console.error("Error creating wap server:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public recalculateCount = async (req: Request, res: Response): Promise<void> => {
        try {
            const data: WapServerByIdParams = req.body as WapServerByIdParams;
            const result = await wapService.recalculateWapServerCount(data);
            res.json(result);
        } catch (error) {
            console.error("Error recalculating wap server count:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public deleteServer = async (req: Request, res: Response): Promise<void> => {
        try {
            const data: WapServerDeleteParams = req.body as WapServerDeleteParams;
            const result = await wapService.deleteWapServer(data);
            res.json(result);
        } catch (error) {
            console.error("Error deleting wap server:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public startBot = async (req: Request, res: Response): Promise<void> => {
        try {
            await wapService.startBot(req.body as WapServerOrganizationActionParams);
            res.json({ success: true, message: "ok" });
        } catch (error) {
            console.error("Error starting wap bot:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public stopBot = async (req: Request, res: Response): Promise<void> => {
        try {
            await wapService.stopBot(req.body as WapServerOrganizationActionParams);
            res.json({ success: true, message: "ok" });
        } catch (error) {
            console.error("Error stopping wap bot:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public restartBot = async (req: Request, res: Response): Promise<void> => {
        try {
            await wapService.restartBot(req.body as WapServerOrganizationActionParams);
            res.json({ success: true, message: "ok" });
        } catch (error) {
            console.error("Error restarting wap bot:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public getBotQr = async (req: Request, res: Response): Promise<void> => {
        try {
            const result = await wapService.getBotQr(req.body as WapServerOrganizationActionParams);
            res.json(result);
        } catch (error) {
            console.error("Error getting wap bot qr:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public deleteBot = async (req: Request, res: Response): Promise<void> => {
        try {
            await wapService.deleteBot(req.body as WapServerOrganizationActionParams);
            res.json({ success: true, message: "ok" });
        } catch (error) {
            console.error("Error deleting wap bot:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };

    public detachOrganizationServer = async (req: Request, res: Response): Promise<void> => {
        try {
            const result = await wapService.detachOrganizationServer(req.body as WapServerOrganizationActionParams);
            res.json(result);
        } catch (error) {
            console.error("Error detaching wap organization server:", error);
            const message = getErrorMessage(error);
            res.status(getErrorStatus(error)).json({ success: false, message, desc: message });
        }
    };
}