t-lj-service 1.0.1

package/module/permission.ts

@@ -0,0 +1,255 @@
+// import nodes from './../../public/nodes.json';
+import {randomInt, setLocal, decrypt, message} from './hooks';
+import {POST, type ServiceResponse, CreateQuery} from './service';
+let allStatus: boolean = false;
+
+const configParams: string = JSON.stringify([{
+    key: "FrontConfig",
+    value: JSON.stringify({ ConfigIden: "", ConfigType: "APP", ConfigContent: "" }),
+}]);
+
+const serviceParams: string = JSON.stringify([{
+    key: "FrontConfig",
+    value: JSON.stringify({  ConfigIden: "", ConfigType: "biznode".toUpperCase(), ConfigContent: "" }),
+}]);
+const nodeCenterParams: string = JSON.stringify([{
+    key: "FrontConfig",
+    value: JSON.stringify({  ConfigIden: "", ConfigType: "nodecenter".toUpperCase(), ConfigContent: "" }),
+}]);
+
+interface OWN {
+    sign?: string;
+    serviden?: string;
+    checkTokenServiden?: string;
+    version?: string;
+    host?: string;
+    servpath?: string;
+    params?: string;
+    type?: string;
+    secretKey?: string;
+    nodes?: any[];
+    appConfig?: any;
+    token?: any;
+    config?: any;
+}
+
+const _replace = (path: string = '/permission-denied'): void => {
+    window.location.href = `${window.location.origin}${path}`;
+}
+
+const _address = async (serviden: string = '', version: string = '', nodes: any[] = []): Promise<any> => {
+    let host: string = '', node: any = null;
+    nodes.forEach((el: any) => {
+        if (el.serviden === serviden && el.version === version) {
+            const {url_addrs} = el;
+            const idx: number = randomInt(0, url_addrs.length);
+            const urls = url_addrs[idx];
+            host = urls.ipaddr;
+            node = el;
+        }
+    })
+    return {
+        host, node,
+    };
+}
+
+const _loadConfig = async ({
+    host = '',
+    servpath = '',
+    serviden = '',
+    params = '',
+}: OWN = {}): Promise<ServiceResponse> => {
+    const res: ServiceResponse = await POST(`${host}${servpath}/LoadFConfig`, CreateQuery({
+        ServIdentifer: serviden,
+        BizType: 'nodes',
+        ReqDatas: params,
+    }));
+    return res;
+}
+
+
+const _initType = async ({
+    host = '',
+    servpath = '',
+    serviden = '',
+    type = '',
+    secretKey = '',
+    version = '',
+    nodes = [],
+    checkTokenServiden = '',
+    appConfig = {},
+}: OWN = {}): Promise<void> => {
+    const { keytoken, ivtoken, loginType } = appConfig;
+    if (type === 'SSO') {
+        await setLocal('sessionislogin', 'Y');
+        await _load();
+    } else if (type === 'NON') {
+        if(loginType === 'CUS' || loginType === 'SSO') {
+            _replace();
+        } else {
+            await setLocal('sessionislogin', 'N');
+            let token: any = await decrypt(secretKey, keytoken, ivtoken);
+            token = token !== '' ? JSON.parse(token) : {};
+            await setLocal('sessiontoken', token);
+            await setLocal('sessioncurrlang', token.Currlang);
+            await _load({ host, servpath, serviden, token, checkTokenServiden, version, nodes });
+        }
+    } else {
+        _status();
+        _replace();
+    }
+}
+
+const _load = async ({
+    host = '',
+    servpath = '',
+    serviden = '',
+    checkTokenServiden = '',
+    nodes = [],
+    version = '',
+    token = {},
+}: OWN = {}): Promise<void> => {
+    await _loadUseServices({
+        host,
+        servpath,
+        serviden,
+        params: serviceParams,
+    });
+    await _loadNodeCenter({
+        host,
+        servpath,
+        serviden,
+        params: nodeCenterParams,
+    });
+    // await _loadI18(token.Currlang);
+    // await _loadI18Item();
+    await _checkToken({
+        token, checkTokenServiden, nodes, version
+    });
+}
+
+const _loadUseServices = async ({
+    host = '',
+    servpath = '',
+    serviden = '',
+    params = '',
+}: OWN = {}): Promise<void> => {
+    const {data, code, msg}: ServiceResponse = await _loadConfig({host, servpath, serviden, params});
+    if (code === 1) {
+        const useservices: any = data.length > 0 ? data[0].ConfigContent.biznode : [];
+        await setLocal('sessionuseservices', useservices);
+        _status(true);
+    } else {
+        _status();
+        message(msg, 'error');
+        _replace();
+    }
+}
+const _loadNodeCenter = async ({
+    host = '',
+    servpath = '',
+    serviden = '',
+    params = '',
+}: OWN = {}): Promise<void> => {
+    const {data, code, msg}: ServiceResponse = await _loadConfig({host, servpath, serviden, params});
+    if (code === 1) {
+        const nodecenter: any = data.length > 0 ? data[0].ConfigContent : {};
+        await setLocal('sessionnodecenter', nodecenter);
+        _status(true);
+    } else {
+        _status();
+        message(msg, 'error');
+        _replace();
+    }
+}
+
+// const _loadI18 = async (lang: string): Promise<void> => {
+//     try {
+//         const i18: any = await import(`./../../public/i18nlang/i18nframe_${lang}.json`);
+//         await setLocal('sessioni18nframelang', i18);
+//         _status(true);
+//     } catch (err: any){
+//         message(err.message, 'error');
+//         _status();
+//     }
+// }
+// const _loadI18Item = async (): Promise<void> => {
+//     try {
+//         const i18Item: any = await import(`./../../public/i18nlang/i18nframeItem.json`);
+//         await setLocal('sessionlangitem', i18Item.langItemsubs);
+//         _status(true);
+//     } catch (err: any){
+//         message(err.message, 'error');
+//         _status();
+//     }
+// }
+// const _loadSystemMenuItem = async (): Promise<void> => {
+//     try {
+//         const i18Item: any = await import(`./../../public/i18nlang/i18nframesystem.json`);
+//         await setLocal('sessionsystemmenu', i18Item);
+//         _status(true);
+//     } catch (err: any){
+//         message(err.message, 'error');
+//         _status();
+//     }
+// }
+const _checkToken = async ({
+    token = {},
+    checkTokenServiden = '',
+    version = '',
+    nodes = [],
+}: OWN = {}): Promise<void> => {
+    const { node, host } = await _address(checkTokenServiden, version, nodes);
+    const check: string = JSON.stringify([{
+        key: "SSY_DYNAMICTOKEN", value: JSON.stringify({
+            ID: token.Tokenud.split('_')[0], Dynamictoken: token.Tokenud.split('_')[1]
+        })
+    }]);
+    const { code, msg }: ServiceResponse = await POST(`${host}${node.servpath}/CheckToken`, CreateQuery({
+        ServIdentifer: checkTokenServiden,
+        BizType: 'nodes',
+        ReqDatas: check,
+    }), { 'Token': JSON.stringify(token) });
+    if(code === 1){
+        await setLocal('sessiontokenok', '1');
+        _status(true);
+        // await _loadSystemMenuItem();
+    } else {
+        _status();
+        message(msg, 'error');
+        _replace();
+    }
+}
+
+const _status = (status: boolean = false): void => {
+    allStatus = status;
+}
+
+export const permission = async ({
+    sign = '',
+    serviden = 'DevCenterManager',
+    version = '1.0',
+    checkTokenServiden = 'DevCenterSecrity',
+    config = {},
+}: OWN = {}): Promise<any> => {
+    _status();
+    const type: string = sign.substring(0, 3);
+    const secretKey: string = sign.substring(3, sign.length);
+    const { biznode }: any = config;
+    const {host, node} = await _address(serviden, version, biznode);
+    await setLocal('sessioncurraddr', host);
+    await setLocal('sessionnodes', node);
+    const {servpath} = node;
+    const {data, code, msg}: ServiceResponse = await _loadConfig({host, servpath, serviden, params: configParams});
+    if (code === 1) {
+        _status(true);
+        const appConfig: any = data.length > 0 ? data[0].ConfigContent : {};
+        await setLocal('sessionappconfig', appConfig);
+        await _initType({type, secretKey, appConfig, host, servpath, serviden, checkTokenServiden, version,  nodes: biznode });
+        return allStatus;
+    } else {
+        _status();
+        message(msg, 'error');
+        _replace();
+    }
+}

