nodejs实现百度舆情接口

const URL = require('url');
const http = require('http');
const https = require('https');
const qs = require('querystring');

let trends = exports;

trends.getInstance = function () {
    return new Trends;
}

function Trends() {
    this.expireTime = 1800;

    this.accessKey = 'xxxxxxxx';
    this.secretKey = 'xxxxxxxx';

    this.userKey = 'xxxxxxxx';
    this.userSecret = 'xxxxxxxx';

    this.host = 'trends.baidubce.com';

    this.timestamp = _.time();
    this.utcTimestamp = _.utcTime();
}

Trends.prototype.request = async function (method, uri, params) {
    method = method.toUpperCase();
    
    let token = this.getToken();
    let headers = this.getHeaders(method, uri);

    params = Object.assign({}, params || {}, {
        'user_key': this.userKey,
        'token': token,
        'timestamp': this.timestamp
    });

    let url = `http://${this.host}${uri}`;
    return await this.httpRequest(method, url, params, headers);
}

Trends.prototype.getHeaders = function (method, uri) {
    let authorization = this.getAuthorization(method, uri);
    return {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Host': this.host,
        'x-bce-date': this.utcTimestamp,
        'Authorization': authorization,
    };
}

Trends.prototype.getAuthorization = function (method, uri) {
    let authString = `bce-auth-v1/${this.accessKey}/${this.utcTimestamp}/${this.expireTime}`;
    let signinKey = _.hmac(authString, this.secretKey, 'sha256');

    let header = {
        'host': this.host,
        'x-bce-date': _.urlencode(this.utcTimestamp)
    };

    let headerArr = [];
    for (let name in header) {
        let val = header[name];
        headerArr.push(`${name}:${val}`);
    }

    let headerKeyStr = Object.keys(header).sort().join(';');

    let requestStr = `${method}\n${uri}\n\n${headerArr.join('\n')}`;
    let signautre = _.hmac(requestStr, signinKey, 'sha256');

    return `${authString}/${headerKeyStr}/${signautre}`;
}

Trends.prototype.getToken = function () {
    return _.hmac(this.userKey + this.timestamp, this.userSecret);
}

Trends.prototype.httpRequest = async function (method, url, params, headers) {
    let urlObj = URL.parse(url);
    let protocol = urlObj.protocol;

    let options = {
        hostname: urlObj.hostname,
        port: urlObj.port,
        path: urlObj.path,
        method: method,
        headers: headers,
        timeout: 10000,
    };

    let postData = qs.stringify(params || {});

    return new Promise((resolve, reject) => {
        let req = (protocol == 'http:' ? http : https).request(options, (res) => {
            let chunks = [];
            res.on('data', (data) => {
                chunks.push(data);
            });
            res.on('end', () => {
                let buffer = Buffer.concat(chunks);
                let encoding = res.headers['content-encoding'];
                if (encoding == 'gzip') {
                    zlib.unzip(buffer, function (err, decoded) {
                        resolve(decoded.toString());
                    });
                } else if (encoding == 'deflate') {
                    zlib.inflate(buffer, function (err, decoded) {
                        resolve(decoded.toString());
                    });
                } else {
                    resolve(buffer.toString());
                }
            });
        });
        req.on('error', (e) => {
            _.error('request error', method, url, params, e);
            resolve('');
        });
        req.on("timeout", (e) => {
            _.error('request timeout', method, url, params, e);
            resolve('');
        })
        if (method.toUpperCase() == 'POST') {
            req.write(postData);
        }
        req.end();
    });
}

module.exports = function () {
    return new Script;
}

function Script() {}

Script.prototype.run = async function () {
    let rst = this.getTaskList();

    console.log(rst);
}

Script.prototype.getTaskList = async function () {
    let params = {};

    let method = 'post';
    let uri = '/openapi/getTasklist';

    let rst = await _.trends.getInstance().request(method, uri, params);

    return rst;
}