@ts-ioc/logs/es2015/LoggerAspect.js

tsioc is AOP, Ioc container, via typescript decorator

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const aop_1 = require("@ts-ioc/aop");
const core_1 = require("@ts-ioc/core");
const IConfigureLoggerManager_1 = require("./IConfigureLoggerManager");
const LogFormater_1 = require("./LogFormater");
/**
 * base looger aspect. for extends your logger aspect.
 *
 * @export
 * @class LoggerAspect
 */
let LoggerAspect = class LoggerAspect {
    constructor(container, config) {
        this.container = container;
        this.config = config;
    }
    get logger() {
        if (!this._logger) {
            this._logger = this.logManger.getLogger();
        }
        return this._logger;
    }
    get logManger() {
        if (!this._logManger) {
            this._logManger = this.container.resolve(IConfigureLoggerManager_1.ConfigureLoggerManagerToken, { config: this.config });
        }
        return this._logManger;
    }
    processLog(joinPoint, annotation, message, level) {
        if (annotation && annotation.length) {
            annotation.forEach(logmeta => {
                let canlog = false;
                if (logmeta.express && logmeta.express(joinPoint)) {
                    canlog = true;
                }
                else if (!logmeta.express) {
                    canlog = true;
                }
                if (canlog) {
                    this.writeLog(logmeta.logname ? this.logManger.getLogger(logmeta.logname) : this.logger, joinPoint, this.joinMessage(message, logmeta.message), logmeta.level || level);
                }
            });
        }
        else {
            this.writeLog(this.logger, joinPoint, message, level);
        }
    }
    joinMessage(...messgs) {
        return messgs.filter(a => a).map(a => core_1.isString(a) ? a : a.toString()).join('; ');
    }
    writeLog(logger, joinPoint, message, level) {
        let formatStr = this.formatMessage(joinPoint, message);
        if (level) {
            logger[level](formatStr);
        }
        else {
            switch (joinPoint.state) {
                case aop_1.JoinpointState.Before:
                case aop_1.JoinpointState.After:
                case aop_1.JoinpointState.AfterReturning:
                    logger.debug(formatStr);
                    break;
                case aop_1.JoinpointState.Pointcut:
                    logger.info(formatStr);
                    break;
                case aop_1.JoinpointState.AfterThrowing:
                    logger.error(formatStr);
                    break;
            }
        }
    }
    formatMessage(joinPoint, message) {
        let config = this.logManger.config;
        let formater;
        config.format = config.format || LogFormater_1.LogFormaterToken;
        if (core_1.isToken(config.format)) {
            formater = this.container.getService(config.format, core_1.lang.getClass(this));
        }
        else if (core_1.isFunction(config.format)) {
            formater = { format: config.format };
        }
        else if (core_1.isObject(config.format) && core_1.isFunction(config.format.format)) {
            formater = config.format;
        }
        if (formater) {
            return formater.format(joinPoint, message);
        }
        return '';
    }
    static getClassAnnations() {
        return { "name": "LoggerAspect", "params": { "constructor": ["container", "config"], "processLog": ["joinPoint", "annotation", "message", "level"], "joinMessage": ["messgs"], "writeLog": ["logger", "joinPoint", "message", "level"], "formatMessage": ["joinPoint", "message"] } };
    }
};
LoggerAspect = tslib_1.__decorate([
    core_1.Abstract(),
    tslib_1.__metadata("design:paramtypes", [Object, Object])
], LoggerAspect);
exports.LoggerAspect = LoggerAspect;

//# sourceMappingURL=sourcemaps/LoggerAspect.js.map