apis-scf-nodejs/src/helper.js

Apis Serverless Compute Function NodeJS Package

//
const os          = require( 'os' );
//
const stream      = require( 'stream' );
//
const Apis        = require( 'apis-core-nodejs' );
//
const ArtTemplate = require( 'art-template' );
//
const Minify      = require( 'html-minifier' );
//
const Cookie      = require( 'cookie' );
//
const Redis       = require( 'ioredis' );
//
const Busboy      = require( 'busboy' );
//
const Xml2Js      = require( 'xml2js' );
//
const LibsCache   = require( './libs/cache' );

const HelperError = {
    /**
     * 异常
     * @param message
     * @param name
     * @param code
     */
    exception : function( message, name = 'ApisException', code = 0 )
    {
        this.message = message;
        this.name    = name;
        this.code    = code;
        this.stack   = (new Error()).stack;
    }
};

const HelperMiddleware = {
    /**
     * 验证登录
     */
    verifyLogin          : async function( requestData, skipScene = [] )
    {
        //方式
        let _session_method = CONFIG[ 'Base' ].session.method;

        //cookie名称
        let _cookie_name = CONFIG[ 'Base' ].session.name;

        //登录数据
        let _login_data = null;

        //跳过场景
        if( skipScene.length >= 1 && skipScene.indexOf( requestData.path.method ) !== -1 )
        {
            return requestData;
        }

        //判断cookie name
        if( !requestData.cookie.hasOwnProperty( _cookie_name ) )
        {
            throw new HelperError.exception( '' + _cookie_name + ' 不能为空', 'login' );
        }

        //根据不同方式获取数据
        if( 'cookie' === _session_method )
        {
            _login_data = JSON.parse( requestData.cookie[ _cookie_name ] );
        }
        else if( 'cache' === _session_method )
        {
            _login_data = await HelperCache.get( requestData.cookie[ _cookie_name ] );
            if( Apis.Utils.Base.isEmpty( _login_data ) )
            {
                throw new HelperError.exception( '获取登录数据失败', 'login' );
            }
        }
        else
        {
            throw new HelperError.exception( '登录数据存储方式异常', 'login' );
        }

        //状态
        if( Apis.Utils.Base.checkFailure( _login_data.login.status ) )
        {
            throw new HelperError.exception( '登录状态失效', 'login' );
        }

        //过期时间
        if( Number( _login_data.login.expiration_time ) < Apis.Utils.Time.getTimestamp() )
        {
            throw new HelperError.exception( '登录过期失效', 'login' );
        }

        //登录数据赋值
        requestData.session = _login_data;

        return requestData;
    },
    /**
     * 验证签名
     * @param requestData
     * @param skipScene
     * @returns {{result: null, message: string, status: boolean}}
     */
    verifySignature      : async function( requestData, skipScene = [] )
    {
        // 没有开启，跳过
        if( CONFIG[ 'Base' ].request.verify.enable !== true )
        {
            return requestData;
        }

        // 不是来自网关，跳过
        if( !HelperBase.checkRequestIsApiGateway( requestData.header ) )
        {
            return requestData;
        }

        // 跳过场景
        if( skipScene.length >= 1 && skipScene.indexOf( requestData.path.method ) !== -1 )
        {
            return requestData;
        }
        //Apis.Utils.Base.log( requestData, '验证签名请求数据' );

        // 判断必须数据是否存在
        let _request_signature = null;
        if( requestData.header.hasOwnProperty( 'x-apis-request-signature' ) )
        {
            _request_signature = requestData.header[ 'x-apis-request-signature' ];
        }
        else if( requestData.all.hasOwnProperty( 'x-apis-request-signature' ) )
        {
            _request_signature = requestData.all[ 'x-apis-request-signature' ];

            //删除all中的x-apis-request-signature，不参与签名计算
            delete requestData.all[ 'x-apis-request-signature' ];
        }
        else
        {
            throw new Error( 'x-apis-request-signature不能为空' );
        }

        //
        let _request_time = null;
        if( requestData.header.hasOwnProperty( 'x-apis-request-time' ) )
        {
            _request_time = requestData.header[ 'x-apis-request-time' ];
        }
        else if( requestData.all.hasOwnProperty( 'x-apis-request-time' ) )
        {
            _request_time = requestData.all[ 'x-apis-request-time' ];

            //删除all中的x-apis-request-time，不参与签名计算
            delete requestData.all[ 'x-apis-request-time' ];
        }
        else
        {
            throw new Error( 'x-apis-request-time不能为空' );
        }
        //判断请求时间是否过期
        let _now_time    = Number( Apis.Utils.Time.getTimestamp() );
        let _expire_time = Number( Number( _request_time ) + Number( CONFIG[ 'Base' ].request.verify.config.expire ) );
        if( _expire_time < _now_time )
        {
            throw new Error( '请求过期' );
        }

        //
        let _request_rand = null;
        if( requestData.header.hasOwnProperty( 'x-apis-request-rand' ) )
        {
            _request_rand = requestData.header[ 'x-apis-request-rand' ];
        }
        else if( requestData.all.hasOwnProperty( 'x-apis-request-rand' ) )
        {
            _request_rand = requestData.all[ 'x-apis-request-rand' ];

            //删除all中的x-apis-request-rand，不参与签名计算
            delete requestData.all[ 'x-apis-request-rand' ];
        }
        else
        {
            throw new Error( 'x-apis-request-rand不能为空' );
        }

        // signature
        let _signature_data   = Object.assign( requestData.all, {
            _method   : requestData.server.method,
            _protocol : requestData.server.protocol,
            _host     : requestData.server.host,
            _path     : requestData.server.path,
            _time     : _request_time,
            _rand     : _request_rand
        } );
        let _verify_signature = Apis.Utils.Security.signatureVerify( CONFIG[ 'Base' ].request.verify.config.method, _request_signature, _signature_data, CONFIG[ 'Base' ].request.verify.config.key );
        if( Apis.Utils.Base.checkFailure( _verify_signature ) )
        {
            throw new Error( '请求签名验证失败' );
        }

        return requestData;
    },
    /**
     * 验证来源
     * @param requestData
     * @param skipScene
     * @returns {{result: null, message: string, status: boolean}}
     */
    verifyReferer        : async function( requestData, skipScene = [] )
    {
        // 跳过场景
        if( skipScene.length >= 1 && skipScene.indexOf( requestData.path.method ) !== -1 )
        {
            return requestData;
        }

        if( requestData.server.referer.length >= 1 && requestData.server.referer.indexOf( CONFIG[ 'Base' ].base.domain ) !== -1 )
        {
            return requestData;
        }

        throw new Error( '请求来源验证失败' );
    },
    /**
     * 请求数据解析json
     * @param requestData
     * @returns {*}
     */
    requestDataJsonParse : async function( requestData )
    {
        //处理all数据
        let _all_data = requestData.all;
        for( let key in _all_data )
        {
            if( !_all_data.hasOwnProperty( key ) )
            {
                continue;
            }

            //是否json，转换
            if( Apis.Utils.Base.isJson( _all_data[ key ] ) )
            {
                requestData.all[ key ] = JSON.parse( _all_data[ key ] );
            }
        }

        //处理post数据
        let _post_data = requestData.post;
        for( let key in _post_data )
        {
            if( !_post_data.hasOwnProperty( key ) )
            {
                continue;
            }

            //是否json，转换
            if( Apis.Utils.Base.isJson( _post_data[ key ] ) )
            {
                requestData.post[ key ] = JSON.parse( _post_data[ key ] );
            }
        }

        return requestData;
    },
    /**
     * 验证语言
     * @param requestData
     */
    verifyLanguage       : async function( requestData )
    {
        // 允许的语言数组
        let _language_list = [
            'zh-cn',
            'en-us',
            'zh-tw'
        ];

        // 默认语言
        let _language_default = 'zh-cn';

        // 语言cookie名称
        let _cookie_name = 'language';

        //
        let _language_value = null;
        if( requestData.all.hasOwnProperty( _cookie_name ) )
        {
            // 使用参数指定语言
            _language_value = requestData.all[ _cookie_name ];
        }
        else
        {
            if( requestData.cookie.hasOwnProperty( _cookie_name ) )
            {
                // 使用cookie指定语言
                _language_value = requestData.cookie[ _cookie_name ];
            }
            else
            {
                // 侦测语言
                _language_value = Apis.Utils.Base.getAcceptLanguage( _language_list, requestData.client.language );
            }
        }

        // 判断语言是否在合法语言列表中，不存在就用默认值
        if( _language_list.indexOf( _language_value ) === -1 )
        {
            _language_value = _language_default;
        }

        // 设置cookie语言
        HelperCookie.set( _cookie_name, _language_value );

        // 加载远程语言


        return requestData;
    }
};

