mtl-js-sdk/lib/platforms/all-platform/ucg/index.js

ynf-fw-mtl-api

import config from './config.js'
import xaxios from 'axios'
let readUCGConfig = config.readUCGConfig;
const axios = xaxios?.default || xaxios

function getUrl(object, suffix) {
    let { appCode } = object;
    let UCGConfig = appCode ? readUCGConfig({ appcode: appCode }) || {} : {};
    let {
        isHttps = UCGConfig.isHttps || false,
        port = UCGConfig.port || "",
        host = UCGConfig.host || "",
        url = "",
        _suffix = suffix
    } = object;
    if (url.indexOf("http") != -1) {
        let _url = `${url}${_suffix}`;
        return _url;
    } else {
        let http = isHttps ? "https://" : "http://";
        let _port = port ? ":" + port : "";
        let _url = host ? `${http}${host}${_port}${url}${_suffix}` : `${url}${_suffix}`;
        return _url;
    }
}

function getTerminalType() {
    let terminalType = "";
    let platform = mtl.platform;
    switch (platform) {
        case "android":
            terminalType = "Android";
            break;
        case "ios":
            terminalType = "IOS";
            break;
        case "wx":
            terminalType = "WX";
            break;
        case "dd":
            terminalType = "DD";
            break;
        case "h5":
            terminalType = "h5";
            break;
        case "upesn":
            terminalType = "upesn";
            break;
        default:
            break;
    }
    return terminalType;
}

function onCommon(func, object) {
    let promise = new Promise(func);
    promise.then(res => {
        object.success && object.success(res.data);
        object.complete && object.complete(res);
    }).catch(err => {
        object.fail && object.fail(err);
        object.complete && object.complete(err);
    });
}

function _loginByUser(object, resolve, reject) {
    let terminalType = object.terminalType || getTerminalType();
    let { appCode, userName, password } = object;
    let _url = getUrl(object, "/mtl/login");
    console.log(_url);
    // 调用网络请求，请求登录接口
    let target = {
        url: _url,
        method: "POST", // 默认值
        data: {
            userName: userName,
            password: password,
            appCode: appCode,
            terminalType: terminalType
        },
        header: {
            "content-type": "application/json" // 默认值
        },
        complete(res) {
            resolve && resolve(res);
        },
        fail(err) {
            reject && reject(err);
        }
    };
    request(target);
}

function _loginByCode(object, resolve, reject) {
    let terminalType = object.terminalType || getTerminalType();
    let { appCode, code } = object;
    let _url = getUrl(object, "/mtl/loginThird");
    if (typeof code == "undefined" || !!!code) {
        mtl.getAuthCode({
            success: res => {
                let code = res.authCode;
                console.log('authCode', code);
                // 调用网络请求，请求登录接口
                if (terminalType == 'WX') {
                    mtl.getUserInfo({
                        complete: res => {
                            let userInfo = res.data ? res.data.userInfo : "";
                            let data = {
                                appCode: appCode,
                                userInfo: userInfo || null,
                                code: code,
                                terminalType: terminalType
                            }
                            _loginRequest(_url, data, resolve, reject);

                        }
                    });
                } else {
                    let data = {
                        appCode: appCode,
                        code: code,
                        terminalType: terminalType
                    }
                    _loginRequest(_url, data, resolve, reject);
                }
            }
        });
    } else {
        // 调用网络请求，请求登录接口
        let data = {
            appCode: appCode,
            code: code,
            terminalType: terminalType
        };

        _loginRequest(_url, data, resolve, reject);
    }
}
function _loginRequest(_url, data, resolve, reject) {
    console.log('_loginRequest', JSON.stringify(data));
    request({
        url: _url,
        method: "POST",
        data: data,
        header: {
            "content-type": "application/json" // 默认值
        },
        complete(res) {
            resolve && resolve(res);
        },
        fail(err) {
            reject && reject(err);
        }
    });
}

function _bindUser(object, resolve, reject) {
    let terminalType = object.terminalType || getTerminalType();
    let {
        appCode,
        tenantCode,
        userName,
        password,
        type,
        code,
        deviceId,
        langCode,
        yhtId
    } = object;
    let _url = getUrl(object, "/mtl/bind");
    console.log(_url);
    // 调用网络请求，请求登录接口
    request({
        url: _url,
        method: "POST", // 默认值
        data: {
            tenantCode: tenantCode,
            userName: userName,
            password: password,
            appCode: appCode,
            type: type,
            code: code,
            deviceId: deviceId,
            langCode: langCode,
            yhtId: yhtId,
            terminalType: terminalType
        },
        header: {
            "content-type": "application/json" // 默认值
        },
        complete(res) {
            resolve && resolve(res);
        },
        fail(err) {
            reject && reject(err);
        }
    });
}

