tplus-pos/dist/log/LogAopFactory.js

pos module

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');

var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

exports.default = function (proxyName) {

    //输出方法名
    function printMethodName(name, originFun) {
        var methodName = _FuncUtil2.default.getFnName(originFun);
        console.log(name + ' \u65B9\u6CD5\u540D ' + methodName);
    }

    //输出参数名
    function printArgument(name, argsNames, args) {
        var i = void 0,
            length = args.length;
        for (i = 0; i < length; i++) {
            console.log(name + ' \u53C2\u6570' + (i + 1) + ' ' + argsNames[i] + ':', (0, _mobx.isObservable)(args[i]) ? (0, _mobx.toJS)(args[i]) : args[i]);
        }
    }

    //打印函数执行结果和消耗时间
    function printMethodExeTime(name, startTime, endTime, result) {
        var costTime = endTime - startTime;
        console.log(name + ' \u51FD\u6570\u6267\u884C\u7ED3\u679C ', result);
        console.log(name + ' \u51FD\u6570\u6D88\u8017\u65F6\u95F4 ', costTime + 'ms');
    }

    // 包裹方法，在原方法前后增加执行方法
    function proxyWrapped(originFun) {
        var argsNames = _FuncUtil2.default.getArgs(originFun);
        printMethodName(proxy.name, originFun);
        //判断是否是同步函数
        if (_FuncUtil2.default.isAsyncFunction(originFun)) {
            return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
                var startTime,
                    result,
                    endTime,
                    _args = arguments;
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                printArgument(proxy.name, argsNames, _args);
                                startTime = new Date().getTime();
                                _context.next = 4;
                                return originFun.apply(this, _args);

                            case 4:
                                result = _context.sent;
                                endTime = new Date().getTime();

                                printMethodExeTime(proxy.name, startTime, endTime, result);
                                return _context.abrupt('return', result);

                            case 8:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, this);
            }));
        } else {
            return function () {
                printArgument(proxy.name, argsNames, arguments);
                var startTime = new Date().getTime();
                var result = originFun.apply(this, arguments);
                var endTime = new Date().getTime();
                printMethodExeTime(proxy.name, startTime, endTime, result);
                return result;
            };
        }
    }

    var proxy = {
        // 添加被代理方法，参数a为被代理方法，参数b为目标对象
        add: function add(a, b) {
            var funName, index;
            // 不传对象时默认为window对象
            b = b || window;
            // 判断参数a类型，如果为正则表达式
            if ((typeof a === 'undefined' ? 'undefined' : (0, _typeof3.default)(a)) == "object" && a.test) {
                // 替换所以满足正则表达式的方法
                (0, _getOwnPropertyNames2.default)(b.__proto__).forEach(function (methodName) {
                    if (a.test(methodName)) {
                        b[methodName] = proxyWrapped(b[methodName]);
                    }
                });
            } else if (typeof b == "function" && typeof a == "string") {
                b[a] = proxyWrapped(b[a]);
            }
            return this;
        },
        // 默认标识
        name: '代理方法'
    };

    if (typeof proxyName == 'string') {
        proxy.name = proxyName;
    }

    return proxy;
};

var _FuncUtil = require('../util/FuncUtil');

var _FuncUtil2 = _interopRequireDefault(_FuncUtil);

var _mobx = require('mobx');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
//# sourceMappingURL=LogAopFactory.js.map