node-web-mvc/dist/servlets/http/HttpServletResponse.js

node spring mvc

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const HttpStatus_1 = __importDefault(require("./HttpStatus"));
const ApiUtils_1 = require("../util/ApiUtils");
const HttpHeaders_1 = __importDefault(require("./HttpHeaders"));
const servletContextSymbol = Symbol('servletContext');
class HttpServletResponse {
    /**
   * 当前请求上下文
   */
    get servletContext() {
        return this[servletContextSymbol];
    }
    /**
     * 判断返回头是否已经发送
     */
    get headersSent() {
        return this.nativeResponse.headersSent;
    }
    get status() {
        const code = this.statusCode;
        return HttpStatus_1.default.AllStatus.get(code) || new HttpStatus_1.default(code, this.statusMessage);
    }
    /**
     * 获取当前设置的返回状态编码
     */
    get statusCode() {
        return this.tempStatusCode || this.nativeResponse.statusCode;
    }
    /**
     * 获取当i请安设置返回状态的描述信息
     */
    get statusMessage() {
        return this.tempStatusMessage || this.nativeResponse.statusMessage;
    }
    /**
     * 获取已经设置的content-type
     */
    get nativeContentType() {
        return this.nativeResponse.getHeader('content-type');
    }
    writeStatus() {
        if (this.nativeResponse.headersSent) {
            return;
        }
        if (!this.tempStatusCode) {
            const OK = HttpStatus_1.default.OK;
            this.nativeResponse.writeHead(OK.code, OK.message);
        }
        else {
            this.nativeResponse.writeHead(this.tempStatusCode, this.tempStatusMessage);
        }
    }
    /**
     * 当前请求是否有错误
     */
    get hasError() {
        return String(this.statusCode)[0] != '2';
    }
    /**
     * 获取设置的返回头
     * @param name
     */
    getHeader(name) {
        return this.nativeResponse.getHeader((name || '').toLowerCase());
    }
    getHeaderValue(name) {
        const v = this.getHeader(name);
        return v instanceof Array ? v : (0, ApiUtils_1.isEmpty)(v) ? [] : [v];
    }
    addHeader(name, value, checkExists = false) {
        const values = this.getHeaderValue(name);
        const addValues = value instanceof Array ? value : [value];
        addValues.forEach((value) => {
            if (!(checkExists && values.indexOf(value) > -1)) {
                values.push(value);
            }
        });
        this.setHeader(name, values);
    }
    /**
     * 添加一个指定名称的返回头到返回头队列
     * @param {String} name 返回头名称
     * @param {String} value 返回头值
     */
    setHeader(name, value) {
        this.nativeResponse.setHeader(name, value);
        return this;
    }
    /**
     * 返回异常，结束请i去
     * @param name
     */
    sendError(status) {
        this.setStatus(status);
    }
    /**
     * 判断当前返回头中是否指定头
     */
    containsHeader(name) {
        return !!this.getHeader(name);
    }
    /**
     * 设置日期类型返回头
     */
    setDateHeader(name, value) {
        const v = value instanceof Date ? value : new Date(value);
        this.nativeResponse.setHeader(name, v.toUTCString());
        return this;
    }
    /**
     * 设置返回状态
     * @param response
     */
    setStatus(status, statusMessage) {
        if (status instanceof HttpStatus_1.default || (status && typeof status === 'object')) {
            this.tempStatusCode = status.code;
            this.tempStatusMessage = status.message;
        }
        else {
            this.tempStatusCode = status;
            this.tempStatusMessage = statusMessage;
        }
        return this;
    }
    /**
     * 移除指定返回头
     * @param name 返回头
     */
    removeHeader(name) {
        this.nativeResponse.removeHeader(name);
    }
    /**
     * 以安全方式将要写入的内容创建成一个buffer对象
     * @param data
     * @returns {Buffer}
     */
    createBuffer(data) {
        if (data instanceof Buffer) {
            return data;
        }
        return Buffer.from(String((0, ApiUtils_1.emptyOf)(data, '')));
    }
    /**
     * 写出内容到客户端
     * @param response
     */
    write(chunk, encoding) {
        this.writeStatus();
        const buffer = this.createBuffer(chunk);
        this.nativeResponse.write(buffer, encoding || 'utf-8');
    }
    /**
     * 结束请求
     * @param response
     */
    end(content, encoding) {
        const buffer = this.createBuffer(content);
        this.write(buffer, encoding);
        this.nativeResponse.end(undefined, encoding);
    }
    /**
     * 立即结束请求，并且设置返回内容与返回内容类型
     * 注意：此前不能调用response的 write与end函数
     * @param content 要返回的内容
     * @param mediaType 媒体类型
     * @param encoding 编码
     */
    async fullResponse(content, mediaType, encoding) {
        const buffer = this.createBuffer(content);
        if (mediaType) {
            this.setHeader(HttpHeaders_1.default.CONTENT_TYPE, mediaType.toString());
        }
        this.setHeader(HttpHeaders_1.default.CONTENT_LENGTH, buffer.byteLength);
        return this.end(buffer, encoding);
    }
    /**
     * 执行http重定向
     * @param response
     */
    sendRedirect(url, status = 302) {
        this.nativeResponse.writeHead(status, { 'Location': url });
    }
    getLastModifiedTime() {
        const n = this.getHeaderValue(HttpHeaders_1.default.LAST_MODIFIED)[0];
        const date = new Date(n);
        return date;
    }
    setServletContext(context) {
        Object.defineProperty(this, servletContextSymbol, {
            value: context,
            writable: false,
            enumerable: false,
            configurable: false,
        });
    }
    constructor(response) {
        this.nativeResponse = response;
    }
}
exports.default = HttpServletResponse;