typed-wx-api/dist/api/mp/crypto/crypto_mp.js

Typed Wechat API

"use strict";
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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WxMpCrypto = void 0;
const crypto_1 = require("../../../crypto");
const xml2js_1 = __importDefault(require("xml2js"));
class WxMpCrypto {
    constructor(config) {
        this.wxCrypto = new crypto_1.WxCrypto({
            token: config.token,
            encodingAESKey: config.encodingAESKey,
            id: config.appid
        });
    }
    decrypt(params, encrypt) {
        return __awaiter(this, void 0, void 0, function* () {
            if (params.msg_signature ===
                this.wxCrypto.signature({
                    timestamp: params.timestamp,
                    nonce: params.nonce,
                    encrypt: encrypt
                })) {
                const decryptData = this.wxCrypto.decrypt(encrypt);
                if (decryptData.id !== this.wxCrypto.id) {
                    return {
                        errMessage: 'Invalid appid:' + decryptData.id
                    };
                }
                else {
                    return {
                        errMessage: undefined,
                        message: decryptData.message
                    };
                }
            }
            else {
                return {
                    errMessage: 'Invalid MsgSignature'
                };
            }
        });
    }
    formatXmlObj(xmlObj) {
        const self = this;
        if (typeof xmlObj === 'object') {
            for (const key in xmlObj) {
                if (!Array.isArray(xmlObj[key]) || xmlObj[key].length === 0) {
                    continue;
                }
                if (xmlObj[key].length === 1) {
                    const val = xmlObj[key][0];
                    if (typeof val === 'object') {
                        xmlObj[key] = self.formatXmlObj(val);
                    }
                    else {
                        xmlObj[key] = (val || '').trim();
                    }
                }
                else {
                    xmlObj[key] = xmlObj[key].map((item) => self.formatXmlObj(item));
                }
            }
        }
        return xmlObj;
    }
    decryptMessageXML(params, xmlStr) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.decryptXML(params, xmlStr);
        });
    }
    decryptXML(params, xmlStr) {
        return __awaiter(this, void 0, void 0, function* () {
            const event = this.formatXmlObj((yield xml2js_1.default.parseStringPromise(xmlStr)).xml);
            if (params.msg_signature == null && (event === null || event === void 0 ? void 0 : event.Encrypt) == null) {
                return {
                    errMessage: undefined,
                    Decrypt: event
                };
            }
            if ((event === null || event === void 0 ? void 0 : event.Encrypt) == null) {
                return {
                    errMessage: 'Missing Encrypt Data'
                };
            }
            const decryptInfo = yield this.decrypt(params, event.Encrypt);
            if (decryptInfo.errMessage === undefined) {
                return {
                    errMessage: undefined,
                    Decrypt: this.formatXmlObj((yield xml2js_1.default.parseStringPromise(decryptInfo.message)).xml)
                };
            }
            else {
                return decryptInfo;
            }
        });
    }
}
exports.WxMpCrypto = WxMpCrypto;
//# sourceMappingURL=crypto_mp.js.map