****************************************
打印块信息
****************************************
491722
function block(...args) {
    info('-'.repeat(80));
    args.forEach(message => info(message));
    info('-'.repeat(80));
}
878731
private void urlWithParamIfGet() {
		if (Method.GET.equals(method) && false == this.isRest) {
			// 优先使用body形式的参数，不存在使用form
			if (ArrayUtil.isNotEmpty(this.bodyBytes)) {
				this.url = HttpUtil.urlWithForm(this.url, StrUtil.str(this.bodyBytes, this.charset), this.charset, false);
			} else {
				this.url = HttpUtil.urlWithForm(this.url, this.form, this.charset, false);
			}
		}
	}
187329
private function parseNetwork()
    {
        // 用户名密码处理
        $username = $this->request->getAttribute('username');
        if(null != $username)
        {
            $userPwd = $username . ':' . $this->request->getAttribute('password', '');
        }
        else
        {
            $userPwd = '';
        }
        curl_setopt_array($this->handler, array(
            // 连接超时
            CURLOPT_CONNECTTIMEOUT_MS       => $this->request->getAttribute('connectTimeout', 30000),
            // 总超时
            CURLOPT_TIMEOUT_MS              => $this->request->getAttribute('timeout', 0),
            // 下载限速
            CURLOPT_MAX_RECV_SPEED_LARGE    => $this->request->getAttribute('downloadSpeed'),
            // 上传限速
            CURLOPT_MAX_SEND_SPEED_LARGE    => $this->request->getAttribute('uploadSpeed'),
            // 连接中用到的用户名和密码
            CURLOPT_USERPWD                 => $userPwd,
        ));
    }
285053
public function flush() {
        // 缓存不存在则查询数据表信息
        $this->db->setModel($this->name);
        $fields =   $this->db->getFields($this->getTableName());
        if(!$fields) { // 无法获取字段信息
            return false;
        }
        $this->fields   =   array_keys($fields);
        unset($this->fields['_pk']);
        foreach ($fields as $key=>$val){
            // 记录字段类型
            $type[$key]     =   $val['type'];
            if($val['primary']) {
                  // 增加复合主键支持
                if (isset($this->fields['_pk']) && $this->fields['_pk'] != null) {
                    if (is_string($this->fields['_pk'])) {
                        $this->pk   =   array($this->fields['_pk']);
                        $this->fields['_pk']   =   $this->pk;
                    }
                    $this->pk[]   =   $key;
                    $this->fields['_pk'][]   =   $key;
                } else {
                    $this->pk   =   $key;
                    $this->fields['_pk']   =   $key;
                }
                if($val['autoinc']) $this->autoinc   =   true;
            }
        }
        // 记录字段类型信息
        $this->fields['_type'] =  $type;

        // 2008-3-7 增加缓存开关控制
        if(C('DB_FIELDS_CACHE')){
            // 永久缓存数据表信息
            $db   =  $this->dbName?:C('DB_NAME');
            F('_fields/'.strtolower($db.'.'.$this->tablePrefix.$this->name),$this->fields);
        }
    }