package/module/qiankun/actions.ts

@@ -0,0 +1,15 @@
+import  { initGlobalState, type MicroAppStateActions } from 'qiankun';
+
+const state = {
+    token: '',
+};
+
+export const actions: MicroAppStateActions = initGlobalState(state);
+
+actions.onGlobalStateChange((state, prev) => {
+
+    console.log(state, prev);
+
+})
+
+

package/module/qiankun/micro-apps.ts

@@ -0,0 +1,14 @@
+const apps: any[] = [
+    // {
+    //     name: 'business',
+    //     entry: import.meta.env.VITE_APP_ENV === 'production' ? 'http://1.119.199.37:19096' : '//localhost:9096',
+    //     activeRule: '/business/',
+    // },
+    // {
+    //     name: 'smart',
+    //     entry: import.meta.env.VITE_APP_ENV === 'production' ? 'http://1.119.199.37:19097' : '//localhost:9097',
+    //     activeRule: '/smart/',
+    // },
+];
+
+export default apps ;

package/module/qiankun/qiankun.ts

@@ -0,0 +1,181 @@
+import { createApp, type Component } from 'vue';
+import {
+    registerMicroApps,
+    runAfterFirstMounted,
+    start,
+} from 'qiankun';
+import {
+    qiankunWindow,
+    type QiankunProps,
+    renderWithQiankun
+} from 'vite-plugin-qiankun/dist/helper';
+// import microApps from './micro-apps'
+import { actions } from './actions'
+const loader = (loading: boolean): void => {
+    console.log('loading', loading);
+}
+
+
+const initApps = (apps: any[] = [], container: string = '#container'): void => {
+    const microApps: any[] = apps.map((item: any) => {
+        return {
+            ...item,
+            container,
+            loader,
+            props: {
+                actions,
+                routerBase: item.activeRule,
+            },
+            sandbox: {
+                strictStyleIsolation: false,
+                experimentalStyleIsolation: false,
+                fallback: true
+            },
+            afterMount: () => {
+                console.log('子应用加载完成');
+            }
+        }
+    });
+
+    registerMicroApps(
+        microApps,
+        {
+            beforeLoad: (app: any) => {
+                console.log('[LifeCycle] before load %c%s', app.name);
+                return Promise.resolve();
+            },
+            beforeMount: (app: any) => {
+                console.log('[LifeCycle] before mount %c%s', app.name);
+                return Promise.resolve();
+            },
+            afterUnmount: (app: any) => {
+                console.log('[LifeCycle] before unmount %c%s', app.name);
+                return Promise.resolve();
+            }
+        }
+    )
+}
+
+const startApp = (apps: any[] = [], container: string = '#container') => {
+    initApps(apps, container);
+    start({
+        prefetch: 'all',
+        singular: true,
+        // sandbox: {
+        //     experimentalStyleIsolation: true,
+        // }
+    });
+    runAfterFirstMounted(() => {
+        console.log('[MainApp] first app mounted')
+    })
+}
+const autoApp = (url: string = '/business/') => {
+    window.history.replaceState({}, '', url)
+}
+
+
+
+
+//  子系统
+type GlobalIcons = Record<string, Component>;
+const _setInner = (container: HTMLDivElement) => {
+    container.style.width = `${window.innerWidth - 30}px`
+    container.style.height = `${window.innerHeight - 85}px`
+    container.style.boxSizing = `border-box`
+}
+const _window = (container: HTMLDivElement, type: number = 1) => {
+    if(type === 1){
+        window.addEventListener('resize', () => _setInner(container));
+    } else {
+        window.removeEventListener('resize', () => _setInner(container));
+    }
+}
+const render = (
+    root: ReturnType<typeof createApp>,
+    App: Component | null = null,
+    use: any[] = [],
+    id: string = '#container',
+    icons: GlobalIcons | null = null,
+    props: QiankunProps = {},
+) => {
+    const { container, actions } = props;
+    root = createApp(App);
+
+    actions?.onGlobalStateChange((state: any, prev: any) => {
+        console.log('子应用监听到全局状态变化:', state, prev);
+        // 可以在这里处理状态变化逻辑
+    });
+
+    if(icons){
+        for (const [key, component] of Object.entries(icons)) {
+            root.component(key, component)
+        }
+    }
+
+    use.forEach((item: any) => {
+        root.use(item.module, item.options || {});
+    })
+    // registerElementPlusIcons(root);
+    // root.use(router);
+    // root.use(ElementPlus, {
+    //     locale: ZhCn,
+    // });
+    // root.use(i18n);
+
+    const c: any = container?.querySelector(id) || document.querySelector(id);
+    _setInner(c);
+    _window(c)
+    root.mount(c);
+}
+
+const initQianKun = (
+    root: ReturnType<typeof createApp>,
+    App: Component | null = null,
+    use: any[] = [],
+    id: string = '#container',
+    icons: GlobalIcons | null = null,
+):void => {
+    renderWithQiankun({
+        async mount(props: QiankunProps) {
+            console.log(props);
+            render(root, App, use, id, icons, props);
+        },
+        bootstrap() {},
+        unmount(props: QiankunProps): void | Promise<void> {
+            const { container } = props;
+            const c: any = container?.querySelector(id) || document.querySelector(id);
+            _window(c, 0);
+            root.unmount();
+        },
+        update(props: QiankunProps): void | Promise<void> {
+            console.log('子应用接收到更新:', props);
+            // 可以在这里重新渲染或者更新组件状态
+            return;
+        },
+    });
+};
+const useApp = ({
+    root = null,
+    App = null,
+    use = [],
+    id = '#container',
+    icons = null,
+}: {
+    root?: ReturnType<typeof createApp> | null,
+    App?: Component | null,
+    use?: any[],
+    id?: string,
+    icons?: GlobalIcons | null,
+} = {}) => qiankunWindow.__POWERED_BY_QIANKUN__ ? initQianKun(root, App, use, id, icons) : render(root, App, use, id ,icons);
+
+
+
+
+
+export {
+    autoApp,
+    startApp,
+    useApp,
+}
+
+