function _getToken(object, resolve, reject) {
    let { appCode, tenantCode, code, deviceId, langCode, yhtId } = object;
    let terminalType = object.terminalType || getTerminalType();
    let _url = getUrl(object, "/mtl/getToken");
    console.log(_url);
    // 调用网络请求，请求登录接口
    request({
        url: _url,
        method: "POST", // 默认值
        data: {
            tenantCode: tenantCode,
            appCode: appCode,
            code: code,
            deviceId: deviceId,
            langCode: langCode,
            yhtId: yhtId,
            terminalType: terminalType
        },
        header: {
            "content-type": "application/json" // 默认值
        },
        fail(err) {
            reject(err);
        },
        complete(res) {
            resolve(res);
        }
    });
}

function login(object) {
    let platform = mtl.platform;
    object.terminalType = object.terminalType || getTerminalType();
    switch (platform) {
        case "android":
        case "ios":
            mtl.ucg.loginByUser(object);
            break;
        case "wx":
        case "dd":
            mtl.ucg.loginByCode(object);
            break;
        case "upesn":
        case "h5":
            if (object.code) {
                mtl.ucg.loginByCode(object);
            }
            break;
        default:
            break;
    }
}

function loginByUser(object) {
    let { appCode } = object;
    onCommon((resolve, reject) => {
        if (typeof appCode == "undefined" || !!!appCode) {
            mtl.getAppCode({
                success: res => {
                    let appCode = res.appCode;
                    object.appCode = appCode;
                    _loginByUser(object, resolve, reject);
                }
            });
        } else {
            _loginByUser(object, resolve, reject);
        }
    }, object);
}

function loginByCode(object) {
    // code
    onCommon((resolve, reject) => {
        let { appCode } = object;
        if (typeof appCode == "undefined" || !!!appCode) {
            mtl.getAppCode({
                success: res => {
                    let appCode = res.appCode;
                    console.log('appCode', appCode);
                    object.appCode = appCode;
                    _loginByCode(object, resolve, reject);
                }
            });
        } else {
            _loginByCode(object, resolve, reject);
        }
    }, object);
}

function bindUser(object) {
    // code
    let terminalType = object.terminalType || getTerminalType();
    onCommon((resolve, reject) => {
        _bindUser(object, resolve, reject);
    }, object);
}

function getToken(object) {
    // code
    onCommon((resolve, reject) => {
        if (typeof object.appCode == "undefined" || !!!object.appCode) {
            mtl.getAppCode({
                success: res => {
                    let appCode = res.appCode;
                    object.appCode = appCode;
                    _getToken(object, resolve, reject)
                },
                fail: (res) => {
                    object.fail && object.fail(res);
                }
            });
        } else {
            _getToken(object, resolve, reject);
        }
    }, object);
}

function callAction(object) {
    // let {appCode,token} = object;
    // token || config.getToken(appCode);
    // if(token){
    //   let resErr = {
    //     code:-1,
    //     message:`appCode :${appCode},未登录,当前未取到token`
    //   }
    //   object.fail && object.fail(resErr);
    //   object.complete && object.complete(resErr);
    //   return;
    // }
    // code
    onCommon((resolve, reject) => {
        let headers = object.headers || {};
        let data = object.data || {};
        let params = object.params || {};
        // headers.token = token;
        let _url = getUrl(object, "");
        console.log(_url);
        // 调用网络请求，请求登录接口
        request({
            url: _url,
            method: "POST", // 默认值
            data: data,
            params: params,
            headers: headers,
            complete(res) {
                resolve(res);
            },
            fail(err) {
                reject(err);
            }
        });
    }, object);
}
function uploadFile(object) {
    onCommon((resolve, reject) => {
        let headers = object.headers || {};
        let formData = object.formData || {};
        let filePath = object.filePath || {};
        let _url = getUrl(object, "");
        console.log(_url);
        // 调用网络请求，请求登录接口
        mtl.uploadFile({
            url: _url,
            header: headers,
            formData: formData,
            filePath: filePath,
            complete(res) {
                resolve(res);
            },
            fail(err) {
                reject(err);
            }
        });
    }, object);
}

/**
 * 推送消息的监听，当钉钉端接收到消息时会通过object的回调方法传送
 * @param {*} object
 */
function addPushListener(object) {
    let platform = mtl.platform;
    if ("dd" == platform) {
        mtl.addPushListener(object);
    } else {
        object.complete && object.complete({
            code: 200,
            message: "",
            data: {}
        });
        return;
    }
}

function request(object) {
    axios(object).then(res => {
        let { status: code, statusText: message, data } = res;
        if (code === 200) {
            object.success && object.success(data);
        } else {
            object.fail && object.fail({ code, message, data });
        }
        object.complete && object.complete({ code, message, data });
    }).catch(err => {
        const result = { code: 1, message: err.message };
        object.fail && object.fail(result);
        object.complete && object.complete(result);
    });
}

export default {
    config,
    getUrl,
    getTerminalType,
    login,
    uploadFile,
    loginByUser,
    loginByCode,
    bindUser,
    getToken,
    callAction,
    writeUCGConfig: config.writeUCGConfig,
    readUCGConfig: config.readUCGConfig,
    addPushListener
};