index.js后端主入口

解释下面的代码，

后端收到前端发来的请求app.get("/jsSdkAuthorized")解析参数执行步骤1获取token执行步骤2获取ticket执行步骤3签名。。。

import express from 'express'

import cors from 'cors'

import config from "./datas/config.json" assert {type: "json"}

import { getAccessToken } from './utils/getAccessToken.js'

import { getRandomStr, sign } from './utils/sign.js'

import { getTicket } from './utils/getTicket.js'

const app = express()

const port = 3000

app.use(cors())

app.use(express.json())

app.use(express.urlencoded({ extended: false }))

app.get("/jsSdkAuthorized", async (req, res) => {

// 解析参数

let url = req.query.url;

// 步骤1

let token = await getAccessToken();

// 步骤2

let jsapiTicket = await getTicket(token);

// 应用id前端发送

let agentId = config.AgentId;

let corpId = config.CorpId;

let timeStamp = Date.now();

// let nonceStr = getRandomStr(16)

let nonceStr = getRandomStr(16)

// 步骤3

let signature = sign(jsapiTicket, nonceStr, timeStamp, url);

res.send({

code: 200,

signatureObj: {

agentId,

corpId,

timeStamp,

nonceStr,

signature

}

})

})

app.listen(port, () => {

console.log(port + ":running")

})

api/index.js 后端发送的请求

import axios from "axios";

const BASE_URL = "https://api.dingtalk.com/v1.0/oauth2";

/**

* 获取token

* @param {*} appKey

* @param {*} appSecret

* @returns

*/

export const accessToken = async (appKey, appSecret) => {

let data = await axios({

headers: {

'Content-Type': 'application/json'

},

method: 'post',

url: `${BASE_URL}/accessToken`,

data: {

appKey,

appSecret

}

});

return data.data

}

/**

* 获取jsapiTicket

* @param {*} token

* @returns

*/

export const jsapiTicket = async (token) => {

try {

let data = await axios({

headers: {

'Content-Type': 'application/json',

'x-acs-dingtalk-access-token': token

},

method: 'post',

url: `${BASE_URL}/jsapiTickets`,

data: {}

});

return data.data

} catch (error) {

console.log(error, 'error')

}

}

datas/config.json 配置参数

{

"AppKey": "xxx",

"AppSecret": "xxx",

"AgentId": "xx",

"CorpId": "xxx"

}

utils/getAccessToken.js 获取token，并且缓存

import fs from 'fs';

import { fileURLToPath } from 'url';

import path from 'path';

// 只读，不修改

import config from '../datas/config.json' assert {type: "json"}

import { accessToken } from '../api/index.js';

const appKey = config.AppKey;

const appSecret = config.AppSecret;

const __filename = fileURLToPath(import.meta.url);

const __dirname = path.dirname(__filename);

// console.log(__filename, __dirname, '__filename,__dirname')

export const getAccessToken = async () => {

// 判断当前token是否存在，如果存在就获取当前的token，如果存在，但是过期了，就重新生成token，如果没有token，那也重新生成token

// 获取当前的时间

let currentTime = Date.now();

// 获取本地的存放的accesstoken

let accessTokenJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../datas/token.json")));

// 如果失效，重新请求

if (accessTokenJson.accessToken == '' || accessTokenJson.expireIn < currentTime) {

console.log("token失效");

// 获取新的token

console.log("get remote: token");

let data = await accessToken(appKey, appSecret);

accessTokenJson.accessToken = data.accessToken;

// expires_in单位秒 5分钟

accessTokenJson.expireIn = Date.now() + (data.expireIn - 300) * 1000;

fs.writeFileSync(path.resolve(__dirname, "../datas/token.json"), JSON.stringify(accessTokenJson));

return accessTokenJson.accessToken

} else {// 从本地获取

console.log("get local: token");

return accessTokenJson.accessToken;

}

}

utils/getTicket.js 获取ticket并且缓存

import fs from 'fs';

import { fileURLToPath } from 'url';

import path from 'path';

// 只读，不修改

import { jsapiTicket } from '../api/index.js'

const __filename = fileURLToPath(import.meta.url);

const __dirname = path.dirname(__filename);

// console.log(__filename, __dirname, '__filename,__dirname')

export const getTicket = async (token) => {

// 判断当前ticket是否存在，如果存在就获取当前的ticket，如果存在，但是过期了，就重新生成ticket，如果没有ticket，那也重新生成ticket

// 获取当前的时间

let currentTime = Date.now();

// 获取本地的存放的accessticket

let accessTicket = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../datas/ticket.json")));

// 如果失效，重新请求

if (accessTicket.jsapiTicket == '' || accessTicket.expireIn < currentTime) {

console.log("ticket失效");

// 获取新的ticket

console.log("get remote: ticket");

let data = await jsapiTicket(token);

accessTicket.jsapiTicket = data.jsapiTicket;

// expires_in单位秒 5分钟

accessTicket.expireIn = Date.now() + (data.expireIn - 300) * 1000;

fs.writeFileSync(path.resolve(__dirname, "../datas/ticket.json"), JSON.stringify(accessTicket));

return accessTicket.jsapiTicket

} else {// 从本地获取

console.log("get local: ticket");

return accessTicket.jsapiTicket;

}

}

utils/sign.js核心鉴权函数

// import CryptoJS from 'crypto-js'

// import crypto from 'crypto'

import sha1 from 'sha1'

/**

* 计算dd.config的签名参数

*

* @param {string} jsticket 通过微应用appKey获取的jsticket

* @param {string} nonceStr 自定义固定字符串

* @param {number} timeStamp 当前时间戳

* @param {string} currentUrl 调用dd.config的当前页面URL

* @returns {string}

*/

export const sign = (ticket, nonce, timeStamp, url) => {

let plainTex = `jsapi_ticket=${ticket}&noncestr=${nonce}&timestamp=${timeStamp}&url=${decodeURIComponent(url)}`;

let signature = sha1(plainTex);

return signature;

}

/**

* 生成随机字符串

*

* @param {number} count 随机字符串长度

* @returns {string}

*/

export const getRandomStr = (count) => {

const base = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

let result = '';

for (let i = 0; i < count; i++) {

const randomIndex = Math.floor(Math.random() * base.length);

result += base[randomIndex];

}

return result;

}

/**

* 返回随机字符串

* @returns

*/

export const getNonceStr = () => {

return Math.random().toString(16).substring(2, 15)

}

最终效果

前端控制台输出

ok

写在最后！官方文档没有提供nodejs代码，差评，提供的文档不够详细，差评。还是前端不够被重视，认为后端就是java或php才能干。。。。