865919
public static function parsePathInfo()
    {
        $urlModel = Config::get('url_model');

        $pathInfo = self::$pathInfo;
        if (empty($pathInfo)) {
            $isCli = Request::isCli(); //是否为命令行访问
            if ($isCli) {
                isset($_SERVER['argv'][1]) && $pathInfo = explode('/', $_SERVER['argv'][1]);
            } else {
                //修正可能由于nginx配置不当导致的子目录获取有误
                if (false !== ($fixScriptName = stristr($_SERVER['SCRIPT_NAME'], '.php', true))) {
                    $_SERVER['SCRIPT_NAME'] = $fixScriptName . '.php';
                }

                $urlPathInfoDeper = Config::get('url_pathinfo_depr');
                if ($urlModel === 1 || $urlModel === 2) { //pathInfo模式(含显示、隐藏index.php两种)SCRIPT_NAME
                    if (isset($_GET[Config::get('var_pathinfo')])) {
                        $param = str_replace(Config::get('url_html_suffix'), '', $_GET[Config::get('var_pathinfo')]);
                    } else {
                        $param = preg_replace('/(.*)\/(.+)\.php(.*)/i', '\\1\\3', preg_replace(
                            [
                                '/\\' . Config::get('url_html_suffix') . '/',
                                '/\&.*/', '/\?.*/'
                            ],
                            '',
                            $_SERVER['REQUEST_URI']
                        ));//这边替换的结果是带index.php的情况。不带index.php在以下处理
                        $scriptName = dirname($_SERVER['SCRIPT_NAME']);
                        if ($scriptName && $scriptName != '/') {//假如项目在子目录这边去除子目录含模式1和模式2两种情况(伪静态到子目录)
                            $param = substr($param, strpos($param, $scriptName) + strlen($scriptName));//之所以要strpos是因为子目录或请求string里可能会有多个/而SCRIPT_NAME里只会有1个
                        }
                    }
                    $param = trim($param, '/' . $urlPathInfoDeper);
                } elseif ($urlModel === 3 && isset($_GET[Config::get('var_pathinfo')])) {//兼容模式
                    $urlString = $_GET[Config::get('var_pathinfo')];
                    unset($_GET[Config::get('var_pathinfo')]);
                    $param = trim(str_replace(
                        Config::get('url_html_suffix'),
                        '',
                        ltrim($urlString, '/')
                    ), $urlPathInfoDeper);
                }

                $pathInfo = explode($urlPathInfoDeper, $param);
            }
        }

        isset($pathInfo[0]) && empty($pathInfo[0]) && $pathInfo = ['/'];

        self::$pathInfo = $pathInfo;

        Plugin::hook('cml.after_parse_path_info');
    }
479955
function getHooks(obj, key, opts) {
    let pres = null, posts = null;
    if (key) {
        if (obj) {
            const routeHooks = obj.routeHooks;
            if (routeHooks && routeHooks[key]) {
                if (routeHooks[key].pre) {
                    pres = Array.isArray(routeHooks[key].pre) ? routeHooks[key].pre : [routeHooks[key].pre];
                }
                if (routeHooks[key].post) {
                    posts = Array.isArray(routeHooks[key].post) ? routeHooks[key].post : [routeHooks[key].post];
                }
            }
        }
        // 添加全局hook：全局hook最先被执行
        const globalHooks = opts.globalRouteHooks || {};
        if (globalHooks[key]) {
            const globalPres = globalHooks[key].pre;
            const globalPosts = globalHooks[key].post;
            if (typeof globalPres === 'function') {
                pres = Array.isArray(pres) ? pres : [];
                pres.unshift(globalPres);
            } else if (Array.isArray(globalPres) && globalPres.length > 0) {
                pres = Array.isArray(pres) ? pres : [];
                pres = globalPres.concat(pres);
            }
            if (typeof globalPosts === 'function') {
                posts = Array.isArray(posts) ? posts : [];
                posts.unshift(globalPosts);
            } else if (Array.isArray(globalPosts) && globalPosts.length > 0) {
                posts = Array.isArray(posts) ? posts : [];
                posts = globalPosts.concat(posts);
            }
        }
    }
    return { pres, posts };
}
682898
public function getPathinfo()
    {
        //pathinfo已经被重写过
        if ($this->_pathinfo !== null) {
            return $this->_pathinfo;
        }
        $pathinfo = $this->get('PATH_INFO');
        if (!$pathinfo) {
            //兼容模式
            $vitex = Vitex::getInstance();
            if ($vitex->getConfig('router.compatible')) {
                $pathinfo = isset($_GET['u']) ? $_GET['u'] : '';
            }
        }
        return $pathinfo;
    }
902967
function getParams(req, all) {
  const val = { query: {}, body: {}, params: {}, all: {} };
  if (all) {
    // 获取全部参数
    for (const k in req.query) {
      val.query[k] = req.query[k];
      val.all[k] = req.query[k];
    }
    for (const k in req.body) {
      val.body[k] = req.body[k];
      val.all[k] = req.body[k];
    }
    for (const k in req.params) {
      val.params[k] = req.params[k];
      val.all[k] = req.params[k];
    }
  } else {
    if (req.method === 'GET') {
      val.query = req.query;
      val.all = req.query;
    } else {
      val.body = req.body;
      val.all = req.body;
    }
    // 所有method都应该获取req.params
    for (const k in req.params) {
      val.params[k] = req.params[k];
      val.all[k] = req.params[k];
    }
  }
  return val;
}
429831
public function init()
    {
        /**
         * 设置默认时区
         */
        if ($this->timezone)
        {
            date_default_timezone_set($this->timezone);
        }

        /**
         * 设置地区信息（地域信息）
         */
        if ($this->locale)
        {
            setlocale(LC_ALL, $this->locale);
        }

        if ($this->charset && function_exists('mb_internal_encoding'))
        {
            mb_internal_encoding($this->charset);
        }

        /**
         * 当输入字符的编码是无效的，或者字符代码不存在于输出的字符编码中时，可以为其指定一个替代字符。
         *
         * @link http://www.php.net/manual/function.mb-substitute-character.php
         */
        mb_substitute_character('none');

        // 确保输入的数据安全
        $_GET = Security::sanitize($_GET);
        $_POST = Security::sanitize($_POST);
        $_COOKIE = Security::sanitize($_COOKIE);

        self::cleanComponents();
    }
