tsioc/lib/aop/access/AdvisorChainFactory.js

tsioc is AOP, Ioc container, via typescript decorator

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
var index_1 = require("../../core/index");
var index_2 = require("../joinpoints/index");
var index_3 = require("../../utils/index");
var AdvisorChainFactory = /** @class */ (function () {
    function AdvisorChainFactory(container, advices) {
        this.container = container;
        this.advices = advices;
    }
    AdvisorChainFactory.prototype.getAdvicers = function (adviceType) {
        return (adviceType ? this.advices[adviceType] : null) || [];
    };
    AdvisorChainFactory.prototype.invoaction = function (joinPoint, state, valueOrthrowing) {
        joinPoint.state = state;
        joinPoint.returning = undefined;
        joinPoint.throwing = undefined;
        switch (state) {
            case index_2.JoinpointState.Before:
                this.before(joinPoint);
                break;
            case index_2.JoinpointState.Pointcut:
                this.pointcut(joinPoint);
                break;
            case index_2.JoinpointState.After:
                joinPoint.returning = valueOrthrowing;
                this.after(joinPoint);
                break;
            case index_2.JoinpointState.AfterThrowing:
                joinPoint.throwing = valueOrthrowing;
                this.afterThrowing(joinPoint);
                break;
            case index_2.JoinpointState.AfterReturning:
                joinPoint.returning = valueOrthrowing;
                this.afterReturning(joinPoint);
                break;
        }
    };
    AdvisorChainFactory.prototype.before = function (joinPoint) {
        var _this = this;
        var cloneJp = Object.assign({}, joinPoint);
        this.getAdvicers('Around')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
        if (!index_3.isUndefined(cloneJp.args)) {
            joinPoint.args = cloneJp.args;
        }
        this.getAdvicers('Before')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
    };
    AdvisorChainFactory.prototype.pointcut = function (joinPoint) {
        var _this = this;
        var cloneJp = Object.assign({}, joinPoint);
        this.getAdvicers('Pointcut')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
        if (!index_3.isUndefined(cloneJp.args)) {
            joinPoint.args = cloneJp.args;
        }
    };
    AdvisorChainFactory.prototype.after = function (joinPoint) {
        var _this = this;
        var cloneJp = Object.assign({}, joinPoint);
        this.getAdvicers('Around')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
        this.getAdvicers('After')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
    };
    AdvisorChainFactory.prototype.afterThrowing = function (joinPoint) {
        var _this = this;
        var cloneJp = Object.assign({}, joinPoint);
        this.getAdvicers('Around')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
        this.getAdvicers('AfterThrowing')
            .forEach(function (advicer) {
            _this.invokeAdvice(cloneJp, advicer);
        });
    };
    AdvisorChainFactory.prototype.afterReturning = function (joinPoint) {
        var _this = this;
        var cloneJp = Object.assign({}, joinPoint);
        var advChain = this.container.resolve(index_3.symbols.IAdvisorChain, { joinPoint: cloneJp });
        this.getAdvicers('Around')
            .forEach(function (advicer) {
            advChain.next(function (jp) {
                return _this.invokeAdvice(jp, advicer);
            });
        });
        this.getAdvicers('AfterReturning')
            .forEach(function (advicer) {
            advChain.next(function (jp) {
                return _this.invokeAdvice(jp, advicer);
            });
        });
        advChain.next(function (jp) {
            if (!index_3.isUndefined(jp.returning)) {
                joinPoint.returning = jp.returning;
            }
            return joinPoint;
        });
        advChain.process();
    };
    AdvisorChainFactory.prototype.invokeAdvice = function (joinPoint, advicer) {
        var _this = this;
        var providers = [];
        providers.push(index_1.Provider.createExtends(index_2.Joinpoint, joinPoint, function (inst, provider) {
            inst._cache_JoinPoint = provider.resolve(_this.container);
        }));
        var metadata = advicer.advice;
        if (!index_3.isUndefined(joinPoint.args) && metadata.args) {
            providers.push(index_1.Provider.create(metadata.args, joinPoint.args));
        }
        if (metadata.annotationArgName) {
            providers.push(index_1.Provider.create(metadata.annotationArgName, function () {
                var curj = joinPoint;
                var annotations = curj.annotations;
                while (!annotations && joinPoint.provJoinpoint) {
                    curj = joinPoint.provJoinpoint;
                    if (curj && curj.annotations) {
                        annotations = curj.annotations;
                        break;
                    }
                }
                if (index_3.isArray(annotations)) {
                    if (metadata.annotation) {
                        var d_1 = metadata.annotation;
                        d_1 = /^@/.test(d_1) ? d_1 : "@" + d_1;
                        return annotations.filter(function (a) { return a.decorator === d_1; });
                    }
                    return annotations;
                }
                else {
                    return [];
                }
            }));
        }
        if (!index_3.isUndefined(joinPoint.returning) && metadata.returning) {
            providers.push(index_1.Provider.create(metadata.returning, joinPoint.returning));
        }
        if (!index_3.isUndefined(joinPoint.throwing) && metadata.throwing) {
            providers.push(index_1.Provider.create(metadata.throwing, joinPoint.throwing));
        }
        return (_a = this.container).syncInvoke.apply(_a, [advicer.aspectType, advicer.advice.propertyKey, null].concat(providers));
        var _a;
    };
    AdvisorChainFactory.classAnnations = { "name": "AdvisorChainFactory", "params": { "constructor": ["container", "advices"], "getAdvicers": ["adviceType"], "invoaction": ["joinPoint", "state", "valueOrthrowing"], "before": ["joinPoint"], "pointcut": ["joinPoint"], "after": ["joinPoint"], "afterThrowing": ["joinPoint"], "afterReturning": ["joinPoint"], "invokeAdvice": ["joinPoint", "advicer"] } };
    AdvisorChainFactory = __decorate([
        index_1.NonePointcut(),
        index_1.Injectable(index_3.symbols.IAdvisorChainFactory),
        __param(0, index_1.Inject(index_3.symbols.IContainer)),
        __metadata("design:paramtypes", [Object, Object])
    ], AdvisorChainFactory);
    return AdvisorChainFactory;
}());
exports.AdvisorChainFactory = AdvisorChainFactory;

//# sourceMappingURL=../sourcemaps/access/AdvisorChainFactory.js.map