xcloudsdk/dist/utils/hsdk.js

xcloud sdk

"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());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.hsdk = void 0;
class cacheManager {
    constructor(cachePrefix) {
        this._maxExpireDate = new Date("Fri, 31 Dec 9999 23:59:59 UTC");
        this._cachePrefix = "";
        this._defaultSerializer = {
            serialize: function (item) {
                return JSON.stringify(item);
            },
            // fix for "illegal access" error on Android when JSON.parse is
            // passed null
            deserialize: function (data) {
                return data && JSON.parse(data);
            },
        };
        this._cachePrefix = cachePrefix;
    }
    isValidDate(date) {
        return (Object.prototype.toString.call(date) === "[object Date]" &&
            !isNaN(date.getTime()));
    }
    getExpiresDate(expires, now) {
        now = now || new Date();
        if (typeof expires === "number") {
            expires =
                expires === Infinity
                    ? this._maxExpireDate
                    : new Date(now.getTime() + expires * 1000);
        }
        else if (typeof expires === "string") {
            expires = new Date(expires);
        }
        if (expires && !this.isValidDate(expires)) {
            throw new Error("`expires` parameter cannot be converted to a valid Date instance");
        }
        return expires;
    }
    isCacheItem(item) {
        if (typeof item !== "object") {
            return false;
        }
        if (item) {
            if ("c" in item && "exp" in item && "v" in item) {
                return true;
            }
        }
        return false;
    }
    checkCacheItemIfEffective(cacheItem) {
        var timeNow = new Date().getTime();
        return timeNow < cacheItem.exp;
    }
    setCache(key, value, exp) {
        var now = new Date().getTime();
        var exp = exp || 7000;
        var expires = this.getExpiresDate(exp, new Date());
        var cacheItem = {
            v: this._defaultSerializer.serialize(value),
            exp: expires.getTime(),
            c: now,
        };
        sessionStorage.setItem(this._cachePrefix + key, this._defaultSerializer.serialize(cacheItem));
    }
    deleteCache(key) {
        sessionStorage.removeItem(this._cachePrefix + key);
        return key;
    }
    getTokenCache(key) {
        var cacheItem = null;
        try {
            cacheItem = this._defaultSerializer.deserialize(sessionStorage.getItem(this._cachePrefix + key));
        }
        catch (e) {
            return null;
        }
        if (cacheItem != null && this.isCacheItem(cacheItem)) {
            var value = this._defaultSerializer.deserialize(cacheItem.v);
            if (this.checkCacheItemIfEffective(cacheItem)) {
                return value;
            }
            else {
                value.AccessToken = null;
            }
        }
        return null;
    }
}
class requestHelper {
    constructor(prefix) {
        this._tokenoption = new tokenOption();
        this._config = {
            v: "2.0",
            format: "json",
            app_key: "",
            authorizetype: "Code",
            sign: "",
            timestamp: "",
            sdkversion: "h-sdk-net-20180201",
        };
        this._cache = new cacheManager(prefix);
    }
    //创建请求
    createXHR() {
        var xhr = new XMLHttpRequest();
        if (xhr == null) {
            xhr = new ActiveXObject("Microsoft.XMLHTTP");
        }
        return xhr;
    }
    getAuthHeaders(token) {
        let auth = "Bearer " + token;
        return {
            Authorization: auth,
        };
    }
    //格式化参数
    formatFormParams(data) {
        let arr = [];
        for (var name in data) {
            arr.push(encodeURIComponent(name) + "=" + encodeURIComponent(data[name]));
        }
        arr.push(("v=" + Math.random()).replace(".", ""));
        return arr.join("&");
    }
    request(url, options, isform) {
        return new Promise((resolve, reject) => {
            let xhr = this.createXHR();
            xhr.open(options.method, url);
            if (options.onCreate) {
                options.onCreate(xhr);
            }
            if (options.headers) {
                Object.keys(options.headers).forEach((k) => {
                    xhr.setRequestHeader(k, options.headers[k]);
                });
            }
            xhr.upload.addEventListener("progress", (evt) => {
                if (evt.lengthComputable && options.onProgress) {
                    options.onProgress({
                        loaded: evt.loaded,
                        total: evt.total,
                    });
                }
            });
            xhr.onreadystatechange = () => {
                let responseText = xhr.responseText;
                if (xhr.readyState !== 4) {
                    return;
                }
                let reqId = ""; //xhr.getResponseHeader("x-reqId") || "";
                if (xhr.status !== 200) {
                    let message = `xhr request failed, code: ${xhr.status};`;
                    if (responseText) {
                        message = message + ` response: ${responseText}`;
                    }
                    reject({
                        code: xhr.status,
                        message: message,
                        reqId: reqId,
                        isRequestError: true,
                    });
                }
                resolve({
                    data: JSON.parse(responseText),
                    reqId: reqId,
                });
            };
            if (isform) {
                xhr.send(this.formatFormParams(options.data));
            }
            else {
                xhr.send(JSON.stringify(options.data));
            }
        });
    }
    getToken(refresh = false) {
        var tokeninfo = this._cache.getTokenCache("token");
        //获取token,并进行缓存
        var header = {
            "Content-Type": "application/json; charset=utf-8",
        };
        return new Promise((resolve, reject) => {
            if (tokeninfo == null) {
                console.log("请求token");
                return this.request(this._tokenoption.tokenurl + "/api/Auth/token", {
                    headers: header,
                    method: "POST",
                    data: {
                        AppId: this._config.app_key,
                        AuthorizeType: this._config.authorizetype,
                        UserId: this._tokenoption.userid,
                        Password: this._tokenoption.password,
                        Code: this._tokenoption.code,
                    },
                }, false).then((res) => {
                    var result = res.data;
                    if (result.IsSuccess) {
                        var data = result.Data;
                        tokeninfo = {
                            accesstoken: data.AccessToken,
                            refreshtoken: data.RefreshToken,
                        };
                        this._cache.setCache("token", tokeninfo, 7000);
                        resolve(tokeninfo);
                        // return tokeninfo;
                    }
                    else {
                        reject(result.ErrorMessage);
                        // throw result.ErrorMessage;
                    }
                }, (err) => {
                    //其他错误信息
                    reject(err);
                    // return {
                    //     Success: false,
                    //     Data: err
                    // };
                });
            }
            else if (tokeninfo != null && tokeninfo.refreshtoken && refresh) {
                //通过RefreshToken,获取accesstoken
                console.log("通过刷新请求token");
                return this.request(this._tokenoption.tokenurl +
                    "/api/Auth/refreshtoken?refreshToken=" +
                    encodeURIComponent(tokeninfo.refreshtoken), {
                    headers: header,
                    method: "POST",
                }, false).then((res1) => {
                    let res = res1;
                    var result = res.data;
                    if (result.IsSuccess) {
                        var data = result.Data;
                        tokeninfo = {
                            accesstoken: data.AccessToken,
                            refreshtoken: data.RefreshToken,
                        };
                        this._cache.setCache("token", tokeninfo, 7000);
                        resolve(tokeninfo);
                        // return tokeninfo;
                    }
                    else {
                        reject(result.ErrorMessage);
                        // throw result.ErrorMessage;
                    }
                }, (err) => {
                    //其他错误信息
                    reject(err);
                    // return {
                    //     Success: false,
                    //     Data: err
                    // };
                });
            }
            else {
                return resolve(tokeninfo);
            }
        });
    }
    setParam(inputs = {}, tables = []) {
        var hrequest = {
            input: [],
            tables: [],
        };
        for (var i in inputs) {
            if (inputs.hasOwnProperty(i) && typeof inputs[i] !== "function") {
                hrequest.input.push({
                    name: i,
                    value: inputs[i],
                });
            }
        }
        var paramStr = JSON.stringify(hrequest);
        var tokeninfo = this._cache.getTokenCache("token");
        var params = Object.assign({}, this._config, {
            param: paramStr,
            token: tokeninfo.accesstoken,
        });
        return params;
    }
    convertOutput(result) {
        var output = {};
        for (var i in result.output) {
            var item = result.output[i];
            output[item.Name] = item.value;
        }
        return output;
    }
    //通过用户名模式获取token
    settokenbyuser(userid, password) {
        this._cache.deleteCache("token");
        this._tokenoption.userid = userid;
        this._tokenoption.password = password;
        this.getToken(false)
            .then((res) => {
            console.log(res.accesstoken);
        })
            .catch((reject) => {
            console.log(reject);
        });
    }
    //通过Code模式获取token
    settokenbycode(code) {
        this._cache.deleteCache("token");
        this._tokenoption.code = code;
        this.getToken(false)
            .then((res) => {
            console.log(res.accesstoken);
        })
            .catch((reject) => {
            console.log(reject);
        });
    }
    init(options, tokenoption) {
        Object.assign(this._config, options);
        Object.assign(this._tokenoption, tokenoption);
        //this._tokenoption = tokenoption;
    }
}
class tokenOption {
    constructor() {
        this.tokenurl = "";
        this.authorizetype = "Code"; // 必填，授权类型UserName,Code
        this.userid = "";
        this.password = "";
        this.code = "";
    }
}
class hsdk {
    constructor(prefix) {
        this._requestHelper = new requestHelper(prefix);
    }
    config(options, tokenoption) {
        this._requestHelper.init(options, tokenoption);
    }
    request(url_1) {
        return __awaiter(this, arguments, void 0, function* (url, inputs = {}, tables = []) {
            var header = {
                "Content-Type": "application/x-www-form-urlencoded",
            };
            var tokeninfo = yield this._requestHelper.getToken();
            //请求数据
            return this._requestHelper
                .request(url, {
                headers: header,
                method: "POST",
                data: this._requestHelper.setParam(inputs, tables),
            }, true)
                .then((res) => {
                var result = res.data;
                if (result.ErrorCode == 0) {
                    var output = this._requestHelper.convertOutput(result);
                    return {
                        Success: true,
                        Message: result.ErrorMessage,
                        Data: output,
                    };
                }
                if (result.ErrorCode == 3012) {
                    //token过期,需要通过refreshtoken重新获取
                    this._requestHelper
                        .getToken(true)
                        .then((res) => {
                        console.log(res.accesstoken);
                    })
                        .catch((reject) => {
                        console.log(reject);
                    });
                }
                else {
                    //其他错误信息
                    return {
                        Success: false,
                        Message: result.ErrorMessage,
                        Code: result.ErrorCode,
                    };
                }
            }, (err) => {
                //其他错误信息
                return {
                    Success: false,
                    Data: err,
                };
            });
        });
    }
    //通过用户名模式获取token
    settokenbyuser(userid, password) {
        this._requestHelper.settokenbyuser(userid, password);
    }
    //通过Code模式获取token
    settokenbycode(code) {
        this._requestHelper.settokenbycode(code);
    }
    getToken() {
        this._requestHelper.getToken();
    }
    //通过refreshToken模式获取token
    settokenbyrefresh() {
        this._requestHelper
            .getToken(true)
            .then((res) => {
            console.log(res.accesstoken);
        })
            .catch((reject) => {
            console.log(reject);
        });
    }
    getparam(inputs = {}, tables = []) {
        return this._requestHelper.setParam(inputs, tables);
    }
    getoutput(result) {
        return this._requestHelper.convertOutput(result);
    }
}
exports.hsdk = hsdk;
var hsdk1 = new hsdk("");
exports.default = hsdk1;
var w = window;
if (!w.hsdk) {
    w.hsdk = new hsdk("sdk");
}