@larksuiteoapi/card
Version:
larksuite open api card sdk
161 lines • 6.5 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.handle = void 0;
const core_1 = require("@larksuiteoapi/core");
const card_1 = require("../model/card");
const err_1 = require("./err");
const util = __importStar(require("util"));
const card_2 = require("../card");
const crypto = require('crypto');
const responseFormat = `{"codemsg":"%s"}`;
const challengeResponseFormat = `{"challenge":"%s"}`;
class Handlers {
constructor(init, validate, unmarshal, handler, complement) {
this.init = init;
this.validate = validate;
this.unmarshal = unmarshal;
this.handler = handler;
this.complement = complement;
}
}
const initFunc = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
let request = httpCard.request;
ctx.set(core_1.HTTPHeaderKey, request.headers);
httpCard.header = {
timestamp: request.headers[card_1.HeaderKey.LarkRequestTimestamp.toLowerCase()],
nonce: request.headers[card_1.HeaderKey.LarkRequestRequestNonce.toLowerCase()],
signature: request.headers[card_1.HeaderKey.LarkSignature.toLowerCase()],
refresh_token: request.headers[card_1.HeaderKey.LarkRefreshToken.toLowerCase()],
};
});
const validateFunc = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
let conf = core_1.getConfigByCtx(ctx);
let body = httpCard.request.body;
let json;
if (typeof body == "string") {
if (httpCard.header.signature) {
verify(httpCard.header, conf.getAppSettings().verificationToken, body);
}
json = JSON.parse(body);
}
else {
json = body;
}
conf.getLogger().debug("[validate] card:", json);
httpCard.input = json;
});
const unmarshalFunc = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
let conf = core_1.getConfigByCtx(ctx);
httpCard.type = httpCard.input["type"];
httpCard.challenge = httpCard.input["challenge"];
if (httpCard.type == core_1.CallbackType.Challenge) {
let appSettings = conf.getAppSettings();
if (appSettings.verificationToken != httpCard.input["token"]) {
core_1.throwTokenInvalidErr();
}
}
});
const verify = (header, verifyToken, body) => {
let targetSig = signature(header, verifyToken, body);
if (header.signature != targetSig) {
throw new err_1.SignatureErr();
}
};
const signature = (header, verifyToken, body) => {
let r = header.timestamp + header.nonce + verifyToken + body;
let hash = crypto.createHash('sha1');
hash.update(r);
return hash.digest('hex');
};
const handlerFunc = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
if (httpCard.type == core_1.CallbackType.Challenge) {
return;
}
let conf = core_1.getConfigByCtx(ctx);
let h = card_2.getHandler(conf);
if (!h) {
throw new err_1.NotFoundHandlerErr();
}
httpCard.output = yield h(ctx, httpCard.input);
});
const writeHTTPResponse = (httpCard, statusCode, body) => {
let response = new core_1.Response();
response.statusCode = statusCode;
response.headers[core_1.ContentType.toLowerCase()] = core_1.DefaultContentType;
response.body = body;
httpCard.response = response;
};
const complementFunc = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
let conf = core_1.getConfigByCtx(ctx);
let err = httpCard.err;
if (err) {
if (err instanceof err_1.NotFoundHandlerErr) {
conf.getLogger().error(err);
writeHTTPResponse(httpCard, 500, util.format(responseFormat, err));
return;
}
conf.getLogger().error(err);
writeHTTPResponse(httpCard, 500, util.format(responseFormat, err));
return;
}
if (httpCard.type == core_1.CallbackType.Challenge) {
writeHTTPResponse(httpCard, 200, util.format(challengeResponseFormat, httpCard.challenge));
return;
}
if (httpCard.output) {
let output = "";
if (typeof httpCard.output == "string") {
output = httpCard.output;
}
else {
output = JSON.stringify(httpCard.output);
}
writeHTTPResponse(httpCard, 200, output);
return;
}
writeHTTPResponse(httpCard, 200, util.format(responseFormat, "success"));
});
const defaultHandlers = new Handlers(initFunc, validateFunc, unmarshalFunc, handlerFunc, complementFunc);
exports.handle = (ctx, httpCard) => __awaiter(void 0, void 0, void 0, function* () {
try {
yield defaultHandlers.init(ctx, httpCard);
yield defaultHandlers.validate(ctx, httpCard);
yield defaultHandlers.unmarshal(ctx, httpCard);
yield defaultHandlers.handler(ctx, httpCard);
}
catch (e) {
httpCard.err = e;
}
finally {
yield defaultHandlers.complement(ctx, httpCard);
}
});
//# sourceMappingURL=handlers.js.map