mira-app-server/dist/routes/BaseRouter.js

Mira Server - standalone server application using mira-app-core

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseRouter = void 0;
class BaseRouter {
    constructor(backend) {
        this.backend = backend;
    }
    /**
     * 验证并获取Library对象
     */
    async validateLibrary(libraryId) {
        if (!libraryId) {
            return {
                success: false,
                error: {
                    code: 400,
                    message: 'Library ID is required',
                    data: null
                }
            };
        }
        const obj = this.backend.libraries.getLibrary(libraryId);
        if (!obj) {
            return {
                success: false,
                error: {
                    code: 404,
                    message: 'Library not found',
                    data: null
                }
            };
        }
        return { success: true, library: obj };
    }
    /**
     * 发送成功响应
     */
    sendSuccess(res, data, message = 'Success') {
        res.json({
            code: 0,
            message,
            data
        });
    }
    /**
     * 发送错误响应
     */
    sendError(res, code, message, data = null) {
        res.status(code).json({
            code,
            message,
            data
        });
    }
    /**
     * 通用的CRUD操作处理器
     */
    async handleCrudOperation(req, res, operation, serviceMethod, options = {}) {
        try {
            // 从请求中获取libraryId
            const libraryId = req.body.libraryId || req.query.libraryId;
            // 验证library
            const validation = await this.validateLibrary(libraryId);
            if (!validation.success) {
                res.status(validation.error.code).json(validation.error);
                return;
            }
            const { library } = validation;
            // 验证必需的ID参数
            if (options.requiresId && !req.body.id) {
                res.status(400).json({
                    code: 400,
                    message: `ID is required for ${operation} operation`,
                    data: null
                });
                return;
            }
            // 准备参数并执行服务方法
            let result;
            switch (operation) {
                case 'create':
                    const { libraryId: _, ...createData } = req.body;
                    // 应用数据转换（如果提供）
                    const transformedCreateData = options.dataTransform ? options.dataTransform(createData) : createData;
                    result = await library.libraryService[serviceMethod](transformedCreateData);
                    break;
                case 'update':
                    const { libraryId: __, id, ...updateData } = req.body;
                    // 应用数据转换（如果提供）
                    const transformedUpdateData = options.dataTransform ? options.dataTransform(updateData) : updateData;
                    result = await library.libraryService[serviceMethod](id, transformedUpdateData);
                    break;
                case 'delete':
                    result = await library.libraryService[serviceMethod](req.body.id, req.body.deleteFiles);
                    break;
                case 'query':
                    result = await library.libraryService[serviceMethod](req.body.query || {});
                    break;
                case 'getAll':
                    result = await library.libraryService[serviceMethod]();
                    break;
                default:
                    throw new Error(`Unsupported operation: ${operation}`);
            }
            // 应用响应转换（如果提供）
            const transformedResult = options.responseTransform ? options.responseTransform(result) : result;
            if (options.onSuccess) {
                options.onSuccess(result, libraryId);
            }
            this.sendSuccess(res, transformedResult, options.successMessage);
        }
        catch (error) {
            console.error(`${operation} operation error:`, error);
            this.sendError(res, 500, 'Internal server error');
        }
    }
    /**
     * 处理文件关联操作（设置标签、文件夹等）
     */
    async handleFileAssociation(req, res, operation, serviceMethod, associationType, options = {}) {
        try {
            const libraryId = req.body.libraryId || req.query.libraryId;
            const fileId = req.body.fileId || req.params.fileId;
            if (!fileId) {
                res.status(400).json({
                    code: 400,
                    message: 'File ID is required',
                    data: null
                });
                return;
            }
            const validation = await this.validateLibrary(libraryId);
            if (!validation.success) {
                res.status(validation.error.code).json(validation.error);
                return;
            }
            const { library } = validation;
            let result;
            if (operation === 'set') {
                const associationValue = req.body[associationType];
                result = await library.libraryService[serviceMethod](fileId, associationValue);
                this.sendSuccess(res, { fileId, [associationType]: associationValue, result }, options.successMessage);
            }
            else {
                result = await library.libraryService[serviceMethod](parseInt(fileId));
                this.sendSuccess(res, { [associationType]: result });
            }
            if (options.onSuccess) {
                options.onSuccess(result, libraryId, fileId);
            }
        }
        catch (error) {
            console.error(`${operation} file ${associationType} error:`, error);
            this.sendError(res, 500, 'Internal server error');
        }
    }
}
exports.BaseRouter = BaseRouter;
//# sourceMappingURL=BaseRouter.js.map