const HelperCookie = {
    data   : [],
    set    : function( name, data, time )
    {
        //是否加密
        if( CONFIG[ 'Base' ].cookie.encryption.enable === true )
        {
            //开头加@#@识别是否加密
            data = '@#@' + Apis.Utils.Security.encrypt( 'aes-128-ecb', JSON.stringify( data ), CONFIG[ 'Base' ].cookie.encryption.key, {} );
        }

        //
        let _options    = JSON.parse( JSON.stringify( CONFIG[ 'Base' ].cookie.config ) );
        _options.maxAge = time
                          ? time
                          : CONFIG[ 'Base' ].cookie.config.maxAge;

        //
        let _item = Cookie.serialize( name, data, _options );

        //
        this.data.push( _item );

        //
        return this;
    },
    delete : function( name )
    {
        let _options    = JSON.parse( JSON.stringify( CONFIG[ 'Base' ].cookie.config ) );
        _options.maxAge = -1;

        //
        let _item = Cookie.serialize( name, null, _options );

        //
        this.data.push( _item );

        //
        return this;
    }
};

const HelperBase = {
    /**
     * 生成请求数据
     * @param requestData
     * @returns Object
     */
    buildRequestData                     : async function( requestData )
    {
        //初始化
        let _result = {
            get    : {},
            post   : {},
            all    : {},
            header : {},
            cookie : {},
            files  : [],
            server : {
                protocol : '',
                host     : '',
                path     : '',
                method   : '',
                referer  : '',
            },
            client : {
                ip       : '',
                agent    : '',
                language : '',
            },
            path   : {
                method     : '',//aaa.bbb.ccc.ddd
                module     : '',//aaa
                model      : '',//bbb
                action     : '',//ccc.ddd
            },
        };

        //==============================================================
        // server和client
        //==============================================================
        if( requestData.headers )
        {
            //protocol
            _result.server.protocol = requestData.headers[ 'x-api-scheme' ]
                                      ? requestData.headers[ 'x-api-scheme' ]
                                      : '';
            //host，判断是否带端口
            _result.server.host     = (requestData.headers.host.indexOf( ':' ) >= 0)
                                      ? requestData.headers.host.split( ':' )[ 0 ]
                                      : requestData.headers.host;
            //referer
            _result.server.referer  = requestData.headers.referer
                                      ? requestData.headers.referer
                                      : '';
            //path
            _result.server.path     = requestData.path
                                      ? requestData.path
                                      : '';
            //method
            _result.server.method   = requestData.httpMethod
                                      ? requestData.httpMethod.toUpperCase()
                                      : '';
            //ip
            _result.client.ip       = (requestData.requestContext && requestData.requestContext.hasOwnProperty( 'sourceIp' ))
                                      ? requestData.requestContext.sourceIp
                                      : '127.0.0.1';
            //user-agent
            _result.client.agent    = requestData.headers[ 'user-agent' ]
                                      ? requestData.headers[ 'user-agent' ]
                                      : '';
            //language
            _result.client.language = requestData.headers[ 'accept-language' ]
                                      ? requestData.headers[ 'accept-language' ].toLowerCase()
                                      : 'zh-cn';
        }

        //==============================================================
        // 触发（腾讯云SCF）
        //==============================================================
        /*{
         Message: '{\r\n    method:"notice.data.send"\r\n}',
         Time: '2022-04-17T22:24:35Z',
         TriggerName: 'SCF-timer-1650234003',
         Type: 'Timer'
         }*/
        if( requestData.Message )
        {
            let _temp         = requestData.Message;
            //去掉换行
            _temp             = _temp.replace( /\r\n/g, '' );
            _temp             = _temp.replace( /\n/g, '' );
            //去掉空格
            _temp             = _temp.replace( /\s+/g, '' );
            let _message_data = {};
            let _object_data  = JSON.parse( _temp );
            for( let key in _object_data )
            {
                if( !_object_data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //
                _message_data[ key ] = decodeURIComponent( _object_data[ key ] );
            }

            //追加到（all）
            _result.all = Object.assign( _result.all, _message_data );
        }

        //==============================================================
        // headers
        //==============================================================
        if( requestData.headers || requestData.headerParameters )
        {
            let _header_data = {};
            let _object_data = Object.assign( {}, requestData.headers, requestData.headerParameters );
            for( let key in _object_data )
            {
                if( !_object_data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //
                _header_data[ key ] = _object_data[ key ];
            }

            //header
            _result.header = _header_data;
        }

        //==============================================================
        // cookie
        //==============================================================
        if( requestData.headers && requestData.headers.cookie )
        {
            //解析
            let _cookie_object = Cookie.parse( requestData.headers.cookie );

            //是否加密
            if( CONFIG[ 'Base' ].cookie.encryption.enable === true )
            {
                for( let key in _cookie_object )
                {
                    if( !_cookie_object.hasOwnProperty( key ) )
                    {
                        continue;
                    }

                    //
                    let _temp_data = _cookie_object[ key ];

                    //判断是否@#@开头
                    if( _temp_data.substr( 0, 3 ) === '@#@' )
                    {
                        try
                        {
                            //去掉@#@
                            _temp_data = _temp_data.substr( 3 );

                            //解密
                            _temp_data = Apis.Utils.Security.decrypt( 'aes-128-ecb', _temp_data, CONFIG[ 'Base' ].cookie.encryption.key, {} );
                        }
                        catch( e )
                        {
                            Apis.Utils.Base.log( _temp_data, 'Cookie解密失败', 'error' );
                        }
                    }

                    //解析
                    _cookie_object[ key ] = JSON.parse( _temp_data );
                }
            }

            //
            _result.cookie = _cookie_object;
        }

        //==============================================================
        // get
        //==============================================================
        if( requestData.queryString || requestData.queryStringParameters || requestData.pathParameters )
        {
            let _get_data    = {};
            //let _object_data = Object.assign( {}, requestData.queryString, requestData.queryStringParameters, requestData.pathParameters );
            let _object_data = {};
            if( requestData.queryString )
            {
                _object_data = Object.assign( _object_data, requestData.queryString );
            }
            if( requestData.queryStringParameters )
            {
                _object_data = Object.assign( _object_data, requestData.queryStringParameters );
                //删除method，防止混入后续的.all中
                if( _object_data.hasOwnProperty( 'method' ) )
                {
                    delete _object_data[ 'method' ];
                }
            }
            if( requestData.pathParameters )
            {
                _object_data = Object.assign( _object_data, requestData.pathParameters );
                //删除method，防止混入后续的.all中
                if( _object_data.hasOwnProperty( 'method' ) )
                {
                    delete _object_data[ 'method' ];
                }
            }

            for( let key in _object_data )
            {
                if( !_object_data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //
                let _value = _object_data[ key ];

                //排除首字符非字母的参数
                let _first_rule = /^[a-zA-Z]/;
                if( !_first_rule.test( key ) )
                {
                    continue;
                }

                //排除包含大写字母的参数
                let _uppercase_rule = /[A-Z]/;
                if( _uppercase_rule.test( key ) )
                {
                    continue;
                }

                //排除值为空的参数
                if( Apis.Utils.Base.isEmpty( _value, false ) )
                {
                    continue;
                }

                //转码
                _value = decodeURIComponent( _value );

                //过滤
                if( CONFIG[ 'Base' ].request.filter.exclude.indexOf( key ) === -1 )
                {
                    _value = Apis.Utils.String.filter( _value );
                }

                //最后赋值
                _get_data[ key ] = _value;
            }

            //GET
            _result.get = _get_data;

            //追加到all
            _result.all = Object.assign( _result.all, _get_data );
        }

        //==============================================================
        // 上传
        //==============================================================
        if( requestData.headers && requestData.headers.hasOwnProperty( 'content-type' ) && requestData.headers[ 'content-type' ].indexOf( 'multipart/form-data' ) >= 0 )
        {
            //处理
            await this._buildUploadData( requestData.body, requestData.headers )
                      .then( function( res, rej )
                             {
                                 _result.files = res;
                             } );

            //设为空，防止后续post处理
            requestData.body = null;
        }

        //==============================================================
        // post
        //==============================================================
        if( requestData.body )
        {
            let _post_data = {};

            //判断body是否base64
            if( requestData.isBase64Encoded === true )
            {
                //解码
                let _temp_buffer = Buffer.from( requestData.body, 'base64' );
                //判断是否还是base64，如果是在解码一次
                if( Apis.Utils.Base.isBase64( _temp_buffer ) )
                {
                    _temp_buffer = Buffer.from( _temp_buffer, 'base64' );
                }
                requestData.body = _temp_buffer.toString();
            }

            //判断是否xml
            let _prefix = requestData.body.substring( 1, 4 );
            if( _prefix === 'xml' )
            {
                console.log( '请求是XML数据' );
                let _temp = requestData.body;
                //去掉换行
                _temp     = _temp.replace( /\r\n/g, '' );
                _temp     = _temp.replace( /\n/g, '' );
                //转义
                //_temp = _temp.replace(/</g,"&lt;");
                //_temp = _temp.replace(/>/g,"&gt;");
                //console.log(_temp);
                //xml转json
                let _parser     = new Xml2Js.Parser( { explicitArray : false } );
                //xml转对象
                let _xml2object = null;
                _parser.parseString( _temp, function( err, res )
                {
                    _xml2object = res;
                } );
                //console.log('_xml2object');
                //console.log(_xml2object);
                //console.log('_xml2object');
                //console.log(_xml2object);
                //对象转查询字符串
                requestData.body = Apis.Utils.String.objectToQueryString( _xml2object.xml );
            }

            //转数组
            let _post_array = requestData.body.split( '&' );
            for( let i = 0; i < _post_array.length; i++ )
            {
                //转数组[0]=key；[1]=value
                let _temp = _post_array[ i ].split( '=' );

                //排除首字符非字母的参数
                let _first_rule = /^[a-zA-Z]/;
                if( !_first_rule.test( _temp[ 0 ] ) )
                {
                    continue;
                }

                //排除包含大写字母的参数
                let _uppercase_rule = /[A-Z]/;
                if( _uppercase_rule.test( _temp[ 0 ] ) )
                {
                    continue;
                }

                //排除值为空的参数
                if( Apis.Utils.Base.isEmpty( _temp[ 1 ], false ) )
                {
                    continue;
                }

                //+号转空格
                _temp[ 1 ] = _temp[ 1 ].replace( /\+/g, '%20' );

                //转码
                _temp[ 1 ] = decodeURIComponent( _temp[ 1 ] );

                //过滤
                if( CONFIG[ 'Base' ].request.filter.exclude.indexOf( _temp[ 0 ] ) === -1 )
                {
                    _temp[ 1 ] = Apis.Utils.String.filter( _temp[ 1 ] );
                }

                //赋值
                _post_data[ _temp[ 0 ] ] = _temp[ 1 ];
            }

            //POST
            _result.post = _post_data;

            //追加到all
            _result.all = Object.assign( _result.all, _post_data );
        }

        //==============================================================
        // 处理path
        //==============================================================
        // 初始化
        _result.path.method = 'init.init.init.init';

        // path传值，格式：aa/bb/cc
        if( requestData.pathParameters )
        {
            // aaa/bbb/ccc 转 aaa.bbb.ccc 格式
            if( !Apis.Utils.ArrayObject.objectPropertyNotSetOrEmpty( requestData.pathParameters, 'method' ) )
            {
                // 把/换成.格式aaa/bbb/ccc换成aaa.bbb.ccc
                _result.path.method = String( requestData.pathParameters.method )
                    .replace( /\//g, '.' );
            }
        }

        // post、get传值，格式：aa.bb.cc.dd.ee
        if( !Apis.Utils.ArrayObject.objectPropertyNotSetOrEmpty( _result.all, 'method' ) )
        {
            _result.path.method = String( _result.all.method ).replace( /\//g, '.' );
        }

        //aa.bb.cc.dd转数组
        let _path_array = _result.path.method.split( '.' );
        //路径例子：passport/account/password/update

        //第1个.之前的是module，转驼峰user-abc转UserAbc
        _result.path.module     = _path_array[ 0 ]
                                  ? Apis.Utils.String.stringToCamel( _path_array[ 0 ] )
                                  : 'Init';
        //第1个.和第2个.之间的是model，转驼峰user-abc转UserAbc
        _result.path.model      = _path_array[ 1 ]
                                  ?  Apis.Utils.String.stringToCamel( _path_array[ 1 ] )
                                  : 'Init';
        //第2个.之后的所有都算做action，转驼峰user-abc转UserAbc，再将首字母转小写userAbc
        //_result.path.action     = _path_array[ 2 ] ? _path_array[ 2 ] : 'init';
        _result.path.action     = _path_array[ 2 ]
                                  ? Apis.Utils.String.firstLetterToLowerCase( Apis.Utils.String.stringToCamel( _path_array[ 2 ] ) )
                                  : 'init';

        //controller名字，拼接成UserAbc
        _result.path.controller_name = _result.path.module + _result.path.model;

        //action名字，拼接成userAbcAction
        _result.path.action_name = _result.path.action + 'Action';

        //==============================================================
        // 返回
        //==============================================================
        return _result;
    },
    /**
     * 生成上传数据
     * @param requestBody
     * @param requestHeaders
     * @returns {Promise<>}
     * @private
     */
    _buildUploadData                     : async function( requestBody, requestHeaders )
    {
        let _result = [];
        let _busboy = new Busboy( { headers : requestHeaders } );

        return new Promise( ( resolve, reject ) =>
                            {
                                /**
                                 * busboy 需要 stream pipe 的方式来进行处理，
                                 * 我们将 body 解码为 buffer后，
                                 * 转换为 stream，最终 pipe 给 busbody
                                 */
                                let _body_buffer   = Buffer.from( requestBody, 'base64' );
                                let _buffer_stream = new stream.PassThrough();
                                _buffer_stream.end( _body_buffer );
                                _buffer_stream.pipe( _busboy );

                                //接受到文件
                                _busboy.on( 'file', ( fieldname, file, filename, encoding, mimetype ) =>
                                {
                                    let buf = Buffer.alloc( 0 );
                                    //console.log( 'File [' + fieldname + ']: filename: ' + filename + ', encoding: ' + encoding + ', mimetype: ' + mimetype );

                                    //接受到文件的数据块，拼接出完整的 buffer
                                    file.on( 'data', function( data )
                                    {
                                        buf = Buffer.concat( [
                                                                 buf,
                                                                 data
                                                             ] );
                                    } );

                                    //文件的数据块接受完毕，生成字符串
                                    file.on( 'end', function()
                                    {
                                        if( filename.length !== 0 )
                                        {
                                            //临时路径
                                            let _file_path        = os.tmpdir() + '/' + filename;
                                            //
                                            let _file_data_base64 = buf.toString( 'base64' );
                                            //
                                            let _file_data_buffer = Buffer.from( _file_data_base64, 'base64' );
                                            //创建文件
                                            Apis.Utils.File.create( _file_path, _file_data_buffer );
                                            //
                                            _result.push( {
                                                              name     : filename,
                                                              encoding : encoding,
                                                              mimetype : mimetype,
                                                              path     : _file_path
                                                          } );
                                        }

                                    } );
                                } );

                                //完成
                                _busboy.on( 'finish', function()
                                {
                                    //Apis.Utils.Base.log( _result, 'Parse form complete' );
                                    resolve( _result );
                                } );

                                //错误
                                _busboy.on( 'error', function( err )
                                {
                                    reject( err );
                                } );
                            } );
    },
    /**
     * 生成输出配置
     * @param requestData
     */
    buildResponseConfig                  : async function( requestData )
    {
        let _result = {
            output_type   : 'call',
            output_format : 'json',
            output_style  : 'apis',
        };

        //类型，请求是来自函数call还是来自gateway
        if( this.checkRequestIsApiGateway( requestData.header ) )
        {
            _result.output_type = 'gateway';
        }

        //格式
        if( requestData.all.hasOwnProperty( 'output_format' ) )
        {
            _result.output_format = requestData.all.output_format;
        }

        //样式
        if( requestData.all.hasOwnProperty( 'output_style' ) )
        {
            _result.output_style = requestData.all.output_style;
        }

        //加密
        if( CONFIG[ 'Base' ].response.encrypt.enable )
        {
            _result.output_encrypt = CONFIG[ 'Base' ].response.encrypt;
        }

        return _result;
    },
    /**
     * 输出
     * @param status
     * @param data
     * @param message
     * @param options
     * @param code
     * @returns {{isBase64Encoded: boolean, headers: *, body: *, statusCode: *}|string}
     */
    getResponseData                      : function( status = 'f', data = null, message = 'done', options = {}, code = 0 )
    {
        // 变量
        let _result;

        // 状态
        if( Apis.Utils.Base.checkSuccess( status ) )
        {
            status = 'success';
        }
        else
        {
            status = 'failure';
        }

        // headers
        let _output_headers = JSON.parse( JSON.stringify( CONFIG[ 'Base' ].response.headers ) );
        if( options.hasOwnProperty( 'output_headers' ) )
        {
            _output_headers = Object.assign( _output_headers, options.output_headers );
        }

        // cookie
        if( HelperCookie.data.length >= 1 )
        {
            //赋值
            _output_headers[ 'set-cookie' ] = HelperCookie.data;

            //恢复初始化，设置空
            HelperCookie.data = [];
        }

        // 格式
        switch( options.output_format )
        {
            case 'json':
                //
                _output_headers[ 'content-type' ] = 'application/json;charset=utf-8';

                //
                if( 'yida_gateway' === options.output_style )
                {
                    //阿里宜搭（网关）格式
                    _result = this._getResponseDataStyleByYiDaGateway( status, data, message );
                }
                else if( 'yida_options' === options.output_style )
                {
                    //阿里宜搭（选项）格式
                    _result = this._getResponseDataStyleByYiDaOptions( status, data, message );
                }
                else if( 'suda_search' === options.output_style )
                {
                    //百度速搭（search）格式
                    _result = this._getResponseDataStyleBySuDaGateway( status, data, message );
                }
                else if( 'suda_options' === options.output_style )
                {
                    //百度速搭（选项）格式
                    _result = this._getResponseDataStyleBySuDaOptions( status, data, message );
                }
                else if( 'weda_options' === options.output_style )
                {
                    //腾讯微搭（选项）格式
                    _result = this._getResponseDataStyleByWeDaOptions( status, data, message );
                }
                else if( 'miniui_options' === options.output_style )
                {
                    //miniui（选项）格式
                    _result = this._getResponseDataStyleByMiniUIOptions( status, data, message, code );
                }
                else if( 'uni_options' === options.output_style )
                {
                    //uniapp（选项）格式
                    _result = this._getResponseDataStyleByUniOptions( status, data, message, code );
                }
                else
                {
                    //默认格式
                    _result = this._getResponseDataStyleByApis( status, data, message, code, options );
                }

                _result = JSON.stringify( _result );

                break;
            case 'html':
                _output_headers[ 'content-type' ] = 'text/html;charset=utf-8';
                _result                           = data;
                break;
            case 'text':
                _output_headers[ 'content-type' ] = 'text/plain';
                _result                           = data;
                break;
            default:
                break;
        }

        // 返回
        if( 'gateway' === options.output_type )
        {
            let _status_code = (_output_headers.hasOwnProperty( 'Location' ) || _output_headers.hasOwnProperty( 'location' ))
                               ? 301
                               : 200;
            return {
                'isBase64Encoded' : false,
                'statusCode'      : _status_code,
                'headers'         : _output_headers,
                'body'            : _result
            }
        }
        else
        {
            return _result;
        }
    },
    _getResponseDataStyleByYiDaGateway   : function( status, data, message )
    {
        //阿里宜搭（网关）格式
        let _result = {};
        if( status === 'success' )
        {
            _result.success   = true;
            _result.content   = data;
            _result.errorCode = '';
            _result.errorMsg  = message;
        }
        else
        {
            _result.success   = false;
            _result.content   = false;
            _result.errorCode = '';
            _result.errorMsg  = message;
        }
        return _result;
    },
    _getResponseDataStyleByYiDaOptions   : function( status, data, message )
    {
        let _result       = {};
        let _options_data = [];
        if( 'success' === status )
        {
            //循环处理
            for( let key in data )
            {
                if( !data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //默认值
                if( data[ key ].hasOwnProperty( 'default' ) )
                {
                    if( data[ key ].default === true )
                    {
                        data[ key ].defaultChecked = true;
                    }

                    //删除原始属性
                    delete data[ key ].default;
                }
            }
            //对象转数组
            _options_data     = Apis.Utils.ArrayObject.objectToArray( data );
            //
            _result.success   = true;
            _result.content   = { options : _options_data };
            _result.errorCode = '';
            _result.errorMsg  = message;
        }
        else
        {
            _result.success   = false;
            _result.content   = { options : _options_data };
            _result.errorCode = '';
            _result.errorMsg  = message;
        }
        return _result;
    },
    _getResponseDataStyleBySuDaGateway   : function( status, data, message )
    {
        let _result = {};
        if( status === 'success' )
        {
            _result.status = 0;
            _result.msg    = message;
            _result.data   = data;
        }
        else
        {
            _result.status = -1;
            _result.msg    = message;
            _result.data   = {};
        }
        return _result;
    },
    _getResponseDataStyleBySuDaOptions   : function( status, data, message )
    {
        let _result       = {};
        let _options_data = [];
        if( 'success' === status )
        {
            //循环处理
            for( let key in data )
            {
                if( !data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //text换成label
                data[ key ].label = data[ key ].text;
                delete data[ key ].text;
            }

            //对象转数组
            _options_data = Apis.Utils.ArrayObject.objectToArray( data );

            //
            _result.status = 0;
            _result.data   = { options : _options_data };
            _result.msg    = message;
        }
        else
        {
            _result.status = -1;
            _result.data   = { options : [] };
            _result.msg    = message;
        }
        return _result;
    },
    _getResponseDataStyleByWeDaOptions   : function( status, data, message )
    {
        let _result       = {};
        let _options_data = [];
        if( 'success' === status )
        {
            //循环处理
            for( let key in data )
            {
                if( !data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //text换成label
                data[ key ].label = data[ key ].text;
                delete data[ key ].text;
            }

            //对象转数组
            _options_data = Apis.Utils.ArrayObject.objectToArray( data );

            //
            _result.result = _options_data;

        }
        else
        {
            _result.result = [];
        }

        //
        _result.status  = status;
        _result.message = message;

        return _result;
    },
    _getResponseDataStyleByMiniUIOptions : function( status, data, message, code )
    {
        let _result = {};
        if( 'success' === status )
        {
            //循环处理
            for( let key in data )
            {
                if( !data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //追加
                data[ key ].id = data[ key ].value;
            }

            //
            _result.status  = status;
            _result.code    = code;
            _result.result  = Apis.Utils.ArrayObject.objectToArray( data );
            _result.message = message;
        }
        else
        {
            _result.status  = status;
            _result.code    = code;
            _result.result  = null;
            _result.message = message;
        }

        return _result;
    },
    _getResponseDataStyleByUniOptions    : function( status, data, message, code )
    {
        let _result = {};
        if( 'success' === status )
        {
            //循环处理
            for( let key in data )
            {
                if( !data.hasOwnProperty( key ) )
                {
                    continue;
                }

                //追加
                data[ key ].id    = ('' + data[ key ].value).toString();
                data[ key ].value = ('' + data[ key ].value).toString();
                data[ key ].label = data[ key ].text;
            }

            //
            _result.status  = status;
            _result.code    = code;
            _result.result  = Apis.Utils.ArrayObject.objectToArray( data );
            _result.message = message;
        }
        else
        {
            _result.status  = status;
            _result.code    = code;
            _result.result  = null;
            _result.message = message;
        }

        return _result;
    },
    _getResponseDataStyleByApis          : function( status, data, message, code, options )
    {
        let _result = {
            status  : status,
            result  : data,
            code    : code,
            message : message
        };

        //固定result的值
        if( Apis.Utils.Base.isEmpty( _result.result, false ) )
        {
            _result.result = null;
        }

        //是否加密
        if( options.hasOwnProperty( 'output_encrypt' ) && options.output_encrypt.enable === true )
        {
            _result.result = Apis.Utils.Security.encrypt( options.output_encrypt.method, JSON.stringify( data ), options.output_encrypt.config[ options.output_encrypt.method ].key, options.output_encrypt.config[ options.output_encrypt.method ] );
        }

        //
        return _result;
    },
    /**
     * 判断请求是否是通过网关来的
     * @param data
     * @returns {boolean}
     */
    checkRequestIsApiGateway             : function( data )
    {
        // 包含requestsource=APIGW说明是从api来的请求
        return data.hasOwnProperty( 'requestsource' ) && data.requestsource === 'APIGW';
    },
    /**
     * 替换模板
     * @param data 模板变量对象
     * @param path 模板html
     * @returns {string}
     */
    renderTemplate                       : function( data, path )
    {
        let _result = '';

        // 配置（关闭调试）
        ArtTemplate.defaults.debug = false;

        // 渲染
        _result = ArtTemplate( path, data );

        // 压缩
        _result = Minify.minify( _result, {
            //去掉注释
            removeComments     : true,
            //去掉空格
            collapseWhitespace : true,
            //压缩js
            minifyJS           : true,
            //压缩css
            minifyCSS          : true
        } );

        // 返回
        return _result;
    }
};

const HelperOptions = {
    /**
     * 获取配置对象默认值
     * @param objectData
     * @returns {*|string}
     */
    getOptionsDefaultValue  : function( objectData )
    {
        return Apis.Utils.ArrayObject.findObjectAttributeValueByAttributeValue( objectData, 'default', true, 'value' );
    },
    /**
     * 判断值是否在配置数据中
     * @param objectData
     * @param value
     * @param field
     * @returns {boolean}
     */
    checkValueInOptions     : function( objectData, value, field )
    {
        let _field = arguments[ 2 ]
                     ? arguments[ 2 ]
                     : 'value';

        for( let key in objectData )
        {
            if( !objectData.hasOwnProperty( key ) )
            {
                continue;
            }

            if( objectData[ key ].hasOwnProperty( 'disabled' ) && objectData[ key ][ 'disabled' ] === true )
            {
                continue;
            }

            if( objectData[ key ].hasOwnProperty( _field ) && (objectData[ key ][ _field ]).toString() === value.toString() )
            {
                return true;
            }
        }

        return false;
    },
    /**
     * 获取配置某个属性的所有值array
     * @param objectData
     * @param field
     * @returns {[]}
     */
    getOptionsAllValueArray : function( objectData, field )
    {
        let _field  = arguments[ 1 ]
                      ? arguments[ 1 ]
                      : 'value';
        let _result = [];

        for( let key in objectData )
        {
            if( !objectData.hasOwnProperty( key ) )
            {
                continue;
            }

            if( objectData[ key ].hasOwnProperty( 'disabled' ) && objectData[ key ][ 'disabled' ] === true )
            {
                continue;
            }

            if( objectData[ key ].hasOwnProperty( _field ) )
            {
                _result.push( objectData[ key ][ _field ] );
            }
        }

        return _result;
    },
    /**
     * 获取配置某个属性的所有值list
     * @param objectData
     * @param field
     * @param split
     * @returns {string}
     */
    getOptionsAllValueList  : function( objectData, field, split )
    {
        let _field = arguments[ 1 ]
                     ? arguments[ 1 ]
                     : 'value';

        let _split = arguments[ 2 ]
                     ? arguments[ 2 ]
                     : ',';

        let _result = this.getOptionsAllValueArray( objectData, _field );

        return _result.join( _split );

    }
};

const HelperCache = LibsCache;

module.exports = {
    Base       : HelperBase,
    Cache      : HelperCache,
    Middleware : HelperMiddleware,
    Options    : HelperOptions,
    Cookie     : HelperCookie
};