593205
function fn(metadataGetter, dataAdapter, opts = {}) {
    if (typeof metadataGetter !== 'function') {
        throw new Error(`'metadataGetter' must be a function.`);
    }
    if (typeof dataAdapter !== 'object') {
        throw new Error(`dataAdapter' must be an object.`);
    }
    Object.assign(metadata, metadataGetter.call(null));

    if (!opts.strategy) {
        if (opts.router) {
            opts.strategy = 'ROUTER';
        } else {
            opts.strategy = 'MIDDLEWARE';
        }
    }

    if (typeof opts.getLocaleString !== 'function') {
        opts.getLocaleString = (key) => {
            const object = {
                mongoose_adapter_error_list: '查询失败，请稍后重试',
                mongoose_adapter_error_count: '查询失败，请稍后重试',
                mongoose_adapter_error_id: '查询失败，请稍后重试',
                mongoose_adapter_error_create: '新增失败',
                mongoose_adapter_error_update: '更新失败',
                mongoose_adapter_error_remove: '删除失败',
            };
            return object[key];
        };
    }

    switch (opts.strategy) {
        case 'ROUTER':
            // 路由器挂载
            if (!opts.router) {
                throw new Error(`'router' can not be empty when using ROUTER strategy.`);
            }
            return routerStrategy(metadata, dataAdapter, opts);
        case 'MIDDLEWARE':
            // 中间件过滤
            if (opts.filter && typeof opts.filter !== 'function') {
                throw new Error(`'filter' must be a function type.`);
            }
            return middlewareStrategy(metadata, dataAdapter, opts);
            break;
    }
}
1198043
function(url, config) {
        config = config || {}

        // 获取头信息
        let realReq = setRequest(ctx, url, config);

        // 扩展请求头信息
        let headersObj = Object.assign({}, realReq.headers, config.headers)

        // 获取请求数据配置
        let requestData = parseData(ctx, config);

        // 请求request的最终配置
        let requestOpt = Object.assign({}, options, {
          uri: realReq.uri,
          method: realReq.method,
          headers: headersObj,
          timeout: undefined,
          gzip: false,
          encoding: null
        }, requestData, config.conf);

        // 发送请求前的钩子，可以对requestjs的参数自定义任何操作
        config.onBeforeRequest && config.onBeforeRequest.call(ctx, proxyName, requestOpt)

        return request(ctx, {
          needPipeRes: true
        }, requestOpt);
      }
