mtl-js-sdk/lib/platforms/yyzone/user/index.js

ynf-fw-mtl-api

import { invokeFail, invokeSuccess } from '../callback'
import { execUpesnBridgeify, execUpesnBridge, canExecUpesnBridge } from '../bridge/index'
import { getUserAgentInternal, setYhtCookie, getExclusiveDomainInfo } from '../util'
import { setLanguage } from '../localization'
import {
    exclusiveUserInfoKey, saveExclusiveYhtInfoKey, exclusiveDomainKey,
    setUserYHTInfoKey, onlinePreloadMdf, offlinePreloadMdf, onlineName, offlineName, businessDateKey
} from '../keys'

export function getUserInfo(param = {}) {
    let userInfo = api.getPrefs({
        sync: true,
        key: exclusiveUserInfoKey
    });
    if (userInfo) {
        invokeSuccess(param, JSON.parse(userInfo));
    } else {
        invokeFail(param, {});
    }
}

export function getUserYHTInfo(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('getUserYHTInfo', param, false);
        return;
    }

    var userInfo = api.getPrefs({
        sync: true,
        key: setUserYHTInfoKey
    });

    if (userInfo) {
        invokeSuccess(param, JSON.parse(userInfo));
    } else {
        invokeFail(param, {});
    }
}

export function setUserYHTInfo(param = {}) {
    // let {userName,tenant_id,yht_userid,yhtToken,tenant_name} = param;
    if (param) {
        api.setPrefs({
            sync: true,
            key: setUserYHTInfoKey,
            value: JSON.stringify(param)
        });

        invokeSuccess(param, {});
    } else {
        invokeFail(param, {});
    }
}

export function setExclusiveLanguage(param = {}) {
    setLanguage(param);
    invokeSuccess(param, {});
}

export function getExclusiveAppH5LocationPath(param = {}) {
    let path = api.wgtRootDir + '/dist/index.html#/workbench/login';
    invokeSuccess(param, { path });
}

export function getExclusiveCode(param = {}) {
    let domainObj = getExclusiveDomainInfo();
    if (!domainObj) {
        invokeFail(param, { message: 'domain error' });
        return;
    }

    let { domain, data } = domainObj;
    let baseUrl, getEsnCode;
    if (data) {
        baseUrl = data.baseUrl;
        getEsnCode = data.getEsnCode;
    }
    let url;
    if (baseUrl && getEsnCode) {
        url = baseUrl + getEsnCode;
    } else {
        if (domain.substr(domain.length - 1, 1) == '/') {
            domain = domain.substr(0, domain.length - 1);
        }
        url = domain + '/rest/v1/mobile/user/yht/auth/code';
    }
    let yht_access_token, wb_at;
    let yhtInfoStr = api.getPrefs({
        sync: true,
        key: saveExclusiveYhtInfoKey
    });
    if (yhtInfoStr) {
        let yhtInfo = JSON.parse(yhtInfoStr);
        if (yhtInfo) {
            yht_access_token = yhtInfo.yht_access_token;
            wb_at = yhtInfo.wb_at;
        }
    }
    let userId, tenantId;
    let userInfo = api.getPrefs({
        sync: true,
        key: exclusiveUserInfoKey
    });
    if (userInfo) {
        let obj = JSON.parse(userInfo);
        if (obj) {
            userId = obj.userId;
            tenantId = obj.tenantId;
        }
    }
    api.ajax({
        url: url,
        data: {
            values: {
                tenantId: tenantId || '',
                wb_at: wb_at || '',
                yhtAccessToken: yht_access_token || ''
            }
        }
    }, function (ret, err) {
        if (ret) {
            if (ret.data) {
                invokeSuccess(param, { code: ret.data });
            } else {
                invokeFail(param, ret);
            }
        } else {
            invokeFail(param, err);
        }
    });
}

export function saveExclusiveYhtInfo(param = {}) {
    let obj = api.require('yonBuilder');
    const { yht_access_token, wb_at } = param;
    if (yht_access_token && wb_at) {
        api.setPrefs({
            sync: true,
            key: saveExclusiveYhtInfoKey,
            value: JSON.stringify(param)
        });
        obj.setUserAgent({ userAgent: getUserAgentInternal() });
        invokeSuccess(param, {});
    } else {
        invokeFail(param, {});
    }
    obj.saveExclusiveYhtInfo && obj.saveExclusiveYhtInfo(param);
}

export function saveExclusiveUserInfo(param = {}) {
    api.setPrefs({
        sync: true,
        key: exclusiveUserInfoKey,
        value: JSON.stringify(param)
    });
    invokeSuccess(param, {});
}

