中广核poc需求

craco.config.js

 const CracoLessPlugin = require('craco-less');
 const { name } = require('./package');
+const path = require('path');
 
 module.exports = {
   plugins: [
@@ -24,6 +25,9 @@ module.exports = {
     },
   ],
   webpack: {
+    alias: {
+      "@": path.resolve("src"),
+    },
     configure: {
       output: {
         library: `${name}-[name]`,

src/commons.ts

+const outUrl:string = '/data-govern';
+const appUrl:string = '/data-govern';
+const Api:string = '/api';
+const inapp:boolean = false;//内网true;外网false
+const baseUrl = inapp?appUrl:outUrl;
+
+const config =  {
+    baseUrl:baseUrl,
+    BaseURL: baseUrl,
+    inapp:inapp,
+    headerstring:inapp?'Basic Z3Vlc3Q6cHdk':'Basic ZGVtb3Rlc3Q6ZGVtb3Rlc3Q=',
+    page:{
+        index:`${baseUrl}/menu/index`,
+        indexpage:'/menu/index',
+        loginpage: inapp?'/api/auth/login':`${baseUrl}/view/login`,
+        workpage:'/view/task',
+        jdbc:`${baseUrl}/menu/datasource-manage`,
+        homeIndex: `${baseUrl}/view`,
+        roleTree: `${baseUrl}/view/roleTree`,
+        rolemanage: `${baseUrl}/view/rolemanage`,
+        metadetail:`${baseUrl}/metadetail`,
+        metadotheretail:`${baseUrl}/staticmeta/detail`,
+        standardmanage:`${baseUrl}/menu/datastandard`,
+        relationpage:`${baseUrl}/menu/sourcemap`,
+        catalogpage:`${baseUrl}/menu/domain`,
+        systempage:`${baseUrl}/menu/datasys`,
+        questionpage:`${baseUrl}/menu/myquestion`,
+        modelpage:`${baseUrl}/menu/data-model`,
+        noticepage:`${baseUrl}/menu/systemnotice`,
+        metasearch:`${baseUrl}/menu/metasearch`,
+        metamanage:`${baseUrl}/menu/metamanage`,
+        standard:`${baseUrl}/menu/datastandard`,
+        quality:`${baseUrl}/menu/data-quality`,
+        assetssource:`${baseUrl}/menu/asset-resource-browse`,//资源
+        asserts:`${baseUrl}/menu/asset-browse`,//资产,
+        lawpolice:`${baseUrl}/menu/specificationbrowse`,
+        systemdocument:`${baseUrl}/menu/specificationbrowse`,
+        guideline:`${baseUrl}/menu/specificationbrowse`,
+        tagmanager:`${baseUrl}/menu/tag-manage`,
+        assetmap:`${baseUrl}/menu/asset-map`,
+        filedetail:`${baseUrl}/noticeinfo`,
+        datamodel:`${baseUrl}/datamodeler`,
+        securitydetail:`${baseUrl}/security/detail`,
+        dataservicedetail:`${baseUrl}/dataservice/detail`,
+        indecatormanage:`${baseUrl}/menu/dataindicator`,
+    },
+    api:{
+        houseinfo:`${Api}`,
+        api:`${Api}`,
+        standard:`${Api}/standard`,
+        authservice:`${Api}/authservice`,
+        singin: `${Api}/auth/signin`,
+        signout: `${Api}/auth/signout`,
+        users: `${Api}/authservice/users/:userId/domains`,
+        sessionInfo: `${Api}/auth/sessionInfo`,
+        userupdate: `${Api}/authservice/users/`,
+        jdbcmanage: `${Api}/metadataharvester/rest/targetConfig/jdbc`,
+        sysjdbcmanage: `${Api}/metadataharvester/rest/targetConfig/system/jdbc`,
+        harveJdbcmanage: `${Api}/metadataharvester/rest/harvestingTarget/jdbc`,
+        taskResult: `${Api}/metadataharvester/rest/taskResult`,
+        task: `${Api}/metadataharvester/rest/task`,
+        role: `${Api}/datacatalog/roleCtrl`,
+        management: `${Api}/datacatalog/management`,
+        domains: `${Api}/authservice/domains`,
+        roleUser: `${Api}/authservice/roles`,
+        usersRoles: `${Api}/authservice/users`,
+        dataqualityapi: `${Api}/dataqualityapi`,
+        dataq:`${Api}/dataq`,
+        label: `${Api}/tagmanager`,
+        metaRepo: `${Api}/metadatarepo`,
+        metaHarvest:`${Api}/metadataharvester`,
+        information: `${Api}/informationmanagement`,
+        questionfeedback:`${Api}/questionfeedback`,
+        fileCatalog: `${Api}/informationmanagement/rest/fileCatalog`,
+        fileInformation: `${Api}/informationmanagement/rest/fileInformation`,
+        dataInformation: `${Api}/informationmanagement/rest/dataInformation`,
+        issuetrack: `${Api}/questionfeedback/rest/issuetrack`,
+        questionInfo: `${Api}/questionfeedback/rest/questionInfo`,
+        report: `${Api}/portal/report`,
+        nodeRelation: `${Api}/metadatarepo/rest/nodeRelation`,
+        interfaceLog:`${Api}/auditlogger/interfaceLogCtrl`,
+        finder: `${Api}/finder`,
+        asset:`${Api}/dataassetmanager`,
+        metadataRelation: `${Api}/metadatarelation`,
+        tagger: `${Api}/tagger`,
+        datamodeler: `${Api}/datamodeler`,
+        dataservice:`${Api}/dataservicemanager`,
+        baseservice:`${Api}/baseservice`,
+        dataquality:`${Api}/dataquality`,
+        datamodelercomment:`${Api}/subscribe`,
+        sdataquality: `${Api}/dataquality`,
+        workorder:`${Api}/workorder`,
+        pdataservice:`${Api}/pdataservice`,
+        dbmanager: `${Api}/dbmanager`,
+        datasource:`${Api}/metadataharvester/datasource`,
+        classifier:`${Api}/classifier`,
+        aiagent:`${Api}/aiagenttest`,
+        aiagent3:`${Api}/aiagentdataq3`,
+        indicator:`${Api}/index`,
+    }
+}
+
+
+export default config
\ No newline at end of file

src/hooks/common/Local.ts

+import { useState,useEffect } from 'react';
+import {useMemoizedFn,useUpdateEffect} from "ahooks"
+import { isFunction, isUndef } from './utils';
+import isBrowser from "./utils/isBrowser"
+
+export type SetState<S> = S | ((prevState?: S) => S);
+
+export interface Options<T> {
+  defaultValue?: T | (() => T);
+  serializer?: (value: T) => string;
+  deserializer?: (value: string) => T;
+  onError?: (error: unknown) => void;
+}
+
+export function createUseStorageState(getStorage: () => Storage | undefined) {
+  function useStorageState<T>(key: string, options: Options<T> = {}) {
+    let storage: Storage | undefined;
+    const {
+      onError = (e) => {
+        console.error(e);
+      },
+    } = options;
+
+    // https://github.com/alibaba/hooks/issues/800
+    try {
+      storage = getStorage();
+    } catch (err) {
+      onError(err);
+    }
+
+    const listen=(e:any)=>{
+        if (e.key === key) {
+            try {
+                setState(getStoredValue());
+            } catch (error) {
+                console.log(error)
+            }
+        }
+    }
+
+    useEffect(()=>{
+        window?.addEventListener("storage", listen);
+        return ()=>{
+            window?.removeEventListener("storage",listen)
+        }
+    },[])
+    
+    const serializer = (value: T) => {
+      if (options.serializer) {
+        return options.serializer(value);
+      }
+      return JSON.stringify(value);
+    };
+
+    const deserializer = (value: string): T => {
+      if (options.deserializer) {
+        return options.deserializer(value);
+      }
+      return JSON.parse(value);
+    };
+
+    function getStoredValue() {
+      try {
+        const raw = storage?.getItem(key);
+        if (raw) {
+          return deserializer(raw);
+        }
+      } catch (e) {
+        onError(e);
+      }
+      if (isFunction(options.defaultValue)) {
+        return options.defaultValue();
+      }
+      return options.defaultValue;
+    }
+
+    const [state, setState] = useState(getStoredValue);
+
+    useUpdateEffect(() => {
+      setState(getStoredValue());
+    }, [key]);
+
+    const updateState = (value?: SetState<T>) => {
+      const currentState = isFunction(value) ? value(state) : value;
+      setState(currentState);
+
+      if (isUndef(currentState)) {
+        storage?.removeItem(key);
+      } else {
+        try {
+          storage?.setItem(key, serializer(currentState));
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    };
+
+    return [state, useMemoizedFn(updateState)] as const;
+  }
+  return useStorageState;
+}
+
+
+export const useMyLocalStorageState = createUseStorageState(() => (isBrowser ? localStorage : undefined));
\ No newline at end of file

src/hooks/common/Modal.ts

+import {useCallback} from "react"
+import {useSetState} from "ahooks"
+
+interface props1{
+    visible:boolean,
+    currentItem:any,
+    type:string,
+    [props:string]:any
+}
+
+export const useGetModalInfoAndAction=()=>{
+    const [state,setState] = useSetState<props1>({
+        visible:false,
+        currentItem:{},
+        type:''
+    })
+
+    const openModal=useCallback((item:any,odata?:any)=>{
+        setState({visible:true,currentItem:item,...odata})
+    },[])
+
+    const cancelModal:any=useCallback((odata?:any)=>{
+        setState({visible:false,currentItem:{},...odata})
+    },[])
+
+    const payload:props1={
+        ...state,
+        openModal,cancelModal
+    }
+
+    return payload
+}
\ No newline at end of file

src/hooks/common/Url.ts

+import {useState,useEffect} from "react"
+interface p3{
+    url:string
+}
+
+export const useGetUrlParams=(props:p3)=>{
+    const {url} = props
+    const [state,setState] = useState<any>({})
+
+    useEffect(()=>{
+        if(url){
+            const theRequest:any = {};
+            if (url.indexOf("?") !== -1) {
+                const str = url.slice(1);
+                const strs = str.split("&");
+                for(let i = 0; i < strs.length; i ++) {
+                    const types = strs[i].split("=");
+                    const key:string = types.shift()||'';
+                    const value = types.join('=')
+                    theRequest[key] = decodeURI(value.trim());
+                }
+            }
+            setState(theRequest)
+        }
+    },[url])
+
+    return state
+}
\ No newline at end of file

src/hooks/common/index.ts

+export * from "./Modal"
+export * from "./Local"
+export * from "./Url"

src/hooks/common/utils/index.ts

+export const isObject = (value: unknown): value is Record<any, any> =>
+  value !== null && typeof value === 'object';
+export const isFunction = (value: unknown): value is (...args: any) => any =>
+  typeof value === 'function';
+
+export const isString = (value: unknown): value is string => typeof value === 'string';
+export const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+export const isNumber = (value: unknown): value is number => typeof value === 'number';
+export const isUndef = (value: unknown): value is undefined => typeof value === 'undefined';

src/hooks/common/utils/isBrowser.ts

+const isBrowser = !!(
+  typeof window !== 'undefined' &&
+  window.document &&
+  window.document.createElement
+);
+
+export default isBrowser;

src/hooks/standard/Tag.ts

+import { standardsService } from "@/services";
+import { httpUtil } from "@/utils";
+import { useSetState,useDebounceEffect } from "ahooks"
+import {useEffect} from "react"
+
+interface p1{
+    metadataIds:Array<string>;
+    reload?:number|string;
+    checkStandard?:boolean;
+}
+
+export const useGetStandardMatchByIds=(props:p1)=>{
+
+    const {metadataIds,reload=0,checkStandard} = props
+
+    const [state,setState] = useSetState<{mapload:boolean,standardmap:any}>({
+        standardmap:{},
+        mapload:false
+    })
+
+    useDebounceEffect(()=>{
+        if(metadataIds.length&&checkStandard){
+            getInfo()
+        }else{
+
+        }
+    },[metadataIds,reload,checkStandard],{wait:300})
+
+    const getInfo=async()=>{
+        setState({mapload:true})
+        const payload = {
+            data:{hasConfirmed:true,
+                filter:{metadataId:metadataIds},
+            },
+            param:{
+                orOperator:true,
+                exactMatch:false,
+                page:1,
+                size:metadataIds.length,
+            }
+        }
+        const result:any = await standardsService.findMatchList(payload)
+        if(httpUtil.checkSuccess(result,1)){
+            if(httpUtil.checkSuccess(result,1)){
+                let map:any = {};
+                (result.data.content||[]).forEach((item:any)=>{
+                    map[item.metadataId] = item
+                })
+                setState({mapload:false,standardmap:map})
+            }else{
+                setState({mapload:false,standardmap:{}})
+            }
+        }
+    }
+
+    return state
+}
\ No newline at end of file

src/hooks/standard/index.ts

+
+export * from "./Tag"
\ No newline at end of file

src/model/datamodel.js

@@ -308,4 +308,15 @@ export function* requirementBind(payload) {
 
 export function* requirementUnbind(payload) {
   return yield call(datamodelerService.requirementUnbind, payload);
+}
+
+export function* uploadCommentFile(payload) {
+  return yield call(datamodelerService.uploadCommentFile, payload)
+}
+
+export function* addComment(payload) {
+  return yield call(datamodelerService.addComment, payload)
+}
+export function* getComments(payload) {
+  return yield call(datamodelerService.getComments, payload)
 }
\ No newline at end of file

src/service/datamodeler.js

@@ -263,4 +263,18 @@ export function requirementBind(payload) {
 
 export function requirementUnbind(payload) {
   return PostJSON("/datarequirement/dataReqTechJobAssoc/unbinding", payload);
-}
\ No newline at end of file
+}
+
+export function uploadCommentFile(payload) {
+  return PostFile("/datamodelercomment/file/upload", payload)
+}
+
+
+export function addComment(payload) {
+  return PostJSON("/datamodelercomment/comment/add", payload)
+}
+
+export function getComments(payload) {
+  return GetJSON("/datamodelercomment/comment/list", payload)
+}
+

src/services/index.ts

+import standardsService from "./standardsService"
+
+export {
+    standardsService
+}
\ No newline at end of file

src/services/standardsService.js

+import qs from "qs"
+import config from "../commons"
+import request from "../utils/request"
+
+const {api} = config
+const headers = { 'Content-Type': 'application/x-www-form-urlencoded' }
+
+class standardsService{
+
+    async getAllStandardTree(payload={},autotip=false){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/tree/list`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getAllStandardTreeWidthAdmit(payload={},autotip=false){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/tree/privilege`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardTypes(payload={},autotip=false){
+        let result = await request({ url: `${api.standard}/metaModel/getSubModel`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getTypeInfo(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/attrs`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardsByIds(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/getByIds`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getDraftStandardById(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/draft/${payload}`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardInPackage(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/standard/list`, method: "post", data: payload.body,params:payload.params },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getDraftStandardInPackage(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/draft/list`, method: "post", data: payload.body,params:payload.params },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async addCatalog(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/addStandardCatalog`, method: "post", data: qs.stringify(payload) },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async updateCatalog(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/updateById`, method: "post", data: payload.data,params:payload.params },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getImportLog(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/import/log`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getModelImportLog(payload,autotip){
+        let result = await request({ url: `${api.standard}/metaModel/importLog`, method: "get", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async importStandard(param,autotip){
+        let config = {
+            headers:{'Content-Type':'multipart/form-data'}
+        }
+        let formdata=new FormData();// 创建form对象
+        const {file,namePath,clazz,isDraft,allowedModels} = param
+        formdata.append('file',file);
+        formdata.append("namePath",namePath)
+        formdata.append("clazz",clazz)
+        formdata.append("isTemp",false)
+        formdata.append("isDraft",isDraft)
+        formdata.append('allowedModels',allowedModels)
+        let result = await request({ url: `${api.standard}/rest/standard/import/addWithConfirm`, method: "post", data: formdata},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async confirmImport(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/import/confirm`, method: "post", data: qs.stringify(param)},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async importModel(param,autotip){
+        const {file,params} = param
+        let formdata=new FormData();// 创建form对象
+        formdata.append('file',file);
+        console.log(params)
+        let result = await request({ url: `${api.standard}/metaModel/import`, method: "post", data: formdata,params},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async updateStardard(param,autotip){
+        console.log(param.data)
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/update/${param.id}`, method: "post",params:param.params, data:param.data},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async addStardard(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/add/${param.id}/${param.type}`, method: "post",params:param.params, data:param.data},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            console.log('666',error)
+            return error
+        })
+        return result
+    }
+
+    async deleteStandards(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/delete`, data:qs.stringify(param), method: "post",},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async deleteMetaByIdsNew(param,autotip=false){
+        let result = await request({ url: `${api.api}/standardmanagement/rest/standard/maintain/deleteStandardCatalog?id=${param}`, method: "post",  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async importMatch(param,autotip){
+        let config = {
+            headers:{'Content-Type':'multipart/form-data'}
+        }
+        let formdata=new FormData();// 创建form对象
+        console.log(config)
+        formdata.append('file',param.file);
+        let result = await request({ url: `${api.api}/standardmanagement/sdrcb/rest/standard/importSDBankStandardMapper`, method: "post", data: formdata},autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result
+    }
+
+    async matchStatic(param,autotip){
+        let result = await request({ url: `${api.api}/standard/rest/standard/match/statistic`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getMatchRules(param,autotip){
+        let result = await request({ url: `${api.api}/standard/rest/standard/match/rules`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getMatchTask(param,autotip){
+        let result = await request({ url: `${api.api}/rest/standard/match/tasks`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async saveRule(payload,autotip){
+        const {data,param} = payload
+        let result = await request({ url: `${api.standard}/rest/standard/match/rule`, method: "post", data: data,params:param },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async saveTask(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/task`, method: "post", data: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async startTask(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/scan/${payload}`, method: "post", data: null },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async restartTask(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/executions/restart`, method: "post", data: qs.stringify(payload) },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async cancelTask(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/executions/cancel`, method: "post", data: qs.stringify(payload) },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+
+    async getMatchList(payload,autotip){
+        const {data,param} = payload
+        let result = await request({ url: `${api.standard}/rest/standard/match/list`, method: "post", data: data,params:param },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async findMatchList(payload,autotip){
+        const {data,param} = payload
+        let result = await request({ url: `${api.standard}/rest/standard/match/find`, method: "post", data: data,params:param },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteMatchs(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/delete`, method: "post", data: qs.stringify(payload) },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteAutoMatchs(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/delete/batch`, method: "delete", params: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteRules(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/rules/delete`, method: "delete", params: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteJob(payload,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/tasks/delete`, method: "delete", params: payload },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getMatchStatus(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/state`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async resetMatchStatus(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/state/reset`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async marchSure(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/confirmResult`, method: "post",data:qs.stringify(param)  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async catalogMove(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/seq`, method: "post",data:qs.stringify(param)  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async downloadFile(payload,autotip=false){
+        await request({ url: `${api.standard}/rest/standard/export/ids`, method: "postdownload", data:qs.stringify(payload),responseType:'blob' },autotip).then((data)=>{
+            let types = data.data.type
+            var blob = new Blob([data.data], {type: types});
+            let fileName = ''
+            let contentDisposition = data.headers['content-disposition'];
+            if (contentDisposition) {
+                fileName = window.decodeURI(data.headers['content-disposition'].split('=')[1]);
+            }
+            if (typeof window.navigator.msSaveBlob !== 'undefined') {
+                window.navigator.msSaveBlob(blob, fileName);
+            }
+            else {
+                var csvURL = window.URL.createObjectURL(blob);
+                var tempLink = document.createElement('a');
+                tempLink.href = csvURL;
+                tempLink.setAttribute('download', fileName);
+                tempLink.setAttribute('target', '_blank');
+                document.body.appendChild(tempLink);
+                tempLink.click();
+                document.body.removeChild(tempLink);
+            }
+        }).catch(error=>{
+            console.log(error)
+        })
+    }
+
+    async downloadFileByCatalog(payload,autotip=false){
+        const {data,params} = payload
+        request({ url: `${api.standard}/rest/standard/export/all`, method: "postdownload", data:data,params,responseType:'blob' },autotip).then((data)=>{
+            let types = data.data.type
+            var blob = new Blob([data.data], {type: types});
+            let fileName = ''
+            let contentDisposition = data.headers['content-disposition'];
+            if (contentDisposition) {
+                fileName = window.decodeURI(data.headers['content-disposition'].split('=')[1]);
+            }
+            if (typeof window.navigator.msSaveBlob !== 'undefined') {
+                window.navigator.msSaveBlob(blob, fileName);
+            }
+            else {
+                var csvURL = window.URL.createObjectURL(blob);
+                var tempLink = document.createElement('a');
+                tempLink.href = csvURL;
+                tempLink.setAttribute('download', fileName);
+                tempLink.setAttribute('target', '_blank');
+                document.body.appendChild(tempLink);
+                tempLink.click();
+                document.body.removeChild(tempLink);
+            }
+        }).catch(error=>{
+            console.log(error)
+        })
+    }
+
+    async downloadFileByCatalogParams(payload,autotip=false){
+        const {data,params} = payload
+        await request({ url: `${api.standard}/rest/standard/draft/exportAll`, method: "postdownload", data:data,params,responseType:'blob' },autotip).then((data)=>{
+            let types = data.data.type
+            var blob = new Blob([data.data], {type: types});
+            let fileName = ''
+            let contentDisposition = data.headers['content-disposition'];
+            if (contentDisposition) {
+                fileName = window.decodeURI(data.headers['content-disposition'].split('=')[1]);
+            }
+            if (typeof window.navigator.msSaveBlob !== 'undefined') {
+                window.navigator.msSaveBlob(blob, fileName);
+            }
+            else {
+                var csvURL = window.URL.createObjectURL(blob);
+                var tempLink = document.createElement('a');
+                tempLink.href = csvURL;
+                tempLink.setAttribute('download', fileName);
+                tempLink.setAttribute('target', '_blank');
+                document.body.appendChild(tempLink);
+                tempLink.click();
+                document.body.removeChild(tempLink);
+            }
+        }).catch(error=>{
+            console.log(error)
+        })
+    }
+
+    async deleteModel(param,autotip){
+        let result = await request({ url: `${api.standard}/metaModel/delete/${param}`, method: "delete"  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardOffset(param,autotip){
+        const {id,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/location/${id}`, method: "post",data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardAllOffset(param,autotip){
+        const {id,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/draft/location/general/${id}`, method: "post",data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardChildren(param,autotip){
+        const {params,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/codeItem/list`, method: "post",params,data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async saveCodeItem(param,autotip){
+        const {params,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/codeItem/save`, method: "post",params,data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteCodeItem(param,autotip){
+        const {params,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/codeItem/delete`, method: "post",params,data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getCreateItem(param,autotip){
+        const {params,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/createForColumn`, method: "post",params,data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async startFlow(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/draft/startStandardFlow`, method: "post",data:qs.stringify(param)  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async deleteDraftStandard(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/draft/delete`, method: "post",data:qs.stringify(param)  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async editDraftStandard(param,autotip){
+        const {body,params} = param
+        let result = await request({ url: `${api.standard}/rest/standard/draft/update`, method: "post",data:body,params:params  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async editDraftStandardChildren(param,autotip){
+        const {body,params} = param
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/codeItem/validate`, method: "post",data:body,params:params  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getDraftStandardOffset(param,autotip){
+        const {id,body}=param
+        let result = await request({ url: `${api.standard}/rest/standard/draft/location/${id}`, method: "post",data:body  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardTotal(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/statistic/overview`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getNewStandardTotal(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/statistic/newOverview`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getNewStandardLeftCount(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/statistic/overviewByVisit`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardCodes(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/getValueRange`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardCodesTypes(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/getValueRange/class`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    // async getStandardCodesTypesByPath(param,autotip){
+    //     let result = await request({ url: `${api.standard}/rest/standard/maintain/getValueRange/class`, method: "get",data:param  },autotip).then(data=>{
+    //         return data;
+    //     }).catch(error=>{
+    //         return error
+    //     })
+    //     return result;
+    // }
+
+    async getCatalogId(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/code/getCodeStandardCatalogId`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getIdByCode(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/code/getIdByCode`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getMatchStandards(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/maintain/findRelatedStdByCode`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async getStandardsAuth(param,autotip){
+        let result = await request({ url: `${api.standard}/privilege/feature`, method: "post",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async importMatchLog(param,autotip){
+        let result = await request({ url: `${api.standard}/rest/standard/match/importLog`, method: "get",data:param  },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+    async importMatchData(param,autotip){
+        const {file}=param
+        const data = new FormData();
+        data.append('file',file);
+        let result = await request({ url: `${api.standard}/rest/standard/match/import`, method: "post",data:data },autotip).then(data=>{
+            return data;
+        }).catch(error=>{
+            return error
+        })
+        return result;
+    }
+
+}
+
+export default new standardsService()
\ No newline at end of file

src/utils/domainChangeUtil.ts

+
+export const domainChagneUtil={
+    getSystemInfo:(resultdata:any,domains:any)=>{
+        let alldomainmap:any = {}
+        domains.forEach((i:any)=>{
+            alldomainmap[i.domainId] = i
+        })
+        let systemmap:any ={}
+        let domainmap:any={}
+        const data = (resultdata||[]).map((domain:any)=>{
+            let tempcatalogs = (domain.catalogs||[]).map((tcatalog:any)=>{
+                let tsystems = (tcatalog.scopes||[]).map((_system:any,index:any)=>{
+                    const system = {..._system,label:_system.scopeName,title:_system.scopeName,key:`system-${_system.scopeId}`,
+                        value:_system.scopeId,catalog:tcatalog.catalogId,domainId:domain.domainId,catalogInfo:tcatalog,
+                        prevnode:domain.catalogs[index-1]||null,nextnode:domain.catalogs[index+1]||null,domain:domain
+                    }
+                    systemmap[_system.scopeId] = system;
+                    return system;
+                })
+                let tempcatalog = {catalogId:tcatalog.catalogId,catalogInfo:tcatalog,catalogName:tcatalog.catalogName,label:tcatalog.catalogName,title:tcatalog.catalogName,key:`catalog-${tcatalog.catalogId}-${domain.domainId}`,value:tcatalog.catalogId,domain:domain.domainId,disabled:true,children:tsystems}
+                return tempcatalog
+            })
+            let domaininfo = alldomainmap[domain.domainId]
+            let tempdomain= {...domaininfo,...domain,label:domain.domainName,title:domain.domainName,key:`domain-${domain.domainId}`,value:domain.domainId,children:tempcatalogs}
+            domainmap[domain.domainId] = tempdomain
+            return tempdomain
+        });
+        return {domainlist:data,domainmap,systemmap}
+    },
+    getSystemInfoFromCatalog:(resultdata:any,domainId:any)=>{
+        let tempcatalogs = (resultdata||[]).map((tcatalog:any)=>{
+            let tsystems = (tcatalog.scopes||[]).map((_system:any,index:any)=>{
+                const system = {..._system,label:_system.scopeName,title:_system.scopeName,key:`system-${_system.scopeId}`,
+                    value:_system.scopeId,catalog:tcatalog.catalogId,domainId:domainId,
+                    prevnode:resultdata[index-1]||null,nextnode:resultdata[index+1]||null
+                }
+                return system;
+            })
+            let tempcatalog = {catalogId:tcatalog.catalogId,catalogName:tcatalog.catalogName,label:tcatalog.catalogName,title:tcatalog.catalogName,key:`catalog-${tcatalog.catalogId}-${domainId}`,value:tcatalog.catalogId,domain:domainId,disabled:true,children:tsystems}
+            return tempcatalog
+        })
+        return tempcatalogs
+    },
+    getSystemInfoFromCatalogForTreeSelect:(resultdata:any,domainId:any)=>{
+        let tempcatalogs = (resultdata||[]).map((tcatalog:any)=>{
+            let tsystems = (tcatalog.scopes||[]).map((_system:any,index:any)=>{
+                const system = {..._system,label:_system.scopeName,title:_system.scopeName,key:`system-${_system.scopeId}`,
+                    value:`system-${_system.scopeId}`,catalog:tcatalog.catalogId,domainId:domainId,
+                    prevnode:resultdata[index-1]||null,nextnode:resultdata[index+1]||null
+                }
+                return system;
+            })
+            let tempcatalog = {catalogId:tcatalog.catalogId,catalogName:tcatalog.catalogName,label:tcatalog.catalogName,title:tcatalog.catalogName,key:`catalog-${tcatalog.catalogId}-${domainId}`,value:`catalog-${tcatalog.catalogId}-${domainId}`,domain:domainId,disabled:true,children:tsystems}
+            return tempcatalog
+        })
+        return tempcatalogs
+    }
+}
\ No newline at end of file

src/utils/heightLignt.tsx

+export const heightLight={
+    highlightSearchContentByTerms:(content:string, terms:string[])=> {
+        if (content===null || content==='') return '';
+        if ((terms||[]).length===0) return content;
+        let processContent = content||'';
+        if(typeof(content)!=='string'){
+            processContent = `${content}`||''
+        }
+         
+        (terms||[]).forEach((term:string) => {
+            processContent = processContent.replace(term, `<em>${term}</em>`);
+        })
+      
+        return highlightSearchContent(processContent);
+    },
+    heightLightString:(content:string)=>{
+        return highlightSearchContent(content)
+    }
+}
+
+const highlightSearchContent=(content:string)=> {
+    if (content===null || content==='') return '';
+  
+    const startFlag = '<em>';
+    const endFlag = '</em>';
+  
+    const start = content.indexOf(startFlag);
+    const end = content.indexOf(endFlag);
+    const beforeStr = content.substr(0, start);
+  
+    const middleStr = content.substr(start + startFlag.length, end - start - startFlag.length);
+    const afterStr = content.substr(end + endFlag.length);
+  
+    return (
+        <>
+            {
+                start > -1 ? <span>
+                    {beforeStr}
+                    <span style={{ color: '#f50' }}>{middleStr}</span>
+                    {highlightSearchContent(afterStr)}
+                </span> : <span>{content}</span>
+            }
+        </>
+    )
+}
\ No newline at end of file

src/utils/httpUtil.tsx

+import config from "@/commons"
+import {notification,message} from "antd"
+
+const {page} = config
+
+export const httpUtil={
+    checkSuccess:(data:any,type:number)=>{
+        if(type===1){
+            if(data.status===200){
+                return true
+            }else{
+                return false
+            }
+        }else{
+            return false;
+        }
+    },
+    logout:()=>{
+        const url = window.location.href;
+        if(!url.includes("/view/login")){
+            window.location.href=`${page.loginpage}?redirectURL=${encodeURIComponent(window.location.href)}`;
+        }
+    },
+    showError:(data:any,type:number,title?:string)=>{
+        if(data.status&&((data.data||{}).ApiError||(data||{}).ApiError||(data||{}).message||(data.data||{}).message)){
+            let messages = '未知异常';
+            try {
+                messages=data.data.ApiError.cnMessage
+            } catch (error) {
+                try {
+                    messages=data.ApiError.cnMessage
+                } catch (error) {
+                    try {
+                        messages=data.data.message
+                    } catch (error) {
+                        messages='获取异常信息异常'
+                    }
+                }
+            }
+            if(type===1){
+                notification['error']({
+                    message:'系统异常',
+                    description:messages,
+                    duration:5
+                })
+            }else if(type===2){
+                notification['info']({
+                    message:'提示',
+                    description:"系统暂无环境，请先在环境管理中新增环境",
+                    duration:null
+                })
+            }else if(type===3){
+                notification['error']({
+                    message:title,
+                    description:<pre>{messages}</pre>,
+                    duration:5
+                })
+            }
+            else{
+                message.error(messages)
+            }
+        }
+    },
+    getUrlByLevel:(url:string,level:number)=>{
+        let paths = (url||'').split('/')
+        let temp = []
+        for(let i=0;i<level;i++){
+            temp.push(paths[i]||'')
+        }
+        return temp.join('/')
+    },
+    getQueryVariable:(variable:string,url:string)=>{
+        const query = (url||'?').substring(1);
+        const vars = query.split("&");
+        for (let i=0;i<vars.length;i++) {
+            let pair = vars[i].split("=");
+            let params = [...pair]
+            params.shift()
+            if(pair[0] == variable){return params.join('=')}
+        }
+        return(false);
+    }
+}
\ No newline at end of file

src/utils/index.ts

+import {httpUtil} from "./httpUtil"
+import request from "./request"
+import {heightLight} from "./heightLignt"
+import {pageUtil} from "./pageUtil"
+import { domainChagneUtil } from "./domainChangeUtil"
+import { standardUtil } from "./standardUtil"
+
+export {
+    httpUtil,
+    request,
+    heightLight,
+    pageUtil,
+    domainChagneUtil,
+    standardUtil
+}
+
+export const timestampToTime = (timestamp:any) => {
+    timestamp = timestamp ? timestamp : null;
+    let date = new Date(timestamp);//时间戳为10位需*1000，时间戳为13位的话不需乘1000
+    let Y = date.getFullYear() + '-';
+    let M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';
+    let D = (date.getDate() < 10 ? '0' + date.getDate() : date.getDate()) + ' ';
+    let h = (date.getHours() < 10 ? '0' + date.getHours() : date.getHours()) + ':';
+    let m = (date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()) + ':';
+    let s = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds();
+    return Y + M + D + h + m + s;
+}
+
+
+export function compare(property: any){
+    return function(a: any, b: any){
+        var value1 = a[property];
+        var value2 = b[property];
+        return value2 - value1;
+    }
+}
+
+
+export function timeCompare(property: any){
+    return function(a: any, b: any){
+        var value1 = new Date(a[property]).getTime();
+        var value2 = new Date(b[property]).getTime();
+        return value2 - value1;
+    }
+}
\ No newline at end of file

src/utils/pageUtil.tsx

+import React from "react"
+import {Tooltip,Typography,notification} from "antd"
+import { heightLight } from "./heightLignt"
+
+const {Text} = Typography
+
+export const pageUtil={
+    getBodyHeight:()=>{
+        if(window.bodyheight){
+            return window.bodyheight
+        }else{
+            return document.body.clientHeight
+        }
+    },
+    showToolTip:(text:any,action?:Function,body?:any)=>{
+        try {
+            let name = text
+            let title = text
+            try {
+                text = name.replace(/(\r\n|\n|\r)/gm, "↵")
+                if(title.includes("\n")){
+                    title=<pre style={{fontFamily:"宋体"}}>{title}</pre>
+                }
+            } catch (error) {
+                
+            }
+            if(action){
+                const bodys = body?body:(text||'')
+                return(
+                    <Tooltip title={title||''}>
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <a onClick={()=>{action()}}>
+                                {bodys}
+                            </a>
+                        </div>
+                    </Tooltip>
+                )
+            }else{
+                const bodys = body?body:<span>{text||''}</span>
+                return(
+                    <Tooltip title={title||''}>
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <span>{bodys}</span>
+                        </div>
+                    </Tooltip>
+                )
+            }
+        } catch (error) {
+            console.log(error)
+            return text
+        }
+    },
+    showToolTipWithImg:(text:any)=>{
+        try {
+            return(
+                <Tooltip title={<div style={{width:500,maxHeight:300,overflow:'auto'}} dangerouslySetInnerHTML={{__html: text}} ></div>}>
+                    <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                        {text}
+                    </div>
+                </Tooltip>
+            )
+        } catch (error) {
+            console.log(error)
+            return text
+        }
+    },
+    showToolTipWithHighLight:(text:any,action?:Function,body?:any)=>{
+        let success = true
+        try {
+            let name = text
+            try {
+                text = name.replace(/(\r\n|\n|\r)/gm, "↵")
+                text = heightLight.heightLightString(text)
+            } catch (error) {
+                success =false
+            }
+            if(action){
+                const bodys = body?body:(text||'')
+                return(
+                    <Tooltip title={text||''}>
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <a onClick={()=>{action()}}>
+                                {bodys}
+                            </a>
+                        </div>
+                    </Tooltip>
+                )
+            }else{
+                const bodys = body?body:<span>{text||''}</span>
+                return(
+                    <Tooltip title={text||''}>
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <span>{bodys}</span>
+                        </div>
+                    </Tooltip>
+                )
+            }
+        } catch (error) {
+            console.log(error)
+            return text
+        }
+    },
+    showChildrenToolTip:(text:any,action?:Function,body?:any)=>{
+        try {
+            let name = text
+            try {
+                text = name.replace(/(\r\n|\n|\r)/gm, "↵")
+            } catch (error) {
+                
+            }
+            if(action){
+                const bodys = body?body:(text||'')
+                return(
+                    <Tooltip title={bodys} color="#fff" overlayStyle={{maxWidth:600}}>
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <a onClick={()=>{action()}}>
+                                {text}
+                            </a>
+                        </div>
+                    </Tooltip>
+                )
+            }else{
+                const bodys = body?body:<span>{text||''}</span>
+                return(
+                    <Tooltip title={bodys} color="#fff">
+                        <div style={{width:'100%',overflow: 'hidden',textOverflow:'ellipsis',whiteSpace:'nowrap'}}>
+                            <span>{text}</span>
+                        </div>
+                    </Tooltip>
+                )
+            }
+        } catch (error) {
+            console.log(error)
+            return text
+        }
+    },
+    checkMenuAdmit:(menuinfo:any,menu:any,menuadmit:any)=>{
+        console.log('begin')
+        let tempmenu = menuinfo.split('/')
+        let queryurl = null
+        if(tempmenu.length>2){
+            queryurl = `/view/${tempmenu[tempmenu.length-1]}`
+        }else{
+            notification['info']({
+                message:'提示',
+                description:`路由${menuinfo}格式异常`,
+                duration:5
+            })
+           return false
+        }
+        let menumessage = (menu.mapurl[queryurl])
+        if(menumessage&&menumessage.href!=='/view/index'){
+            let type = menumessage.id.split("-")
+            let key = ""
+            if (type[0] !== "item") {
+                key = "sub-" + type[0]
+            } 
+            if(key){
+                try {
+                    let parent = menu.parentIdMap[key]||''
+                    let totalbit = menuadmit[parent.name];
+                    if(!parent.hidden){
+                        //(menumessage.bit&totalbit)===menumessage.bit
+                        if(totalbit.includes(menumessage.name)){
+                            return true
+                        }else{
+                            notification['info']({
+                                message:'提示',
+                                description:`暂无访问菜单【${menumessage.name}】的权限`,
+                                duration:5
+                            })
+                            return false
+                        }
+                    }else{
+                        notification['info']({
+                            message:'提示',
+                            description:`暂无访问菜单【${menumessage.name}】的权限`,
+                            duration:5
+                        })
+                        return false
+                    }
+                } catch (error) {
+                    notification['info']({
+                        message:'提示',
+                        description:`暂无访问路由${menuinfo}的权限`,
+                        duration:5
+                    })
+                   return false
+                }
+            }else{
+                notification['info']({
+                    message:'提示',
+                    description:`暂无访问路由${menuinfo}的权限`,
+                    duration:5
+                })
+               return false
+            }
+        }else{
+            return false
+        }
+    },
+    changeLevel:(text:any)=>{
+        if(text===1||text==='1'){
+            return '一级'
+        }else if(text===2||text==='2'){
+            return '二级'
+        }else if(text===3||text==='3'){
+            return '三级'
+        }else if(text===4||text==='4'){
+            return '四级'
+        }else{
+            return text
+        }
+    }
+}
\ No newline at end of file

src/utils/request.ts

+import axios from "axios"
+import {compile} from "path-to-regexp"
+import { message } from "antd"
+import {httpUtil} from "./index"
+import config from "@/commons"
+const {page:{loginpage},headerstring} =config
+
+const requestList:Array<any> = []
+
+axios.interceptors.request.use(
+    (config:any) => {
+        config.headers['WWW-Authenticate'] = null;
+        const requestMark = `${config.method} ${config.url}`; // 请求标识 为了在响应的时候删除请求队列中的数据
+        let flagindex:any = null
+        const flag = requestList.find((item:any,key:any)=>{
+            if(item.requestMark === requestMark)
+                flagindex = key
+            return item.requestMark === requestMark
+        });
+        if (flag&&flag.requestMark) {
+            requestList.splice(flagindex,1); // 在等待重新发起的请求列表中移除
+            if(flag.hashrequest){
+                flag.cancel()
+            }
+        }
+        const cancelToken = axios.CancelToken;
+        const source:any = cancelToken.source();
+        config.cancelToken = source.token; 
+        config.cancel = source.cancel;
+        config.requestMark = requestMark; //添加唯一标识符
+        requestList.push(config);
+        return config;
+    },
+    err => {
+        return Promise.reject(err);
+});
+
+
+axios.interceptors.response.use(
+    (response) => {
+        const config = response.config;
+        const requestMark = `${config.method} ${config.url}`; // 请求标识 为了在响应的时候删除请求队列中的数据
+        let flagindex:any = null
+        const flag = requestList.find((item:any,key:any)=>{
+            if(item.requestMark === requestMark)
+                flagindex = key
+            return item.requestMark === requestMark
+        });
+        if (flag&&flag.requestMark) {
+            requestList.splice(flagindex,1); // 在等待重新发起的请求列表中移除
+        }
+        return response;
+    },
+    error => {
+        if (error.response) {
+            switch (error.response?.status) {
+            case 401:
+                {
+                    const config = {
+                        content:"身份信息已过期，正在重新验证……",
+                        key:'logout'
+                    }
+                    message.warning(config)  
+                    httpUtil.logout()
+                    //window.location.href=`${loginpage}?redirectURL=${encodeURIComponent(window.location.href)}`
+                }
+            }
+        }
+        // else if((error.ApiError?.status||'')==='INTERNAL_SERVER_ERROR'){
+
+        // }
+        return Promise.reject(error)   // 返回接口返回的错误信息
+    }
+);
+
+
+
+const fetch = (options:any) => {
+    let { method = "get", data,urldata , params , url, config={},hashrequest=false}:any = options
+    const pathname = window.location.pathname
+    if(pathname.includes('staticmeta')){
+        let headers:any = null
+        let tempconfig:any = config
+        if(pathname.includes('staticmeta')){
+            const tempheader = config.headers?config.headers:{}
+            headers = {
+            ...tempheader,
+            'Authorization': headerstring
+            };
+            tempconfig.headers = headers
+            tempconfig.hashrequest = hashrequest
+        }
+        try {
+            url = compile(url)(urldata)
+    
+        } catch (e) {
+        }
+        switch (method.toLowerCase()) {
+            case "get":
+                const payloadget:any={params: data?data:params,headers,hashrequest}
+                return axios.get(url,payloadget)
+            case "delete":
+                const payloaddelete:any = {data,params,headers,hashrequest}
+                return axios.delete(url,payloaddelete)
+            case "post":
+                if(params){
+                    tempconfig.params = params
+                }
+                return axios.post(url, data, tempconfig)
+            case "put":
+                return axios.put(url, data, tempconfig)
+            case "patch":
+                return axios.patch(url, data, tempconfig)
+            case "postdownload":
+                return axios({...options,method:'post',headers})
+            default:
+                return axios({...options,headers})
+        }
+    }else{
+        try {
+            url = compile(url)(urldata)
+    
+        } catch (e) {
+            //console.log(e)
+        }
+
+        switch (method.toLowerCase()) {
+            case "get":
+                const payloadget:any={params: data?data:params,hashrequest}
+                return axios.get(url,payloadget)
+            case "delete":
+                const payloaddelete:any = {data,params,hashrequest}
+                return axios.delete(url,payloaddelete)
+            case "post":
+                if(params){
+                    config.params = params
+                }
+                config.hashrequest = hashrequest
+                return axios.post(url, data, config)
+            case "put":
+                return axios.put(url, data, config)
+            case "patch":
+                return axios.patch(url, data, config)
+            case "postdownload":
+                return axios({...options,method:'post'})
+            default:
+                return axios(options)
+        }
+    }
+}
+
+export default function request(options:any, autotip:boolean){
+    return new Promise((resolve)=>{
+        let result:any = {}
+        fetch(options).then(response => {
+            try {
+                if(response?.status===200){
+                    if(autotip)
+                        message.success('操作成功')
+                    result.status=200
+                    result.data = response?.data
+                    result.headers=response.headers
+                    resolve(result)
+                }else if(response?.status===401){
+                    if(!options.url.includes("signin"))
+                        httpUtil.logout()
+                    else
+                        resolve({status:500,data:{}})
+                }else{
+                    if(autotip)
+                        message.error('操作异常')
+                    result.status = 500
+                    result.data = response?.data
+                    result.headers=response.headers
+                    resolve(result)
+                }
+            } catch (error) {
+                if(autotip)
+                    message.error('操作异常')
+                result.status=500
+                result = response?.data
+                resolve(result)
+            }
+        }).catch(async (error) => {
+            if(autotip)
+                message.error('操作异常')
+            let data = error;
+            if(data?.ApiError||data?.status){
+                result.status=500
+                result.data=data
+            }
+            resolve(result)
+        })
+    })
+    
+}

src/utils/standardUtil.ts

+export const standardUtil={
+    getStandardAttrs:(list:Array<any>)=>{
+        let tempmap:any = {};
+        let childrenlist:any = []
+        list.forEach((item:any)=>{
+            if(item.show){
+                if(item.childAttr){
+                    childrenlist.push(item)
+                }else{
+                    if(tempmap[item.status]){
+                        tempmap[item.status] = [...tempmap[item.status],item]
+                    }else{
+                        tempmap[item.status] = [item]
+                    }
+                }
+            }
+        })
+        let attrtype:any = []
+        for(let key in tempmap){
+            attrtype.push({title:key,children:tempmap[key]||[]})
+        }
+        return {typelist:attrtype,childrenAttr:childrenlist}
+    },
+    getStandardColumns:(list:Array<any>)=>{
+        let tempmap:any = [];
+        let childrenlist:any = [];
+        (list||[]).forEach((item:any)=>{
+            if(item.show){
+                if(item.childAttr){
+                    childrenlist.push(item)
+                }else{
+                    tempmap.push(item)
+                }
+            }
+        })
+        return {typelist:tempmap,childrenAttr:childrenlist}
+    },
+}
\ No newline at end of file

src/view/Manage/AssetManage/Component/AssetAction.jsx

@@ -24,8 +24,10 @@ import { checkDataAssetEditable } from '../../../../service/dataassetmanager';
 import download from '../../../../util/download';
 import RelationAssets from './asset-relation-assets';
 import QuestionModalButton from './QuestionModalButton';
-
+import MetaMatchStandard from './MetaMatchStandard';
 import './AssetAction.less';
+import { useGetStandardMatchByIds } from '@/hooks/standard';
+import ImportActionComment from "./ImportActionComment"
 
 const AssetAction = React.forwardRef(function (props, ref) {
   const { id, dirId, action, terms, onChange, reference, readonly = false, permissionId, catalog, template } = props;
@@ -296,6 +298,31 @@ const AssetAction = React.forwardRef(function (props, ref) {
     }
   }, [assets, isStructured])
 
+  const [tableData, total] = useMemo(() => {
+    let currentMetadataColumnList = currentAction!=='detail' ? [...modifyMetadataColumnList||[]] : [...metadataColumnList||[]]
+
+    return [paginate(currentMetadataColumnList, pageNum, pageSize), currentMetadataColumnList.length];
+  }, [metadataColumnList, modifyMetadataColumnList, pagination, keyword, currentAction, assets])
+
+  const resourceIds = useMemo(()=>{
+    return tableData?.map((item)=>{
+        return item.metadataColumnId
+    })
+  },[tableData])
+  const checkStandard=true
+  const {standardmap} = useGetStandardMatchByIds({metadataIds:resourceIds,checkStandard})
+
+  const standardmatch={
+    title: '匹配标准',
+    ellipsis:true,
+    width:150,
+    // resize:true,
+    className: 'table-tag-cell',
+    render:(_,record)=>{
+        return <MetaMatchStandard id={record.metadataColumnId} isManager={false} item={standardmap[record.metadataColumnId]} />
+    }
+  }
+
   const cols = useMemo(() => {
     let newCols = []
 
@@ -304,14 +331,10 @@ const AssetAction = React.forwardRef(function (props, ref) {
       newCols.push(businessActionCol)
     }
  
-    return newCols
+    return [...newCols,standardmatch]
   }, [currentAction, isStructured, columns, businessColumns, businessActionCol])
 
-  const [tableData, total] = useMemo(() => {
-    let currentMetadataColumnList = currentAction!=='detail' ? [...modifyMetadataColumnList||[]] : [...metadataColumnList||[]]
 
-    return [paginate(currentMetadataColumnList, pageNum, pageSize), currentMetadataColumnList.length];
-  }, [metadataColumnList, modifyMetadataColumnList, pagination, keyword, currentAction, assets])
 
   const getPermission = () => {
     dispatch({
@@ -1053,6 +1076,7 @@ const AssetAction = React.forwardRef(function (props, ref) {
           </React.Fragment>
         }
       </div>
+      <ImportActionComment modelerData={assets} />
       {contextHolder}
     </div>
   )

src/view/Manage/AssetManage/Component/ImportActionComment.jsx

+import React from "react"
+import { Button, Space, Input, Divider, Upload, Row, Col, Tooltip, List, Typography, Modal } from "antd"
+import { DownOutlined, UpOutlined, PlusOutlined } from '@ant-design/icons'
+
+import { showMessage } from "../../../../util"
+import { dispatch } from '../../../../model'
+// import { importActionSubject } from "./ImportAction"
+
+import './ImportActionHeader.less'
+import './ImportActionComment.less'
+
+const FC = (props) => {
+  const { modelerData, action } = props
+  const [isCollapse, setCollapse] = React.useState(false)
+  const [uploading, setUploading] = React.useState(false)
+  const [fileList, setFileList] = React.useState()
+  const [comment, setComment] = React.useState()
+  const [comments, setComments] = React.useState()
+  const [modal, contextHolder] = Modal.useModal()
+
+  // React.useEffect(() => {
+  //   const $importActionSubject = importActionSubject.subscribe((props) => {
+  //     if (props.type === 'expand' && props.key === 'model-import-action-comment' && props.action === action) {
+  //       setCollapse(false)
+  //     } 
+  //   })
+
+  //   return () => {
+  //     $importActionSubject.unsubscribe()
+  //   }
+  // }, [action])
+
+  React.useEffect(() => {
+    if (modelerData?.id) {
+      getComments()
+    }
+  }, [modelerData?.id])
+
+  const getComments = () => {
+    dispatch({
+      type: 'datamodel.getComments',
+      payload: {
+        modelId: modelerData?.id,
+        type:'assetsinfo'
+      },
+      callback: data => {
+        setComments(data)
+      }
+    })
+  }
+
+  const onAddCommentClick = () => {
+    console.log(uploading)
+    if (uploading) {
+      showMessage('warn', '文件上传中,请稍后')
+      return
+    }
+
+    dispatch({
+      type: 'datamodel.addComment',
+      payload: {
+        data: {
+          fileList,
+          modelId: modelerData?.id,
+          comment,
+          type:'assetsinfo'
+        }
+      },
+      callback: data => {
+        showMessage('success', '发表评论成功')
+        setFileList([])
+        setComment()
+        getComments()
+      }
+    })
+  }
+
+  const onDeleteClick = (item) => {
+    modal.confirm({
+      title: '提示',
+      content: '确定删除该评论嘛?',
+      onOk: () => {
+        dispatch({
+          type: 'datamodel.deleteComment',
+          payload: { 
+            id: item?.id
+          },
+          callback: data => {
+            showMessage('success', '删除成功')
+            getComments()
+          },
+        })
+      }
+    })
+  }
+
+  const uploadProps = {
+    beforeUpload: file => {
+      if (uploading) {
+        showMessage('warn', '文件上传中,请稍后')
+        return
+      }
+
+      const isLt20M = file.size / 1024 / 1024 <= 100
+      if (!isLt20M) {
+        showMessage('error', '上传文件限制最大100M')
+        return false
+      }
+
+      setUploading(true)
+      dispatch({
+        type: 'datamodel.uploadCommentFile',
+        payload: {
+          fileList: [file]
+        },
+        callback: data => {
+          setUploading(false)
+          if (data) {
+            setFileList(prevFileList => {
+              return [...prevFileList??[], data]
+            })
+          }
+        },
+        error: () => {
+          setUploading(false)
+        }
+      }) 
+
+      return false
+    },
+    fileList: []
+  }
+
+  return (
+    <div className='model-import-action-comment'>
+      <Divider orientation='left'>评论{` (${(comments??[]).length})`}</Divider>
+      {
+        !isCollapse && <div className='mt-3'>
+          <div style={{ border: '1px solid #d9d9d9', borderRadius: 4 }}>
+            <Input.TextArea value={comment} bordered={false} rows={3} placeholder='请输入您的评论' onChange={(e) => { setComment(e.target.value) }}  />
+            <Divider style={{ margin: 0 }}/>
+            <div className='flex' style={{ padding: '8px 11px', justifyContent: 'space-between' }}>
+              <Space align='start'>
+                <Upload {...uploadProps }>
+                  <Button loading={uploading} size='small' icon={<PlusOutlined />} />
+                </Upload>
+                <AttachesItem value={fileList} onChange={(val) => { setFileList(val) }} />
+              </Space>
+              <Tooltip title={comment?'':'请先输入您的评论'}>
+                <Button disabled={!comment} size='small' type='primary' onClick={onAddCommentClick}>发表评论</Button>
+              </Tooltip>
+            </div>
+          </div>
+          <div className='mt-3'>
+            <List
+              itemLayout="horizontal"
+              dataSource={comments??[]}
+              pagination={
+                (comments??[]).length<=20 ? false : {
+                pageSize: 20,
+                size: 'small',
+              }}
+              renderItem={(item) => (
+                <List.Item
+                  // actions={item.currentUser?[<a key="list-delete" onClick={() => {
+                  //   onDeleteClick(item)
+                  // }}>删除</a>]:null}
+                >
+                  <List.Item.Meta
+                    avatar={
+                      <div style={{ width: 60 }}>
+                        <Tooltip title={item.userName}>
+                          <Typography.Text ellipsis={true}>{item.userName}</Typography.Text>
+                        </Tooltip>
+                      </div>
+                    }
+                    title={
+                      <div>
+                        {item.comment}
+                        <AttachesItem value={item.fileList} readOnly />
+                      </div>
+                    }
+                    description={new Date(item.createdTS).toLocaleString()}
+                  />
+                </List.Item>
+              )}
+            />
+          </div>
+        </div>
+      }
+      {contextHolder}
+    </div>
+  )
+}
+
+export default FC
+
+const AttachesItem = ({ value, onChange, readOnly }) => {
+  return (
+    <React.Fragment>
+      {
+        value?.map((item, index) => {
+          return (
+            <div key={index} style={{ marginTop: (!readOnly&&index!==0)?5:0 }}>
+              <Space>
+                <a onClick={() => {
+                  window.open(`/api/datamodelercomment/file/download?id=${item.id}`)
+                }}>{item.fileName}
+                </a>
+                {
+                  !readOnly && <Button 
+                    size='small' 
+                    type='danger'
+                    onClick={() => {
+                      dispatch({
+                        type: 'datamodel.deleteCommentFile',
+                        payload: {
+                          id: item?.id
+                        },
+                        callback: () => {
+                          const newValue = [...value]
+                          newValue.splice(index, 1)
+                          onChange?.(newValue)
+                        }
+                      }) 
+                    }}
+                  >删除</Button>
+                }
+              </Space>
+            </div>
+          )
+        })
+      }
+    </React.Fragment>
+  )
+}
\ No newline at end of file

src/view/Manage/AssetManage/Component/ImportActionComment.less

+.model-import-action-comment {
+  padding-bottom: 20px;
+  .yy-list-pagination {
+    text-align: center;
+  }
+}
\ No newline at end of file

src/view/Manage/AssetManage/Component/ImportActionHeader.less

+.model-import-action-header {
+  .yy-form-item-control {
+    overflow: hidden;
+  }
+}
+
+.model-import-action-header-readolny {
+  .yy-form-item-label > label {
+    height: auto;
+  }
+
+  .yy-form-item-control-input {
+    min-height: 0;
+  }
+}
+
+.edit-template .model-import-action-table {
+  padding: 0;
+}
\ No newline at end of file

src/view/Manage/AssetManage/Component/MetaMatchStandard.tsx

+import React,{useState,useEffect,useRef,useMemo} from "react"
+import {Tag,Button,Tooltip,Typography,Modal,message} from "antd"
+import {useSetState} from "ahooks"
+import { useGetStandardMatchByIds } from "@/hooks/standard";
+import { useGetModalInfoAndAction } from "@/hooks/common"
+
+interface p1{
+    item:any,
+    id:string,
+    isManager?:boolean,
+}
+
+const MetaMatchStandard:React.FC<any>=(props:p1)=>{
+
+    const {item,id,isManager=false} = props
+
+    const [currentItem,setCurrentItem] = useState<any>({})
+    const [visible,setVisible] = useSetState({
+        item:{},
+        visible:false
+    })
+
+    const [reload,setReload] = useState(0)
+    const detailmodal = useGetModalInfoAndAction()
+
+    const checkStandard = useMemo(()=>{
+        if(reload){
+            return true
+        }else{
+            return false
+        }
+    },[reload])
+
+    const ids=useMemo(()=>{
+        return [id]
+    },[id])
+
+    const {standardmap} = useGetStandardMatchByIds({metadataIds:ids,reload,checkStandard})
+
+    useEffect(()=>{
+        if(standardmap[id]){
+            setCurrentItem(standardmap[id])
+        }
+    },[standardmap])
+
+    useEffect(()=>{
+        if(item?.id){
+            setCurrentItem(item)
+        }
+    },[item])
+
+    const color = '#196AD2'
+    
+    const onPreventMouseDown = (event:any) => {
+        event.preventDefault();
+        event.stopPropagation();
+    };
+
+    const name = useMemo(()=>{
+        try {
+            if(currentItem.standardCode){
+                return `${currentItem.standardName} | ${currentItem.standardCode}`
+            }else{
+                return currentItem.standardName
+            }
+        } catch (error) {
+            return ''
+        }
+    },[currentItem])
+
+    const openDetal=(record:any)=>{
+        console.log(record)
+        const type = record.standardId.split('=')[0]
+        detailmodal.openModal(record,{type:'detail',standardType:type,standardId:record.standardId})
+    }
+
+    return(
+        <>
+            <div>
+                {
+                    currentItem.id?(
+                        <Tooltip title={name}>
+                            <Tag
+                                onMouseDown={onPreventMouseDown}
+                                style={{
+                                    marginRight: 3,
+                                    padding: '2px 7px',
+                                    textAlign: 'center',
+                                    borderColor: color,
+                                    color,
+                                    backgroundColor: '#fff',
+                                    cursor:'pointer'
+                                }}
+                                onClick={()=>{openDetal(currentItem)}}
+                            > 
+                                <Typography.Text ellipsis={true} style={{ width: 80 }}>
+                                    <span style={{ color }}>{currentItem?.standardName}</span>
+                                </Typography.Text>
+                            </Tag>
+                        </Tooltip>
+                    ):(
+                        <span></span>
+                    )
+                }
+            </div>
+        </>
+    )
+}
+
+export default MetaMatchStandard
\ No newline at end of file

tsconfig-extand.json

+{
+  "compilerOptions": {
+    "jsx": "react",
+    "baseUrl": "src",
+    "paths": {
+      "@/*": ["*"]
+    }
+  }
+}
\ No newline at end of file

tsconfig.json

@@ -21,6 +21,8 @@
     "jsx": "react-jsx"
   },
   "include": [
-    "src"
-  ]
+    "src",
+    "types.d.ts"
+  ],
+  "extends": "./tsconfig-extand.json"
 }

types.d.ts

+declare module '*.module.less' {
+    const classes: { readonly [key: string]: string }
+    export default classes
+}
+
+
+interface Window {
+    bodyheight: number;
+    bodywidth:number;
+    navigator:any;
+    szseOffice:any;
+}
\ No newline at end of file