package/module/service.ts

@@ -0,0 +1,109 @@
+import Axios, { type AxiosResponse } from 'axios';
+import {
+    TIME_OUT,
+    BASE_URL,
+    CreateQuery,
+    DEFAULT_QUERY,
+    CreateParams,
+    RequestConfig
+} from './config';
+import hooks from './hooks'
+import { Code, HttpCodeMessage } from './code'
+
+export interface ServiceResponse<T = any> {
+    code: number;
+    data: T;
+    msg: string;
+    [key: string]: any;
+}
+
+const service = Axios.create({
+    baseURL: BASE_URL,
+    timeout: TIME_OUT,
+    headers: {
+        'Content-Type': 'application/json;charset=UTF-8',
+        'Token': hooks.getLocal('token') || '',
+        'Authorization': `Bearer ${hooks.getLocal("token")}`
+    }
+});
+
+
+service.interceptors.request.use(
+    (config: any) => {
+        hooks.loading();
+        return RequestConfig(config);
+    },
+    (error: any) => {
+        console.log(error)
+        hooks.loading(false);
+        let msg: string = error.message
+        let code: number = Number(`-${error?.request?.status || 500}`);
+        if(error.code === 'ERR_NETWORK'){
+            code = 999;
+            msg = HttpCodeMessage[code]
+        } else if(Code.indexOf(error.request.status) !== -1 && error.code !== 'ERR_NETWORK'){
+            msg = HttpCodeMessage[error.request.status]
+        }
+        hooks.message(msg, 'error');
+        return Promise.reject({
+            code,
+            data: null,
+            msg,
+        });
+    }
+
+)
+
+service.interceptors.response.use(
+    (response: AxiosResponse) => {
+        hooks.loading(false);
+        const data = response.data;
+        if (response.status === 200) {
+            data.code = Number(data.Status);
+            data.msg = data.RespErrorDatas || data.RespSuccessInfo;
+            if(data.code !== 1){
+                hooks.message(data.msg, 'error')
+            }
+            try {
+                data.data = data.RespDatas !== '' ? JSON.parse(data.RespDatas) : data.RespDatas;
+            } catch (err:any) {
+                data.data = data.RespDatas;
+            }
+            return data;
+        } else {
+            hooks.message(HttpCodeMessage[response.status], 'error')
+            data.code = response.status;
+            data.msg = HttpCodeMessage[response.status];
+            data.data = null;
+            return data;
+        }
+    },
+    (error) => {
+        console.log(error)
+        hooks.loading(false);
+        let msg: string = error.message
+        let code: number = Number(`-${error?.request?.status || 500}`);
+        if(error.code === 'ERR_NETWORK'){
+            code = 999;
+            msg = HttpCodeMessage[code]
+        } else if(Code.indexOf(error.request.status) !== -1 && error.code !== 'ERR_NETWORK'){
+            msg = HttpCodeMessage[error.request.status]
+        }
+        hooks.message(msg, 'error');
+        return {
+            code,
+            data: null,
+            msg,
+        }
+    }
+)
+
+type ApiResponse<T> = T extends ServiceResponse<infer U> ? ServiceResponse<U> : ServiceResponse<T>;
+
+export const GET = <T = ServiceResponse>(url: string, params?: any): Promise<ApiResponse<T>> => service.get(url, {params});
+export const POST = <T = ServiceResponse>(url: string, data?: any, headers?: any): Promise<ApiResponse<T>> => service.post(url, data, headers);
+export const DELETE = <T = ServiceResponse>(url: string, params?: any): Promise<ApiResponse<T>> => service.delete(url, {params});
+export const PUT = <T = ServiceResponse>(url: string, data?: any, headers?: any): Promise<ApiResponse<T>> => service.put(url, data, headers);
+
+export { CreateQuery, CreateParams, DEFAULT_QUERY };
+