export function saveExclusiveDomain(param = {}) {
    let obj = api.require('yonBuilder');
    obj.saveExclusiveDomain && obj.saveExclusiveDomain(param);
    api.setPrefs({
        sync: true,
        key: exclusiveDomainKey,
        value: JSON.stringify(param)
    });
    invokeSuccess(param, {});
}

export function isExclusivePreloadMDF(param = {}) {
    let { isPreload, mdfUrl } = param;

    if (!mdfUrl) {
        invokeFail(param, { message: 'mdfUrl is null!' });
        return;
    }

    const preloadMDFName = (mdfUrl.includes('https://') || mdfUrl.includes('http://')) ? onlineName : offlineName

    if (!isPreload) {
        api.closeWin({
            name: PreloadMDFName,
            singleInstance: true
        })
        invokeSuccess(param, {});
        return;
    }

    setYhtCookie(mdfUrl);

    const key = (mdfUrl.includes('https://') || mdfUrl.includes('http://')) ? onlinePreloadMdf : offlinePreloadMdf
    api.setGlobalData({
        key: key,
        value: ''
    });

    let browserPath = api.systemType == 'harmonyos' ? 'package://res_yonBuilder/widget/html/browser/browser.html' : 'package://res_yonBuilder/widget/build/browser/browser.js';
    api.openTabLayout({
        name: PreloadMDFName,
        url: browserPath,
        hidden: true,
        singleInstance: true,
        reload: true,
        statusBarAppearance: false,
        slidBackType: 'edge',
        navigationBar: {},
        pageParam: {
            url: mdfUrl,
            headers: {
                'User-Agent': getUserAgentInternal()
            },
            frameParam: {
                reload: true
            }
        }
    });
    invokeSuccess(param, {});
}

export function gainUserInfo(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('gainUserInfo', param, false);
        return;
    }
    var userInfo = api.getPrefs({
        sync: true,
        key: setUserYHTInfoKey
    });

    if (userInfo) {
        const obj = JSON.parse(userInfo) || {}
        invokeSuccess(param, {
            userId: obj.yht_userid,
            name: obj.userName,
            qzId: obj.tenant_id,
            loginName: obj.userName,
            qzName: obj.tenant_name,
            avatar: obj.userAvatar,
        });
    } else {
        invokeFail(param, {});
    }
}

export function getToken(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('getToken', param, false);
        return;
    }

    var userInfo = api.getPrefs({
        sync: true,
        key: setUserYHTInfoKey
    });

    if (userInfo) {
        const obj = JSON.parse(userInfo) || {}
        invokeSuccess(param, { token: obj.yhtToken });
    } else {
        invokeFail(param, {});
    }
}

export function setBusinessDate(param = {}) {
    let businessDateString = param.businessDateString;
    if (typeof businessDateString == 'string') {
        api.setPrefs({
            sync: true,
            key: businessDateKey,
            value: businessDateString
        })
    }
}

export function getBusinessDate(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridge({
            method: 'getBusinessDate',
            ...param
        });
        return;
    }
    let businessDateString = api.getPrefs({ sync: true, key: businessDateKey });
    invokeSuccess(param, { businessDateString: businessDateString ? businessDateString : '' });
}

export function mtlContext(param = {}) {
    let domainObj = getExclusiveDomainInfo();
    let storageDomain = ''
    if (domainObj) {
        let { domain } = domainObj;
        if (domain) {
            storageDomain = domain
        }
    }
    if (window.location.href.includes('https')) {
        storageDomain = window.location.origin
    }
    const { domain = storageDomain } = param
    if (domain && domain.length > 0) {
        const url = `${domain}/me?onlyShayat=false`;
        let mtlResult = mtl.getStorageSync({ key: url })
        if (mtlResult) {
            try {
                mtlResult = JSON.parse(mtlResult)
            } catch (error) {
            }
            invokeSuccess(param, mtlResult)
            return
        }
        window.mtl.request({
            url,
            success: function (res) {
                let { data } = res
                if (data) {
                    if (typeof (data) === 'string') {
                        data = JSON.parse(res.data)
                    }
                    if (data.data) {
                        mtl.setStorage({
                            key: url,
                            data: JSON.stringify(data.data)
                        });
                        invokeSuccess(param, data.data)
                    } else {
                        mtl.setStorage({
                            key: url,
                            data: JSON.stringify(data)
                        });
                        invokeSuccess(param, data)
                    }
                } else {
                    mtl.setStorage({
                        key: url,
                        data: JSON.stringify(res)
                    });
                    invokeSuccess(param, res)
                }
            },
            fail: function (err) {
                invokeFail(param, res)
            }
        })
    } else {
        console.log('mtlContext domain is null')
    }
}