// 开发者后端url，使用者可自行替换
export const BASE_URL = 'http://127.0.0.1:8000';

/**
 * @description: 将小程序api封装成Promise
 * @param {any} func js api，例如tt.login
 * @param {*} options 传入api的参数
 * @return {*}
 */
export function promisify(func, options = {}) {
  return new Promise((resolve, reject) => {
    func({
      ...options,
      success(res) {
        resolve(res);
      },
      fail(err) {
        reject(err);
      },
    });
  });
}

/**
 * @description: 封装tt.request方法
 * @param {RequestData} options
 * @return {*}
 */
export async function request(options) {
  const urlRegexp = /(http|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/;
  const { url } = options;
  if (url && !urlRegexp.test(url)) {
    options.url = new URL(url, BASE_URL).href;
  }
  return await promisify(tt.request, options);
}

import { promisify, request } from './promisify';
// 是否登录开发者服务端
let isDeveloperServerLogin = false;
// 是否登录抖音主端
let isDouyinLogin = false;
class LoginController {

  _token = '';
  _openid = '';
  _unionid = '';

  /**
   * @description: 登录函数，首先调用tt.login获取code，并向开发者服务端请求登录
   * @param {*} force 当用户未登录抖音app时，是否强制调起抖音app登录界面
   * @return {*}
   */
  async login(force = true) {
    if (isDeveloperServerLogin) {
      return;
    }
    let loginData = null;
    try {
      // 是否强制调起抖音的登录窗口
      loginData = await promisify(tt.login, { force });
      isDouyinLogin = loginData.isLogin;
    } catch (err) {
      console.error(err);
      tt.showToast({
        icon: 'fail',
        title: '开发者取消登录抖音',
      });
    }
    if (isDouyinLogin && loginData) {
      try {
        // 与开发者服务端交互，进行登录
        await this.loginToDeveloperServer(loginData.code);
        isDeveloperServerLogin = true;
      } catch (err) {
        console.error(err);
        tt.showToast({
          title: '授权登录失败',
          icon: 'fail',
        });
      }
    }
    return isDouyinLogin;
  }

  /**
   * @description: 请求开发者服务端，做code2session
   * @param {string} code tt.login返回的code
   * @return {*}
   */
  async loginToDeveloperServer(code) {
    try {
      tt.showLoading({
        title: '正在登录开发者服务端',
      });
      const res = await request({
        url: '/api/apps/login',
        method: 'post',
        data: {
          code,
        },
      });
      this._token = res.data.token;
      this._openid = res.data.openid;
      this._unionid = res.data.unionid;
      tt.setStorageSync('token', res.data.token);
      tt.setStorageSync('openid', res.data.openid);
      tt.setStorageSync('unionid', res.data.unionid);
    } catch (err) {
      console.log(err);
    } finally {
      tt.hideLoading({});
    }
  }

  /**
   * @description: 登出开发者服务端
   * @return {*}
   */
  async logout() {
    await request({
      url: '/api/apps/logout',
      method: 'post',
      data: {
        token: loginController.getToken(),
      },
    });
    isDeveloperServerLogin = false;
    tt.removeStorageSync('token');
    tt.removeStorageSync('openid');
    tt.removeStorageSync('unionid');
    tt.removeStorageSync('phoneNumberLogin');
    tt.removeStorageSync('customLogin');
  }

  /**
   * @description: 返回是否登录抖音主端
   * @return {*}
   */
  isDouyinLogin() {
    return isDouyinLogin;
  }

  /**
   * @description: 是否登录开发者服务端
   * @return {*}
   */
  isDeveloperServerLogin() {
    return isDeveloperServerLogin;
  }
  
  /**
   * @description: 获取localStorage中的token
   * @return {string}
   */
  getToken() {
    return this._token || tt.getStorageSync('token');
  }

  // openid和unionid由开发者服务端下发，此处只是为了前端做展示；
  // 在实际情况中不建议开发者下发openid和unionid
  /**
   * @description: 获取localStorage中的openid
   * @return {string}
   */
  getOpenid() {
    return this._openid || tt.getStorageSync('openid');
  }

  /**
   * @description: 获取localStorage中的unionid
   * @return {string}
   */
  getUnionid() {
    return this._unionid || tt.getStorageSync('unionid');
  }
}
export const loginController = new LoginController();

import { loginController } from '../../utils';
Page({
  data: {
    openid: '',
    unionid: '',
    // 抖音登录状态
    isLogin: true,
  },
  async onLoad() {
    // 判断用户是否登录抖音主端
    const isDouyinLogin = await loginController.login();
    // setData设置抖音登录状态
    this.setData({
      isLogin: isDouyinLogin,
    });
    // 如果用户已登录开发者服务端，则在缓存中获取openid和unionid
    if (loginController.isDeveloperServerLogin()) {
      this.setData({
        openid: loginController.getOpenid(),
        unionid: loginController.getUnionid(),
      });
    }
  },
  /**
   * @description: 点击事件，若用户没登录抖音主端，则强制调取登录界面，并向开发者服务端进行登录
   * @return {*}
   */
  async login() {
    const isDouyinLogin = await loginController.login();
    this.setData({
      openid: loginController.getOpenid(),
      unionid: loginController.getUnionid(),
      isLogin: isDouyinLogin,
    });
  },
});

func Login(context context.Context, req *model.LoginRequest) *model.LoginResponse {
   code2SessionReq := &code2SessionRequest{
      AppId:  conf.Appid,
      Secret: conf.Secret,
      Code:   req.Code,
      ACode:  "",
   }

   code2SessionResp, err := code2Session(context, code2SessionReq)

   if err != nil {
      response := &model.LoginResponse{
         ErrCode: -1,
         ErrMsg:  err.Error(),
         Token:   "",
      }
      return response
   }

   if code2SessionResp.ErrNo != 0 {
      response := &model.LoginResponse{
         ErrCode: -1,
         ErrMsg:  code2SessionResp.ErrTips,
         Token:   "",
      }
      return response
   }

   token := store.SetCache(context, "", code2SessionResp.Data.Openid, code2SessionResp.Data.UnionId, "", code2SessionResp.Data.SessionKey)

   response := &model.LoginResponse{
      ErrCode: 0,
      ErrMsg:  "success",
      Token:   token,
      Openid:  masker.ID(code2SessionResp.Data.Openid),
      Unionid: masker.ID(code2SessionResp.Data.UnionId),
   }
   return response
}

const (
   domain           = "developer.toutiao.com"
   sandBoxDomain    = "open-sandbox.douyin.com"
   code2SessionPath = "/api/apps/v2/jscode2session"
)

type code2SessionRequest struct {
   AppId  string `json:"appid"`
   Secret string `json:"secret"`
   Code   string `json:"code"`
   ACode  string `json:"anonymous_code"`
}

type Code2SessionResponseData struct {
   SessionKey string `json:"session_key"`
   Openid     string `json:"openid"`
   AOpenId    string `json:"anonymous_openid"`
   UnionId    string `json:"unionid"`
   DOpenid    string `json:"dopenid"`
}

type Code2SessionResponse struct {
   ErrNo   int64  `json:"err_no"`
   ErrTips string `json:"err_tips"`
   Data Code2SessionResponseData `json:"data"`
}

func code2Session(ctx context.Context, req *code2SessionRequest) (*Code2SessionResponse, error) {
   reqBodyByte, _ := json.Marshal(req)
   reqDomain := domain
   // 沙盒切换
   if conf.IsSandBox == "1" {
      reqDomain = sandBoxDomain
   }
   respBody, err := utils.HttpDo(ctx, code2SessionPath, utils.HttpPostMethod, string(reqBodyByte), "https", reqDomain)
   resp := &Code2SessionResponse{}
   if err != nil {
      return nil, err
   }

   err = json.Unmarshal([]byte(respBody), resp)

   return resp, err
}

@RestController
@ComponentScan
public class Login {

    @Autowired
    private AppConfig appConfig;

    /**
     * 小程序利用code2session登录获取openid返回
     * @param requestBody
     * @return
     * @throws IOException
     */
    @RequestMapping(value = "/api/apps/login", consumes = MediaType.APPLICATION_JSON_VALUE)
    String handle(@RequestBody String requestBody) throws IOException {
        // 请求体初始化pb结构
        open.douyin.com.model.Login.LoginRequest.Builder requestBuild = open.douyin.com.model.Login.LoginRequest.newBuilder();
        JsonFormat.parser().merge(requestBody, requestBuild);
        open.douyin.com.model.Login.LoginRequest request = requestBuild.build();

        // 装配code2session请求体
        Gson gson = new GsonBuilder().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();
        Code2SessionRequest code2SessionRequest = new Code2SessionRequest();
        code2SessionRequest.setCode(request.getCode());
        code2SessionRequest.setAppid(appConfig.AppId);
        code2SessionRequest.setSecret(appConfig.Secret);

        // code2session的http请求 TODO 常量化
        String domain = "developer.toutiao.com";
        if (appConfig.IsSandBox.equals("1")) {
            domain = "open-sandbox.douyin.com";
        }
        String code2SessionPath = "/api/apps/v2/jscode2session";
        Code2SessionResponse response = HttpUtil.HttpPost(code2SessionPath, gson.toJson(code2SessionRequest), "https", domain, Code2SessionResponse.class);

        // 初始化登录返回数据 并处理返回异常
        open.douyin.com.model.Login.LoginResponse.Builder builder = open.douyin.com.model.Login.LoginResponse.newBuilder();

        // 对返回数据异常处理
        if (response == null || response.getData() == null) {
            builder.setErrCode(-1);
            builder.setErrMsg("error");
            open.douyin.com.model.Login.LoginResponse obj = builder.build();
            return JsonFormat.printer().print(obj);
        }
        if (response.getErrNo() != 0) {
            builder.setErrCode(-1);
            builder.setErrMsg(response.getErrTips());
            open.douyin.com.model.Login.LoginResponse obj = builder.build();
            return JsonFormat.printer().print(obj);
        }

        // 返回成功则组装返回结构体
        builder.setErrCode(response.getErrNo());
        builder.setErrMsg("");
        builder.setErrCode(0);

        String token = Store.SetCache("", response.getData().getOpenid(), response.getData().getUnionId(), "", response.getData().getSessionKey());
        builder.setToken(token);

        builder.setOpenid(response.getData().getOpenid().substring(0, 3) + "****" + response.getData().getOpenid().substring(7));
        builder.setUnionid(response.getData().getUnionId().substring(0, 3) + "****" + response.getData().getUnionId().substring(7));

        open.douyin.com.model.Login.LoginResponse responseBody = builder.build();
        return JsonFormat.printer().print(responseBody);
    }

}

def login_handler(login_req_body):
    # 解析登录请求参数
    login_req = Parse(login_req_body, login_pb2.LoginRequest(), True)
    code2session_req = {'appid': conf.app.get_app_id(), 'secret': conf.app.get_secret(), 'code': login_req.code}
    code2session_res = utils.http_utils.http_post('https://developer.toutiao.com/api/apps/v2/jscode2session',
                                                  code2session_req)

    print(code2session_res)
    data = json.loads(code2session_res)

    login_res = login_pb2.LoginResponse()
    if data['err_no'] != 0:
        login_res.errCode = -1
        login_res.errMsg = 'error'
        return MessageToJson(login_res)
    else:
        login_res.errCode = 0
        login_res.errMsg = 'success'
        login_res.token = store.store.set_cache(
            "", data['data']['openid'], data['data']['unionid'], "", data['data']['session_key'])

        login_res.openid = data['data']['openid'][:3] + "****" + data['data']['openid'][7:]
        login_res.unionid = data['data']['unionid'][:3] + "****" + data['data']['unionid'][7:]
    return MessageToJson(login_res)

class LoginController extends BaseController
{
    /**
     * @throws \Exception
     */
    public function login(): string
    {
        $this->response->setHeader("Content-Type", "application/json");
        try {
            $json = $this->request->getBody();
            $lr = new LoginRequest();
            $lr->mergeFromJsonString($json, true);

            $code2SessionMap = array("appid"=>$_SERVER['APP_ID'], "secret"=>$_SERVER['SECRET'], "code"=>$lr->getCode());
            $code2SessionReqBody = json_encode($code2SessionMap);

            $domain = "developer.toutiao.com";
            if ($_SERVER['IS_SAND_BOX'] == "1") {
                $domain = "open-sandbox.douyin.com";
            }
            $code2SessionRespBody = \App\Utils\HttpUtils::HttpPost("/api/apps/v2/jscode2session", $code2SessionReqBody, "https", $domain);

            $code2SessionResp = json_decode($code2SessionRespBody, true);

            $loginResponse = new LoginResponse();
            if (empty($code2SessionResp)) {
                $loginResponse->setErrCode(-1);
                $loginResponse->setErrMsg("error");
                return $loginResponse->serializeToJsonString();
            }
            if ($code2SessionResp['err_no'] != 0 || empty($code2SessionResp["data"])) {
                $loginResponse->setErrCode(-1);
                $loginResponse->setErrMsg("error");
                return $loginResponse->serializeToJsonString();
            }

            $loginResponse->setErrCode(0);
            $loginResponse->setErrMsg("success");

            $token = \App\Store\Store::setCache("", $code2SessionResp["data"]["openid"], $code2SessionResp["data"]["unionid"], "", $code2SessionResp["data"]["session_key"]);
            $loginResponse->setToken($token);
            $loginResponse->setOpenid($this->dataDesensitization($code2SessionResp["data"]["openid"], 3, 7));
            $loginResponse->setUnionid($this->dataDesensitization($code2SessionResp["data"]["unionid"], 3, 7));
            return $loginResponse->serializeToJsonString();
        } catch (\Exception $e) {
            return $e->getMessage();
        }
    }


    function dataDesensitization($string, $start = 0, $length = 0, $re = '*')
    {
        if (empty($string)){
            return false;
        }
        $strarr = array();
        $mb_strlen = mb_strlen($string);
        while ($mb_strlen) {//循环把字符串变为数组
            $strarr[] = mb_substr($string, 0, 1, 'utf8');
            $string = mb_substr($string, 1, $mb_strlen, 'utf8');
            $mb_strlen = mb_strlen($string);
        }
        $strlen = count($strarr);
        $begin = $start >= 0 ? $start : ($strlen - abs($start));
        $end = $last = $strlen - 1;
        if ($length > 0) {
            $end = $begin + $length - 1;
        } elseif ($length < 0) {
            $end -= abs($length);
        }
        for ($i = $begin; $i <= $end; $i++) {
            $strarr[$i] = $re;
        }
        if ($begin >= $end || $begin >= $last || $end > $last) return false;
        return implode('', $strarr);
    }
}

// 详细代码请参考 NodeJs/src/app.js
const axios = require('axios');
const Router = require('koa-router');
const { v4: uuidv4 } = require('uuid');

// 存储token
const tokens = {};

const router = new Router();

// 是否为沙盒环境
const baseURL = sandbox ? 'https://developer.toutiao.com' : 'https://open-sandbox.douyin.com';
const http = axios.create({
   baseURL,
});
/**
 * @description: 字符串脱敏，中间四个字符被和谐
 * @param {*} str
 * @return {*}
 */
function desensitization(str) {
  const len = str.length;
  const mid = len >> 1;
  return `${str.substring(0, mid - 1)}****${str.substring(mid + 2)}`;
}
// 静默登录接口
router.post('/api/apps/login', async ctx => {
    // 前端上报tt.login返回的code
    const { code } = ctx.request.body;
    // 调用开平code2session接口
    const res = await http.request({
      url: '/api/apps/v2/jscode2session',
      method: 'post',
      data: {
        secret,
        code,
        appid,
      },
    });
    // 获取到session_key,用户openid和union_id
    const { session_key, openid, unionid } = res.data.data;
    // 根据openid生成token
    const token = uuidv4();
    // 存储到开发者服务端
    tokens[token] = {
      session_key,
      openid,
      unionid,
      token,
    };

    ctx.body = {
      errCode: 0,
      errMsg: 'ok',
      token,
      openid: desensitization(openid),
      unionid: desensitization(unionid),
    };
  });

func ShowData(context context.Context, req *model.ShowDataRequest) *model.ShowDataResponse {
    userData, exist := store.GetCache(context, req.Token)
    if !exist {
        resp := &model.ShowDataResponse{
            ErrCode:       -1,
            ErrMsg:        "",
            DecryptedData: "",
            Token:         "",
        }
        return resp
    }

    println("data: ", req.EncryptedData.Data)
    println("sessionkey: ", userData.SessionKey)
    println("iv: ", req.EncryptedData.Iv)
    decodeData, _ := base64.StdEncoding.DecodeString(req.EncryptedData.Data)
    decodeSecret, _ := base64.StdEncoding.DecodeString(userData.SessionKey)
    decodeIv, _ := base64.StdEncoding.DecodeString(req.EncryptedData.Iv)
    decryptData, err := utils.CbcDecrypt(decodeData, decodeSecret, decodeIv)
    if err != nil {
        resp := &model.ShowDataResponse{
            ErrCode:       -1,
            ErrMsg:        err.Error(),
            DecryptedData: "",
            Token:         "",
        }
        return resp
    }
    token := store.SetCache(context, req.Token, userData.OpenId, userData.UnionId, decryptData, userData.SessionKey)

    resp := &model.ShowDataResponse{
        ErrCode:       0,
        ErrMsg:        "success",
        DecryptedData: utils.MaskPhoneNumber(context, decryptData),
        Token:         token,
    }
    return resp
}

@RestController
@RestController
public class ShowData {

    @Autowired
    private AppConfig appConfig;

    /**
     * 小程序登录解密全流程，code2session->cbc decryption，这里demo对可能存在的加解密异常不做额外处理，开发者可以自行加入处理逻辑
     * @param requestBody
     * @return
     * @throws IOException
     * @throws InvalidAlgorithmParameterException
     * @throws NoSuchPaddingException
     * @throws IllegalBlockSizeException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws InvalidKeyException
     */
    @RequestMapping(value = "/api/apps/showData", consumes = MediaType.APPLICATION_JSON_VALUE)
    public String handle(@RequestBody String requestBody) throws IOException, InvalidAlgorithmParameterException, NoSuchPaddingException, IllegalBlockSizeException, NoSuchAlgorithmException, BadPaddingException, InvalidKeyException {
        // 装载showdata请求体
        open.douyin.com.model.Login.ShowDataRequest.Builder requestBuild = open.douyin.com.model.Login.ShowDataRequest.newBuilder();
        JsonFormat.parser().merge(requestBody, requestBuild);
        open.douyin.com.model.Login.ShowDataRequest request = requestBuild.build();

        UserSession userData = Store.GetCache(request.getToken());

        open.douyin.com.model.Login.ShowDataResponse.Builder builder = open.douyin.com.model.Login.ShowDataResponse.newBuilder();

        // cbc解密
        open.douyin.com.model.Login.EncryptedData data = request.getEncryptedData();
        String decryptData = CbcCoding.decrypt(data.getData(), userData.getSessionKey(), data.getIv());
        builder.setDecryptedData(Mask.MaskPhoneNumber(decryptData));
        String token = Store.SetCache(request.getToken(), userData.getOpenid(), userData.getUnionid(), decryptData, userData.getSessionKey());

        builder.setToken(token);
        Login.ShowDataResponse obj = builder.build();

        return JsonFormat.printer().print(obj);
    }
}

def show_data_handler(login_req_body):
    # 解析登录请求参数，并http调用code2session
    show_data_req = Parse(login_req_body, login_pb2.ShowDataRequest(), True)

    user_data = store.store.get_cache(show_data_req.token)
    # 解密用户加密数据
    decode_session_key = base64.b64decode(user_data.get_session_key())

    decode_data = base64.b64decode(show_data_req.encryptedData.data)
    decode_iv = base64.b64decode(show_data_req.encryptedData.iv)
    decrypt_data = utils.cbc_coding.decrypt(decode_data, decode_session_key, decode_iv)

    token = store.store.set_cache(show_data_req.token, user_data.get_open_id(), user_data.get_union_id(), decrypt_data,
                                  user_data.get_session_key())

    show_data_res = login_pb2.ShowDataResponse()
    show_data_res.decryptedData = utils.mask.mask_phone(decrypt_data)
    show_data_res.token = token

    return MessageToJson(show_data_res)

class ShowDataController extends BaseController
{
    public function showData()
    {
        $this->response->setHeader("Content-Type", "application/json");
        try {
            $json = $this->request->getBody();
            $showDataReq = new ShowDataRequest();
            $showDataReq->mergeFromJsonString($json, true);
            $showDataResp = new ShowDataResponse();

            log_message('critical', $json);
            $userData = \App\Store\Store::getCache($showDataReq->getToken());

            if (empty($userData)) {
                $showDataResp->setErrCode(-1);
                $showDataResp->setErrMsg("token not exist");
                return $showDataResp->serializeToJsonString();
            }

            log_message('critical', $showDataReq->getToken());
            $decodeKey = base64_decode($userData["sessionKey"]);

            $decodeData = base64_decode($showDataReq->getEncryptedData()->getData());
            $decodeIv = base64_decode($showDataReq->getEncryptedData()->getIv());
            $decryptData = CbcCoding::decrypt($decodeData, $decodeKey, $decodeIv);
            if (!$decryptData) {
                $showDataResp->setErrCode(-1);
                $showDataResp->setErrMsg("error");
                return $showDataResp->serializeToJsonString();
            }

            $showDataResp->setDecryptedData(Mask::MaskPhoneNumber($decryptData));
            $showDataResp->setErrCode(0);
            $showDataResp->setErrMsg("success");

            $token = \App\Store\Store::setCache("", $userData["openId"], $userData["unionId"], $decryptData, $userData["sessionKey"]);
            $showDataResp->setToken($token);
            return $showDataResp->serializeToJsonString();
        } catch (\Exception $e) {
            return $e->getMessage();
        }
    }
}

// 详细代码请参考 NodeJs/src/app.js
const axios = require('axios');
const Router = require('koa-router');
const router = new Router();
// 是否为沙盒环境
const baseURL = sandbox ? 'https://developer.toutiao.com' : 'https://open-sandbox.douyin.com';
const http = axios.create({
   baseURL,
});
// 存储对象，本示例中以object方式代替数据库存储方式，以用户openid作为存储的主键
const storage = {};
// 存储token，每个token对应一个openid
const tokens = {};
/**
 * @description: 解密方法
 * @param {string} encryptedData
 * @param {string} sessionKey
 * @param {string} iv
 * @return {string}
 */
function decrypt(encryptedData, sessionKey, iv) {
  const decipher = crypto.createDecipheriv('aes-128-cbc', Buffer.from(sessionKey, 'base64'), Buffer.from(iv, 'base64'));
  let ret = decipher.update(encryptedData, 'base64', 'utf8');
  ret += decipher.final('utf8');
  return ret;
}
// 解密用户数据
router.post('/api/apps/showData', ctx => {
  /**
   * @description: 前端需要上报tt.login返回的code和tt.getUserProfile和getPhoneNumber返回的encryptedData
   * @param {{ data: string, iv: string,dataType: number }[]} encryptedData: data(用户加密数据)，iv( 随机iv), dataType(1为获取电话；2为获取用户信息)
   * @return {*}
   */
  const { encryptedData, token } = ctx.request.body;

  let info = tokens[token];

  // 获取本地缓存sessionKey
  const { session_key } = info;

  const { data, iv } = encryptedData;
  // 解密
  let decryptedData = null;
  try {
    decryptedData = decrypt(data, session_key, iv);
    decryptedData = JSON.parse(decryptedData);
    tokens[token].userData = decryptedData;
    // 此处做了一个脱敏处理
    decryptedData.phoneNumber = desensitization(decryptedData.phoneNumber);
    decryptedData.purePhoneNumber = desensitization(decryptedData.purePhoneNumber);
    // 下发前端解密数据
    ctx.body = {
      errCode: 0,
      errMsg: 'ok',
      decryptedData: JSON.stringify(decryptedData),
    };
  } catch (err) {
    console.log(err);
    // 若解密失败，说明sessionKey过期，用户登录失效
    ctx.status = 401;
    ctx.body = {
      errCode: 1,
      errMsg: '认证过期',
    };
    delete tokens[token];
  }
});

// 确定用户登录后调用的返回用户信息接口，需要前端上传token
router.post('/api/apps/userData', ctx => {
  const { token } = ctx.request.body;
  const user = tokens[token];
  if (!user) {
    ctx.status = 404;
    ctx.body = {
      errCode: 1,
      errMsg: '未找到用户',
      userData: {},
    };
    return;
  }
  const decryptedData = user && user.userData;
  if (!decryptedData) {
    ctx.status = 400;
    ctx.body = {
      errCode: 2,
      errMsg: '请先调用showData接口',
      userData: {},
    };
    return;
  }
  // 此处做了一个脱敏处理
  decryptedData.phoneNumber = desensitization(decryptedData.phoneNumber);
  decryptedData.purePhoneNumber = desensitization(decryptedData.purePhoneNumber);
  ctx.body = {
    errCode: 0,
    errMsg: 'ok',
    userData: { data: JSON.stringify(decryptedData) },
  };
});