package/module/zip.ts

@@ -0,0 +1,59 @@
+import JSZip from "jszip";
+import FileSaver from "file-saver";
+import axios from 'axios';
+import hooks from "./hooks";
+
+
+const getFile = (url: string, token: string = localStorage.getItem('sessiontoken') || ''): Promise<ArrayBuffer> => {
+    return new Promise((resolve, reject) => {
+        axios({
+            method: 'get',
+            url,
+            responseType: 'arraybuffer',
+            withCredentials: false,
+            headers:{
+                'Content-Type': 'application/json;charset=UTF-8',
+                'Token': token
+            }
+        }).then(res => {
+            resolve(res.data);
+        }).catch(error => {
+            hooks.message.error(error);
+            reject(error.toString());
+        })
+    })
+};
+export const zip = async (file: any[], zipName: string = '频道数字化') => {
+    if( !file && typeof file !== 'object' ) return ;
+    try {
+        const zipSDK: JSZip = new JSZip();
+        const promises: any[] = [];
+        const cache: any = {};
+
+        await file.forEach(item => {
+            const promise = getFile(item.filePath).then(dat => {
+                // 获取文件名
+                let arr = item.fileName ?  item.fileName.split('/') : new Date().valueOf();
+                const file_name = arr[arr.length-1]
+                zipSDK.file(file_name, dat, { binary: true });
+                cache[file_name] = dat;
+            });
+            promises.push(promise)
+        });
+        Promise.all(promises).then(() => {
+            zipSDK.generateAsync({ type: "blob" }).then(content => {
+                FileSaver.saveAs(content, zipName + ".zip")
+            }).catch(err => {
+                hooks.message.error('网络出了点小问题，请稍后再试！');
+                console.error("网络出了点小问题，请稍后再试！");
+                throw new Error(err)
+            })
+        });
+
+    } catch (e: any) {
+        throw new Error(e);
+    }
+}
+
+
+export default { zip };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "t-lj-service",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "the.one",
+  "license": "ISC",
+  "dependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/file-saver": "^2.0.7",
+    "@types/jszip": "^3.4.1",
+    "axios": "^1.10.0",
+    "crypto-js": "^4.2.0",
+    "element-plus": "^2.10.4",
+    "file-saver": "^2.0.5",
+    "jszip": "^3.10.1",
+    "qiankun": "^2.10.16",
+    "vite": "^7.0.4",
+    "vite-plugin-qiankun": "^1.0.15",
+    "vue": "^3.5.17",
+    "vue-router": "^4.5.1"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/file-saver": "^2.0.7",
+    "@types/jszip": "^3.4.1",
+    "axios": "^1.10.0",
+    "crypto-js": "^4.2.0",
+    "element-plus": "^2.10.4",
+    "file-saver": "^2.0.5",
+    "jszip": "^3.10.1",
+    "qiankun": "^2.10.16",
+    "vite": "^7.0.4",
+    "vite-plugin-qiankun": "^1.0.15",
+    "vue": "^3.5.17",
+    "vue-router": "^4.5.1"
+  }
+}