Spaces:

sardarbipul
/

test

Sleeping

test / dist /controllers /admin.controller.js

feat: Include hardcoded dataset attributes (image,type,text,x1,y1,x2,y2) in every request/response

4aafa95 3 months ago

9.09 kB

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AdminController = void 0;
const app_config_1 = require("../config/app.config");
class AdminController {
    statisticsService;
    workerService;
    taskQueueService;
    datasetService;
    wsServer;
    constructor(statisticsService, workerService, taskQueueService, datasetService, wsServer) {
        this.statisticsService = statisticsService;
        this.workerService = workerService;
        this.taskQueueService = taskQueueService;
        this.datasetService = datasetService;
        this.wsServer = wsServer;
    }
    setWsServer(wsServer) {
        this.wsServer = wsServer;
    }
    getStatistics = async (req, res) => {
        try {
            const stats = await this.statisticsService.getSystemStatistics();
            res.status(200).json(stats);
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    getWorkers = async (req, res) => {
        try {
            const status = req.query.status;
            const workers = await this.workerService.getAllWorkers(status);
            res.status(200).json({ count: workers.length, workers });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    getTasks = async (req, res) => {
        try {
            const status = req.query.status;
            const workerId = req.query.workerId;
            const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
            const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
            const tasks = await this.taskQueueService.getTasks({ status, workerId, limit, offset });
            const counts = await this.taskQueueService.getTaskCounts();
            res.status(200).json({
                summary: counts,
                limit,
                offset,
                count: tasks.length,
                tasks,
            });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    createTask = async (req, res) => {
        try {
            const { startRow, endRow, totalRows, chunkSize } = req.body;
            if (totalRows !== undefined) {
                const count = await this.taskQueueService.generateBatchTasks(Number(totalRows), chunkSize ? Number(chunkSize) : undefined);
                res.status(201).json({ message: `Successfully queued batch tasks. Total tasks: ${count}` });
                return;
            }
            if (startRow === undefined || endRow === undefined) {
                res.status(400).json({ error: 'Parameters startRow and endRow (or totalRows) are required.' });
                return;
            }
            const task = await this.taskQueueService.createTask({
                startRow: Number(startRow),
                endRow: Number(endRow),
            });
            res.status(201).json({ message: 'Task created successfully', task });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    resetTasks = async (req, res) => {
        try {
            const clearedCount = await this.taskQueueService.resetAllTasks();
            res.status(200).json({ message: `Cleared ${clearedCount} existing tasks.` });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    shutdownWorker = async (req, res) => {
        try {
            const { workerId, reason } = req.body;
            if (!workerId) {
                res.status(400).json({ error: 'workerId is required' });
                return;
            }
            if (this.wsServer) {
                const sent = this.wsServer.sendToWorker(workerId, {
                    type: 'shutdown',
                    payload: { reason: reason || 'Administrative shutdown order' },
                });
                if (sent) {
                    await this.workerService.setWorkerStatus(workerId, 'offline', null);
                    res.status(200).json({ message: `Shutdown message dispatched to worker ${workerId}` });
                    return;
                }
            }
            await this.workerService.setWorkerStatus(workerId, 'offline', null);
            res.status(200).json({ message: `Worker ${workerId} marked offline (no active WS connection)` });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    getDatasetRows = async (req, res) => {
        try {
            const startRow = req.query.startRow ? parseInt(req.query.startRow, 10) : 0;
            const limit = req.query.limit ? parseInt(req.query.limit, 10) : 5;
            const safeStartRow = Math.max(0, isNaN(startRow) ? 0 : startRow);
            const safeLimit = Math.min(100, Math.max(1, isNaN(limit) ? 5 : limit));
            const rawRows = await this.datasetService.readRowContentSnippet(safeStartRow, safeLimit);
            const datasetStats = await this.datasetService.getDatasetStats();
            res.status(200).json({
                startRow: safeStartRow,
                limit: safeLimit,
                count: rawRows.length,
                totalRows: datasetStats.totalIndexedRows,
                attributes: app_config_1.CONFIG.DATASET_ATTRIBUTES,
                header: app_config_1.CONFIG.DATASET_HEADER,
                rows: rawRows.map((content, idx) => ({
                    rowIndex: safeStartRow + idx,
                    content,
                })),
            });
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
    getTaskData = async (req, res) => {
        try {
            const taskId = (req.params.taskId || req.query.taskId || req.body?.taskId);
            let startRow = req.query.startRow !== undefined ? parseInt(req.query.startRow, 10) : req.body?.startRow;
            let endRow = req.query.endRow !== undefined ? parseInt(req.query.endRow, 10) : req.body?.endRow;
            let startOffset = req.query.startOffset !== undefined ? parseInt(req.query.startOffset, 10) : req.body?.startOffset;
            let endOffset = req.query.endOffset !== undefined ? parseInt(req.query.endOffset, 10) : req.body?.endOffset;
            const format = (req.query.format || req.body?.format);
            if (taskId) {
                const task = await this.taskQueueService.getTask(taskId);
                if (task) {
                    if (startRow === undefined)
                        startRow = task.startRow;
                    if (endRow === undefined)
                        endRow = task.endRow;
                    if (startOffset === undefined && task.startOffset !== undefined)
                        startOffset = task.startOffset;
                    if (endOffset === undefined && task.endOffset !== undefined)
                        endOffset = task.endOffset;
                }
            }
            if (taskId === undefined &&
                (startRow === undefined || endRow === undefined) &&
                (startOffset === undefined || endOffset === undefined)) {
                res.status(400).json({
                    error: 'Missing required parameters. Please specify taskId, or startRow & endRow, or startOffset & endOffset.',
                });
                return;
            }
            const result = await this.datasetService.getTaskData({
                taskId,
                startRow: startRow !== undefined ? Number(startRow) : undefined,
                endRow: endRow !== undefined ? Number(endRow) : undefined,
                startOffset: startOffset !== undefined ? Number(startOffset) : undefined,
                endOffset: endOffset !== undefined ? Number(endOffset) : undefined,
            });
            const wantsJson = format === 'json' ||
                (req.headers.accept && req.headers.accept.includes('application/json'));
            if (wantsJson) {
                const contentStr = result.buffer.toString('utf-8');
                res.status(200).json({
                    taskId: taskId || null,
                    startRow: result.startRow,
                    endRow: result.endRow,
                    startOffset: result.startOffset,
                    endOffset: result.endOffset,
                    byteLength: result.byteLength,
                    attributes: result.attributes,
                    header: result.header,
                    content: contentStr,
                });
                return;
            }
            res.setHeader('Content-Type', 'text/csv; charset=utf-8');
            res.setHeader('Content-Length', result.buffer.length);
            if (taskId) {
                res.setHeader('Content-Disposition', `attachment; filename="${taskId}.csv"`);
            }
            res.status(200).send(result.buffer);
        }
        catch (err) {
            res.status(500).json({ error: err.message });
        }
    };
}
exports.AdminController = AdminController;

	"use strict";
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.AdminController = void 0;
	const app_config_1 = require("../config/app.config");
	class AdminController {
	statisticsService;
	workerService;
	taskQueueService;
	datasetService;
	wsServer;
	constructor(statisticsService, workerService, taskQueueService, datasetService, wsServer) {
	this.statisticsService = statisticsService;
	this.workerService = workerService;
	this.taskQueueService = taskQueueService;
	this.datasetService = datasetService;
	this.wsServer = wsServer;
	}
	setWsServer(wsServer) {
	this.wsServer = wsServer;
	}
	getStatistics = async (req, res) => {
	try {
	const stats = await this.statisticsService.getSystemStatistics();
	res.status(200).json(stats);
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	getWorkers = async (req, res) => {
	try {
	const status = req.query.status;
	const workers = await this.workerService.getAllWorkers(status);
	res.status(200).json({ count: workers.length, workers });
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	getTasks = async (req, res) => {
	try {
	const status = req.query.status;
	const workerId = req.query.workerId;
	const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
	const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
	const tasks = await this.taskQueueService.getTasks({ status, workerId, limit, offset });
	const counts = await this.taskQueueService.getTaskCounts();
	res.status(200).json({
	summary: counts,
	limit,
	offset,
	count: tasks.length,
	tasks,
	});
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	createTask = async (req, res) => {
	try {
	const { startRow, endRow, totalRows, chunkSize } = req.body;
	if (totalRows !== undefined) {
	const count = await this.taskQueueService.generateBatchTasks(Number(totalRows), chunkSize ? Number(chunkSize) : undefined);
	res.status(201).json({ message: `Successfully queued batch tasks. Total tasks: ${count}` });
	return;
	}
	if (startRow === undefined \|\| endRow === undefined) {
	res.status(400).json({ error: 'Parameters startRow and endRow (or totalRows) are required.' });
	return;
	}
	const task = await this.taskQueueService.createTask({
	startRow: Number(startRow),
	endRow: Number(endRow),
	});
	res.status(201).json({ message: 'Task created successfully', task });
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	resetTasks = async (req, res) => {
	try {
	const clearedCount = await this.taskQueueService.resetAllTasks();
	res.status(200).json({ message: `Cleared ${clearedCount} existing tasks.` });
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	shutdownWorker = async (req, res) => {
	try {
	const { workerId, reason } = req.body;
	if (!workerId) {
	res.status(400).json({ error: 'workerId is required' });
	return;
	}
	if (this.wsServer) {
	const sent = this.wsServer.sendToWorker(workerId, {
	type: 'shutdown',
	payload: { reason: reason \|\| 'Administrative shutdown order' },
	});
	if (sent) {
	await this.workerService.setWorkerStatus(workerId, 'offline', null);
	res.status(200).json({ message: `Shutdown message dispatched to worker ${workerId}` });
	return;
	}
	}
	await this.workerService.setWorkerStatus(workerId, 'offline', null);
	res.status(200).json({ message: `Worker ${workerId} marked offline (no active WS connection)` });
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	getDatasetRows = async (req, res) => {
	try {
	const startRow = req.query.startRow ? parseInt(req.query.startRow, 10) : 0;
	const limit = req.query.limit ? parseInt(req.query.limit, 10) : 5;
	const safeStartRow = Math.max(0, isNaN(startRow) ? 0 : startRow);
	const safeLimit = Math.min(100, Math.max(1, isNaN(limit) ? 5 : limit));
	const rawRows = await this.datasetService.readRowContentSnippet(safeStartRow, safeLimit);
	const datasetStats = await this.datasetService.getDatasetStats();
	res.status(200).json({
	startRow: safeStartRow,
	limit: safeLimit,
	count: rawRows.length,
	totalRows: datasetStats.totalIndexedRows,
	attributes: app_config_1.CONFIG.DATASET_ATTRIBUTES,
	header: app_config_1.CONFIG.DATASET_HEADER,
	rows: rawRows.map((content, idx) => ({
	rowIndex: safeStartRow + idx,
	content,
	})),
	});
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	getTaskData = async (req, res) => {
	try {
	const taskId = (req.params.taskId \|\| req.query.taskId \|\| req.body?.taskId);
	let startRow = req.query.startRow !== undefined ? parseInt(req.query.startRow, 10) : req.body?.startRow;
	let endRow = req.query.endRow !== undefined ? parseInt(req.query.endRow, 10) : req.body?.endRow;
	let startOffset = req.query.startOffset !== undefined ? parseInt(req.query.startOffset, 10) : req.body?.startOffset;
	let endOffset = req.query.endOffset !== undefined ? parseInt(req.query.endOffset, 10) : req.body?.endOffset;
	const format = (req.query.format \|\| req.body?.format);
	if (taskId) {
	const task = await this.taskQueueService.getTask(taskId);
	if (task) {
	if (startRow === undefined)
	startRow = task.startRow;
	if (endRow === undefined)
	endRow = task.endRow;
	if (startOffset === undefined && task.startOffset !== undefined)
	startOffset = task.startOffset;
	if (endOffset === undefined && task.endOffset !== undefined)
	endOffset = task.endOffset;
	}
	}
	if (taskId === undefined &&
	(startRow === undefined \|\| endRow === undefined) &&
	(startOffset === undefined \|\| endOffset === undefined)) {
	res.status(400).json({
	error: 'Missing required parameters. Please specify taskId, or startRow & endRow, or startOffset & endOffset.',
	});
	return;
	}
	const result = await this.datasetService.getTaskData({
	taskId,
	startRow: startRow !== undefined ? Number(startRow) : undefined,
	endRow: endRow !== undefined ? Number(endRow) : undefined,
	startOffset: startOffset !== undefined ? Number(startOffset) : undefined,
	endOffset: endOffset !== undefined ? Number(endOffset) : undefined,
	});
	const wantsJson = format === 'json' \|\|
	(req.headers.accept && req.headers.accept.includes('application/json'));
	if (wantsJson) {
	const contentStr = result.buffer.toString('utf-8');
	res.status(200).json({
	taskId: taskId \|\| null,
	startRow: result.startRow,
	endRow: result.endRow,
	startOffset: result.startOffset,
	endOffset: result.endOffset,
	byteLength: result.byteLength,
	attributes: result.attributes,
	header: result.header,
	content: contentStr,
	});
	return;
	}
	res.setHeader('Content-Type', 'text/csv; charset=utf-8');
	res.setHeader('Content-Length', result.buffer.length);
	if (taskId) {
	res.setHeader('Content-Disposition', `attachment; filename="${taskId}.csv"`);
	}
	res.status(200).send(result.buffer);
	}
	catch (err) {
	res.status(500).json({ error: err.message });
	}
	};
	}
	exports.AdminController = AdminController;