349390
public function info() {
        /**
         * avatar	用户头像	String	如果没有数据的时候不会返回该数据，请做好容错	可空	https://tfsimg.alipay.com/images/partner/T1k0xiXXRnXXXXXXXX
        nick_name	用户昵称	String	如果没有数据的时候不会返回该数据，请做好容错	可空	张三
        province	省份	String	用户注册时填写的省份 如果没有数据的时候不会返回该数据，请做好容错	可空	浙江省
        city	城市	String	用户注册时填写的城市， 如果没有数据的时候不会返回该数据，请做好容错	可空	杭州
        gender	用户性别	String	M为男性，F为女性， 如果没有数据的时候不会返回该数据，请做好容错	可空	M
        user_type_value	用户类型	String	（1/2），1代表公司账户；2代表个人账户	不可空	1
        is_licence_auth	是否经过营业执照认证	String	T为通过营业执照认证，F为没有通过	不可空	T
        is_certified	是否通过实名认证	String	T是通过；F是没有实名认证	不可空	F
        is_certify_grade_a	是否A类认证	String	T表示是A类认证，F表示非A类认证，A类认证用户是指上传过身份证照片并且通过审核的支付宝用户	不可空	T
        is_student_certified	是否是学生	String	T表示是学生，F表示不是学生	不可空	T
        is_bank_auth	是否经过银行卡认证	String	T为经过银行卡认证，F为未经过银行卡认证	不可空	T
        is_mobile_auth	是否经过手机认证	String	T为经过手机认证，F为未经过手机认证	不可空	T
        alipay_user_id	当前用户的userId	String	支付宝用户的userId	不可空	2088411964574197
        user_id	已废弃，请勿使用	String	已废弃，请勿使用	不可空	已废弃，请勿使用
        user_status	用户状态（Q/T/B/W）	String	Q代表快速注册用户；T代表已认证用户；B代表被冻结账户；W代表已注册，未激活的账户	不可空	T
        is_id_auth	是否身份证认证	String	T为是身份证认证，F为非身份证认证	不可空	T
         */
        $user = (new OAuth())->info($this->get('access_token'));
        if (!is_array($user) || $user['code'] != 10000) {
            return false;
        }
        $user['username'] = $user['nick_name'];
        $user['sex'] = $user['gender'];
        $this->set($user);
        return $user;
    }
778431
public function actionRecord()
    {
        $wechat = $this->getWechat();
        $fans = $this->getFans();
        if (!$fans) { // 存储粉丝信息
            $fans = Yii::createObject(Fans::className());
            $fans->setAttributes([
                'wid' => $wechat->id,
                'open_id' => $this->message['FromUserName'],
                'status' => Fans::STATUS_SUBSCRIBED
            ]);
            if ($fans->save() && $wechat->status > Wechat::TYPE_SUBSCRIBE) { // 更新用户详细数据, 普通订阅号无权限获取
                $fans->updateUser();
            }
        } elseif ($fans->status != Fans::STATUS_SUBSCRIBED) { // 更新关注状态
            $fans->subscribe();
        }

//        $history = new MessageHistory();
//        $attributes = [
//            'wid' => $wechat->id,
//            'module' => $this->getModuleName($this->api->lastProcessController),
//        ];
    }
1067910
@SuppressWarnings("unchecked")
    private static Object putIfNotExist(Object data, Map<String, Object> resultMap) {
        LOG.info("[RuleController]补全信息时:data = " + data);
        if (data == null) {
            return resultMap;
        } else if (!(data instanceof Collection) && !(data instanceof Map)) {//既不是map也不是list,需要显示地配置出最后一个unit的返回结果列表
            return resultMap;
        } else if (data instanceof Map) {
            putToMap((Map) data, resultMap);
            return data;
        } else/* if (data instanceof Collection)*/ {
            Collection newCollection = new ArrayList<>();
            Collection listData = (Collection) data;
            for (Object o : listData) {
                newCollection.add(putIfNotExist(o, resultMap));
            }
            return newCollection;
        }
    }
831795
function (jsonObj) {
    if ($bc_$4.pN) {
      var obj = jsonObj || {
        callback: 'console.log',
        key: ''
      };

      // 统一向后兼容处理
      for (var key in jsonObj) {
        if (jsonObj.hasOwnProperty(key)) {
          obj[key] = jsonObj[key];
        }
      }

      $bc_$4.pN.window.getInfoFromUserDefaults(JSON.stringify(obj));
    }
  }
219987
function parseData(ctx, config) {
    let fields = ['json', 'form', 'body'],
      result = {};

    // 如果默认配置了`json`,`form`,`body`字段，则使用这些数据，并完全忽略默认的请求体数据；
    for (let i = 0; i < fields.length; i++) {
      let key = fields[i];

      if (config[key]) {
        result[key] = config[key];
        return result;
      }
    }

    if (ctx.request.is(METHOD_TYPES.json)) {
      result.json = ctx.request.body
    } else if (ctx.request.is(METHOD_TYPES.form)) {
      result.form = ctx.request.body
    } else if (ctx.request.is(METHOD_TYPES.text)) {
      result.body = ctx.request.body
    } else {
      // 其他content-type默认不做任何处理
    }

    return result;
  }
65153
function getApiResult(data, status, message) {
    var result = {};

    // 成功处理并返回
    if (!status) {
        result.data = data;
    } else {
        result.status = status;
        result.statusInfo = {
            message: message
        };
    }

    return result;
}