主数据定义、主数据配置修改API接口

src/model/index.js

@@ -8,11 +8,12 @@ import * as user from './user';
 import * as datasource from './datasource';
 import * as map from './map';
 import * as datamodel from './datamodel';
+import * as manualdatamodel from './manualdatamodel';
 import * as assetmanage from './assetmanage';
 import * as tag from './tag';
 import * as msd from './msd';
 
-const funcs = Connect({ user, datamodel, map, assetmanage, datasource, tag, msd })
+const funcs = Connect({ user, datamodel, manualdatamodel,map, assetmanage, datasource, tag, msd })
 
 function* request(args) {
   const { type, payload, callback, error } = args.args;

src/model/manualdatamodel.js

+import * as userService from '../service/user';
+import * as metadataService from '../service/metadata';
+import * as datamodelerService from '../service/manualdatamodeler';
+import { call } from 'redux-saga/effects';
+
+export function* getAllSystemAndDatabase() {
+  const roleData = yield call(userService.queryRoles);
+
+  let isAdminMode = false;
+  roleData && roleData.roleData && roleData.roleData.forEach((item) => {
+    if(item.roleId === 2) {
+      isAdminMode=true;
+    }
+  })
+  
+  const systems = yield call(userService.queryUserSystem, { isAdminMode });
+
+  let dbData = [];
+  if (systems.length) {
+    const _system = systems[0].scopeId;
+    dbData = yield call(metadataService.queryDatabase, { sysCodeList: _system });
+  }
+  
+  return { systems, dbs: [ { value: '', name: '所有数据源' } , ...(dbData||[])] };
+  
+}
+
+export function* getAllSystemDatabase(payload) {
+  const dbData = yield call(metadataService.queryDatabase, payload);
+
+  return [ { value: '', name: '所有数据源' } , ...(dbData||[])];
+}
+
+export function* getAllScheme(payload) {
+  let value = payload.db.split(',');
+  const schemaData = yield call(metadataService.querySchemeByParentId, {parentId:value[0]});
+
+  return [ { value: '', name: '所有Schema' } , ...(schemaData||[])]
+}
+
+export function* getAllDataTable(payload) {
+  return yield call(metadataService.queryAllDataTable, payload);
+}
+
+export function* getAllFileds(payload) {
+  return yield call(metadataService.queryAllFields, payload);
+}
+
+export function* loadDataModelCatalog() {
+  return yield call(datamodelerService.loadDataModelCatalog);
+}
+
+export function* refreshDataModelCatalog() {
+  return yield call(datamodelerService.refreshDataModelCatalog);
+}
+
+export function* upDownModelCatalog(payload) {
+  return yield call(datamodelerService.upDownModelCatalog, payload);
+}
+
+export function* loadDataModelStateCatalog() {
+  return yield call(datamodelerService.loadDataModelStateCatalog);
+}
+
+export function* saveDataModelCatalog(payload) {
+  return yield call(datamodelerService.saveDataModelCatalog, payload);
+}
+
+export function* deleteDataModelCatalog(payload) {
+  return yield call(datamodelerService.deleteDataModelCatalog, payload);
+}
+
+export function* bindCatalogDataModel(payload) {
+  return yield call(datamodelerService.bindCatalogDataModel, payload);
+}
+
+export function* getCurrentDataModelCatalog(payload) {
+  return yield call(datamodelerService.getCurrentDataModelCatalog, payload);
+}
+
+export function* getCurrentDataModelStateCatalog(payload) {
+  return yield call(datamodelerService.getCurrentDataModelStateCatalog, payload);
+}
+
+export function* nextState(payload) {
+  return yield call(datamodelerService.nextState, payload);
+}
+
+export function* recatalogDataModel(payload) {
+  return yield call(datamodelerService.recatalogDataModel, payload);
+}
+
+export function* modelCopy(payload) {
+  return yield call(datamodelerService.modelCopy, payload);
+}
+
+export function* getSupportedPartitionTypes(payload) {
+  return yield call(datamodelerService.getSupportedPartitionTypes, payload);
+}
+
+export function* savePartitionType(payload) {
+  return yield call(datamodelerService.savePartitionType, payload);
+}
+
+export function* deletePartitionType(payload) {
+  return yield call(datamodelerService.deletePartitionType, payload);
+}
+
+export function* getSupportedIndextypes() {
+  return yield call(datamodelerService.getSupportedIndextypes);
+}
+
+export function* savePreference(payload) {
+  return yield call(datamodelerService.savePreference, payload);
+} 
+
+export function* getPreference() {
+  return yield call(datamodelerService.getPreference);
+} 
+
+export function* manualSaveNoticeMessage(payload) {
+  return yield call(datamodelerService.manualSaveNoticeMessage, payload);
+}
+
+export function* extractExcelContent(payload) {
+  return yield call(datamodelerService.extractExcelContent, payload);
+}
+
+export function* getAllConstraintsAndTemplates() {
+  const constraints = yield call(datamodelerService.constraints);
+  const templates = yield call(datamodelerService.templates);
+
+  return { constraints, templates }; 
+}
+
+export function* getAllConstraints() {
+  return yield call(datamodelerService.constraints);
+}
+
+export function* getAllTemplates(payload) {
+  return yield call(datamodelerService.templates, payload);
+}
+
+export function* getTemplate(payload) {
+  return yield call(datamodelerService.getTemplate, payload);
+}
+
+export function* saveTemplate(payload) {
+  return yield call(datamodelerService.saveTemplate, payload);
+}
+
+export function* deleteTemplate(payload) {
+  return yield call(datamodelerService.deleteTemplate, payload);
+}
+
+//获取初稿
+export function* getDraft(payload) {
+  return yield call(datamodelerService.draft, payload);
+}
+
+export function* getDraftUsingDDL(payload) {
+  return yield call(datamodelerService.draftUsingDDL, payload);
+}
+
+export function* getConsult(payload) {
+  return yield call(datamodelerService.consult, payload);
+}
+
+export function* translatePhase(payload) {
+  return yield call(datamodelerService.translatePhase, payload);
+}
+
+export function* getSupportedDatatypes() {
+  return yield call(datamodelerService.getSupportedDatatypes);
+}
+
+export function* getSuggestionPreference(payload) {
+  return yield call(datamodelerService.getSuggestionPreference, payload);
+}
+
+export function* suggest(payload) {
+  return yield call(datamodelerService.suggest, payload);
+}
+
+export function* preSaveDataModel(payload) {
+  return yield call(datamodelerService.preSaveDataModel, payload);
+}
+
+export function* saveDataModel(payload) {
+  return yield call(datamodelerService.saveDataModel, payload);
+}
+
+export function* deleteDataModel(payload) {
+  return yield call(datamodelerService.deleteDataModel, payload);
+}
+
+export function* deleteDataModels(payload) {
+  return yield call(datamodelerService.deleteDataModels, payload);
+}
+
+export function* getDataModel(payload) {
+  return yield call(datamodelerService.getDataModel, payload);
+}
+
+export function* getDataModelWithRecommendedDefinitionAndTermDiscovery(payload) {
+  return yield call(datamodelerService.getDataModelWithRecommendedDefinitionAndTermDiscovery, payload);
+}
+
+export function* checkOutDataModel(payload) {
+  return yield call(datamodelerService.checkOutDataModel, payload);
+}
+
+export function* getCheckoutDataModel(payload) {
+  return yield call(datamodelerService.getCheckoutDataModel, payload);
+}
+
+export function* dataModelRollback(payload) {
+  return yield call(datamodelerService.dataModelRollback, payload);
+}
+
+export function* compareOtherModel(payload) {
+  return yield call(datamodelerService.compareOtherModel, payload);
+}
+
+export function* getDataModelStandardMapping(payload) {
+  return yield call(datamodelerService.getDataModelStandardMapping, payload)
+}
+
+export function* getDataModelLocation(payload) {
+  return yield call(datamodelerService.getDataModelLocation, payload);
+}
+
+export function* ddlGenerators() {
+  return yield call(datamodelerService.ddlGenerators);
+}
+
+export function* exportDDLString(payload) {
+  return yield call(datamodelerService.exportDDLString, payload);
+}
+
+export function* ddlChangeString(payload) {
+  return yield call(datamodelerService.ddlChangeString, payload);
+}
+
+export function* exportERWinString(payload) {
+  return yield call(datamodelerService.exportERWinString, payload);
+}
+
+export function* uploadWordTemplate(payload) {
+  return yield call(datamodelerService.uploadWordTemplate, payload);
+}
+
+export function* importWordGenerateModel(payload) {
+  return yield call(datamodelerService.importWordGenerateModel, payload);
+}
+
+export function* importWordLogs(payload) {
+  return yield call(datamodelerService.importWordLogs, payload);
+}
+
+export function* importWordGenerateModelDraft(payload) {
+  return yield call(datamodelerService.importWordGenerateModelDraft, payload);
+}
+
+export function* heartbeat() {
+  return yield call(datamodelerService.heartbeat);
+}
+
+export function* exportTableDDLAbstractList(payload) {
+  return yield call(datamodelerService.exportTableDDLAbstractList, payload);
+}
+
+export function* getExportTableDDL(payload) {
+  return yield call(datamodelerService.getExportTableDDL, payload);
+}
+
+export function* downloadExportTableDDLListZip(payload) {
+  return yield call(datamodelerService.downloadExportTableDDLListZip, payload);
+}
+
+export function* validateDataModel(payload) {
+  return yield call(datamodelerService.validateDataModel, payload);
+}
+
+export function* autocomplete(payload) {
+  return yield call(datamodelerService.autocomplete, payload);
+}
+
+export function* recommandEnglishWords(payload) {
+  return yield call(datamodelerService.recommandEnglishWords, payload);
+}
+
+export function* startFlow(payload) {
+  return yield call(datamodelerService.startFlow, payload);
+}
+
+export function* getDatasourcesByEnv(payload) {
+  return yield call(datamodelerService.getDatasourcesByEnv, payload);
+}
+
+export function* getSchemasByDatasourceId(payload) {
+  return yield call(datamodelerService.getSchemasByDatasourceId, payload);
+}
+
+export function* getParent(payload) {
+  return yield call(datamodelerService.getParent, payload);
+}
+
+export function* autoCreateTable(payload) {
+  return yield call(datamodelerService.autoCreateTable, payload);
+}
+
+export function* searchModel(payload) {
+  return yield call(datamodelerService.searchModel, payload);
+}
+
+export function* getVersions(payload) {
+  return yield call(datamodelerService.getVersions, payload);
+}
+
+export function* compare(payload) {
+  return yield call(datamodelerService.compare, payload);
+}
+
+export function* getDataModelByVersionId(payload) {
+  return yield call(datamodelerService.getDataModelByVersionId, payload);
+}
+
+export function* getDataModelDigest(payload) {
+  return yield call(datamodelerService.getDataModelDigest, payload);
+}
+
+export function* isSetRootDomainId() {
+  return yield call(datamodelerService.isSetRootDomainId);
+}
+
+export function* setRootDomainId(payload) {
+  return yield call(datamodelerService.setRootDomainId, payload);
+} 
+
+export function* getMaintenanceRecords(payload) {
+  return yield call(datamodelerService.getMaintenanceRecords, payload);
+}
+
+export function* getSystemAllGraph(payload) {
+  return yield call(metadataService.getSystemAllGraph, payload);
+}
+
+export function* dataTypeList() {
+  return yield call(datamodelerService.dataTypeList);
+}
+
+export function* bindingLoadRangeList(payload) {
+  return yield call(datamodelerService.bindingLoadRangeList, payload);
+}
+
+export function* getInheritanceTypes() {
+  return yield call(datamodelerService.getInheritanceTypes);
+}
+
+export function* inheriteDataModel(payload) {
+  return yield call(datamodelerService.inheriteDataModel, payload);
+}
+
+export function* getConfigPrivilege() {
+  return yield call(datamodelerService.getConfigPrivilege);
+}
+
+export function* getCatalogAdmin() {
+  return yield call(datamodelerService.getCatalogAdmin);
+}
+
+export function* getPrivilegeBranchAdmin() {
+  return yield call(datamodelerService.getPrivilegeBranchAdmin);
+}
+
+export function* getModelPrivilege(payload) {
+  return yield call(datamodelerService.getModelPrivilege, payload)
+}
+
+export function* getRuleTemplateList() {
+  return yield call(datamodelerService.getRuleTemplateList);
+}
+
+export function* getRuleTemplateReferenceRuleCatalogList(payload) {
+  return yield call(datamodelerService.getRuleTemplateReferenceRuleCatalogList, payload);
+}
+
+export function* addRuleTemplate(payload) {
+  return yield call(datamodelerService.addRuleTemplate, payload);
+}
+
+export function* updateRuleTemplate(payload) {
+  return yield call(datamodelerService.updateRuleTemplate, payload);
+}
+
+export function* deletesRuleTemplate(payload) {
+  return yield call(datamodelerService.deletesRuleTemplate, payload);
+}
+
+export function* deleteRuleTemplate(payload) {
+  return yield call(datamodelerService.deleteRuleTemplate, payload);
+}
+
+export function* getRuleTemplateDetail(payload) {
+  return yield call(datamodelerService.getRuleTemplateDetail, payload);
+}
+
+export function* getRuleTemplateCheckTypes() {
+  return yield call(datamodelerService.getRuleTemplateCheckTypes);
+}
+
+export function* getRuleTemplateAllCheckPropertyTypes() {
+  return yield call(datamodelerService.getRuleTemplateAllCheckPropertyTypes);
+}
+
+export function* getRuleTemplateAllVerifyExpressionTypes() {
+  return yield call(datamodelerService.getRuleTemplateAllVerifyExpressionTypes);
+}
+
+export function* getRuleTemplateAllVertifyExpressions() {
+  return yield call(datamodelerService.getRuleTemplateAllVertifyExpressions);
+}
+
+/* rule catalog */
+export function* addRuleCatalog(payload) {
+  return yield call(datamodelerService.addRuleCatalog, payload)
+}
+
+export function* updateRuleCatalog(payload) {
+  return yield call(datamodelerService.updateRuleCatalog, payload)
+}
+
+export function* upRuleCatalog(payload) {
+  return yield call(datamodelerService.upRuleCatalog, payload)
+}
+
+export function* downRuleCatalog(payload) {
+  return yield call(datamodelerService.downRuleCatalog, payload)
+}
+
+export function* deleteRuleCatalog(payload) {
+  return yield call(datamodelerService.deleteRuleCatalog, payload)
+}
+
+export function* getRuleCatalogList() {
+  return yield call(datamodelerService.getRuleCatalogList)
+}
+
+export function* getRuleCatalogEnableList() {
+  return yield call(datamodelerService.getRuleCatalogEnableList)
+}
+
+export function* getRuleCatalogVersionList(payload) {
+  return yield call(datamodelerService.getRuleCatalogVersionList, payload)
+}
+
+export function* compareRuleCatalogVersion(payload) {
+  return yield call(datamodelerService.compareRuleCatalogVersion, payload)
+}
+
+export function* getRuleCatalogStatus() {
+  return yield call(datamodelerService.getRuleCatalogStatus)
+}
+
+/* rule */
+export function* addRule(payload) {
+  return yield call(datamodelerService.addRule, payload)
+}
+
+export function* updateRule(payload) {
+  return yield call(datamodelerService.updateRule, payload)
+}
+
+export function* deleteRules(payload) {
+  return yield call(datamodelerService.deleteRules, payload)
+}
+
+export function* getRuleList(payload) {
+  return yield call(datamodelerService.getRuleList, payload)
+}
+
+export function* getRuleAlertTypes() {
+  return yield call(datamodelerService.getRuleAlertTypes)
+}
+
+export function* getRuleStatus() {
+  return yield call(datamodelerService.getRuleStatus)
+}
+
+export function* addComment(payload) {
+  return yield call(datamodelerService.addComment, payload)
+}
+
+export function* deleteComment(payload) {
+  return yield call(datamodelerService.deleteComment, payload)
+}
+
+export function* getComments(payload) {
+  return yield call(datamodelerService.getComments, payload)
+}
+
+export function* uploadCommentFile(payload) {
+  return yield call(datamodelerService.uploadCommentFile, payload)
+}
+
+export function* deleteCommentFile(payload) {
+  return yield call(datamodelerService.deleteCommentFile, payload)
+}
+
+export function* getSearchProperties() {
+  return yield call(datamodelerService.getSearchProperties)
+}
+
+export function* searchModelBySearchProperties(payload) {
+  return yield call(datamodelerService.searchModelBySearchProperties, payload)
+}
+
+export function* getNoticeDataModelById(payload) {
+  return yield call(datamodelerService.getNoticeDataModelById, payload)
+}
+
+export function* getNoticeDataModelByVersionId(payload) {
+  return yield call(datamodelerService.getNoticeDataModelByVersionId, payload)
+}
+
+export function* getCompareJobList() {
+  return yield call(datamodelerService.getCompareJobList)
+}
+
+export function* getCompareJobDetail(payload) {
+  return yield call(datamodelerService.getCompareJobDetail, payload)
+}
+
+export function* addCompareJob(payload) {
+  return yield call(datamodelerService.addCompareJob, payload)
+}
+
+export function* updateCompareJob(payload) {
+  return yield call(datamodelerService.updateCompareJob, payload)
+}
+
+export function* deleteCompareJobs(payload) {
+  return yield call(datamodelerService.deleteCompareJobs, payload)
+}
+
+export function* runCompareJob(payload) {
+  return yield call(datamodelerService.runCompareJob, payload)
+}
+
+export function* runCompareJobLog(payload) {
+  return yield call(datamodelerService.runCompareJobLog, payload)
+}
+
+export function* reRunCompareJob(payload) {
+  return yield call(datamodelerService.reRunCompareJob, payload)
+}
+
+export function* cancelCompareJob(payload) {
+  return yield call(datamodelerService.cancelCompareJob, payload)
+}
+
+export function* getCompareJobStates() {
+  return yield call(datamodelerService.getCompareJobStates)
+}
+
+export function* getCompareJobModelStates() {
+  return yield call(datamodelerService.getCompareJobModelStates)
+}
+
+export function* getModelCompareJobCompareTypes() {
+  return yield call(datamodelerService.getModelCompareJobCompareTypes)
+}
+
+export function* getStrategyItemPropertyTypes() {
+  return yield call(datamodelerService.getStrategyItemPropertyTypes)
+}
+
+export function* getCompareJobCronCycleTypes() {
+  return yield call(datamodelerService.getCompareJobCronCycleTypes)
+}
+
+export function* getChildBySystem(payload) {
+  return yield call(metadataService.getChildBySystem, payload)
+}
+
+export function* getChildByParentId(payload) {
+  return yield call(metadataService.getChildByParentId, payload)
+}
+
+export function* getSettingCols(payload) {
+  return yield call(datamodelerService.getSettingCols, payload)
+}
+
+export function* setSettingCols(payload) {
+  return yield call(datamodelerService.setSettingCols, payload)
+}
+
+export function* getCompareJobResultList(payload) {
+  return yield call(datamodelerService.getCompareJobResultList, payload)
+}
+
+export function* getCompareJobRunStateTypes() {
+  return yield call(datamodelerService.getCompareJobRunStateTypes)
+}
+
+export function* getCompareJobResultPerfectMatchList(payload) {
+  return yield call(datamodelerService.getCompareJobResultPerfectMatchList, payload)
+}
+
+export function* getCompareJobResultPartialMatchList(payload) {
+  return yield call(datamodelerService.getCompareJobResultPartialMatchList, payload)
+}
+
+export function* getCompareJobResultNotMatchModelList(payload) {
+  return yield call(datamodelerService.getCompareJobResultNotMatchModelList, payload)
+}
+
+export function* getCompareJobResultNotMatchMetadataList(payload) {
+  return yield call(datamodelerService.getCompareJobResultNotMatchMetadataList, payload)
+}
+
+export function* getCompareJobResultDeployModels(payload) {
+  return yield call(datamodelerService.getCompareJobResultDeployModels, payload)
+}
+
+export function* getCompareJobResultMetadataNotMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultMetadataNotMatchCatalog, payload)
+}
+
+export function* getCompareJobResultMetadataPartialMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultMetadataPartialMatchCatalog, payload)
+}
+
+export function* getCompareJobResultMetadataPerfectMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultMetadataPerfectMatchCatalog, payload)
+}
+
+export function* getCompareJobResultModelNotMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultModelNotMatchCatalog, payload)
+}
+
+export function* getCompareJobResultModelPartialMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultModelPartialMatchCatalog, payload)
+}
+
+export function* getCompareJobResultModelPerfectMatchCatalog(payload) {
+  return yield call(datamodelerService.getCompareJobResultModelPerfectMatchCatalog, payload)
+}
+
+export function* getCompareJobResultModelCount(payload) {
+  const deployWaitingCount = yield call(datamodelerService.getCompareJobResultDeployWaitingTotalCount, payload)
+  const deployedCount = yield call(datamodelerService.getCompareJobResultDeployedTotalCount, payload)
+  const offlineCount = yield call(datamodelerService.getCompareJobResultOfflineTotalCount, payload)
+
+  return { totalCount: (deployWaitingCount+deployedCount+offlineCount), deployWaitingCount, deployedCount, offlineCount }
+}
+
+export function* getCompareJobResultDeployWaitingModelPage(payload) {
+  return yield call(datamodelerService.getCompareJobResultDeployWaitingModelPage, payload)
+}
+
+export function* getCompareJobResultDeployedModelPage(payload) {
+  return yield call(datamodelerService.getCompareJobResultDeployedModelPage, payload)
+}
+
+export function* getCompareJobResultOfflineModelPage(payload) {
+  return yield call(datamodelerService.getCompareJobResultOfflineModelPage, payload)
+}
+
+export function* addDataTypeConfig(payload) {
+  return yield call(datamodelerService.addDataTypeConfig, payload)
+}
+
+export function* batchDeleteDataTypeConfig(payload) {
+  return yield call(datamodelerService.batchDeleteDataTypeConfig, payload)
+}
+
+export function* getDataTypeConfigs() {
+  return yield call(datamodelerService.getDataTypeConfigs)
+}
+
+export function* getStandardTypes() {
+  return yield call(datamodelerService.getStandardTypes)
+}
+
+export function* getSupportDBTypes() {
+  return yield call(datamodelerService.getSupportDBTypes)
+}
+
+export function* getColumnTypes(payload) {
+  return yield call(datamodelerService.getColumnTypes, payload)
+}
+
+export function* getAllBranches() {
+  return yield call(datamodelerService.getAllBranches)
+}
+
+export function* upDownBranch(payload) {
+  return yield call(datamodelerService.upDownBranch, payload)
+}
+
+export function* saveBranch(payload) {
+  return yield call(datamodelerService.saveBranch, payload)
+}
+
+export function* getBranch(payload) {
+  return yield call(datamodelerService.getBranch, payload)
+}
+
+export function* deleteBranch(payload) {
+  return yield call(datamodelerService.deleteBranch, payload)
+}
+
+export function* getBranchDiffForked(payload) {
+  return yield call(datamodelerService.getBranchDiffForked, payload)
+}
+
+export function* joinBranch(payload) {
+  return yield call(datamodelerService.joinBranch, payload)
+}
+
+export function* behindAlarmInBranch(payload) {
+  return yield call(datamodelerService.behindAlarmInBranch, payload)
+}
+
+export function* syncBranch(payload) {
+  return yield call(datamodelerService.syncBranch, payload)
+}
+
+export function* getForkedModel(payload) {
+  return yield call(datamodelerService.getForkedModel, payload)
+}
+
+export function* getForkEasyDataModelerDataModelDistributions(payload) {
+  return yield call(datamodelerService.getForkEasyDataModelerDataModelDistributions, payload)
+}
+
+export function* mergeBranch(payload) {
+  return yield call(datamodelerService.mergeBranch, payload)
+}
+
+export function* getCooperationUsers(payload) {
+  return yield call(datamodelerService.getCooperationUsers, payload)
+}
+
+export function* getCooperatorCandidates(payload) {
+  return yield call(datamodelerService.getCooperatorCandidates, payload)
+}
+
+export function* getApprovalUsers(payload) {
+  return yield call(datamodelerService.getApprovalUsers, payload)
+}
+
+export function* addPhysicalModelApproval(payload) {
+  return yield call(datamodelerService.addPhysicalModelApproval, payload)
+}
+
+export function* getPhysicalModelApproval(payload) {
+  return yield call(datamodelerService.getPhysicalModelApproval, payload)
+}
+
+export function* updatePhysicalModelApproval(payload) {
+  return yield call(datamodelerService.updatePhysicalModelApproval, payload)
+}
+
+export function* commitPhysicalModelApproval(payload) {
+  return yield call(datamodelerService.commitPhysicalModelApproval, payload)
+}
+
+export function* setPhysicalModelApprovalTip(payload) {
+  return yield call(datamodelerService.setPhysicalModelApprovalTip, payload)
+}
+
+export function* getPhysicalModelApprovalTip(payload) {
+  return yield call(datamodelerService.getPhysicalModelApprovalTip, payload)
+}
+
+export function* approvalUploadFile(payload) {
+  return yield call(datamodelerService.approvalUploadFile, payload)
+}
+
+export function* approvalDeleteFile(payload) {
+  return yield call(datamodelerService.approvalDeleteFile, payload)
+}
+
+export function* getCooperators(payload) {
+  return yield call(datamodelerService.getCooperators, payload)
+}
+
+export function* setCooperators(payload) {
+  return yield call(datamodelerService.setCooperators, payload)
+}
+
+export function* getOwner(payload) {
+  return yield call(datamodelerService.getOwner, payload)
+}
+
+export function* setOwner(payload) {
+  return yield call(datamodelerService.setOwner, payload)
+}
+
+export function* findAssociationMetadataByModelId(payload) {
+  return yield call(datamodelerService.findAssociationMetadataByModelId, payload)
+}
+
+export function* getMatchMetadataTableById(payload) {
+  return yield call(datamodelerService.getMatchMetadataTableById, payload)
+}
+
+export function* getModelMetadataCompareResult(payload) {
+  return yield call(datamodelerService.getModelMetadataCompareResult, payload)
+}
+
+export function* getModelBranchNotice(payload) {
+  return yield call(datamodelerService.getModelBranchNotice, payload)
+}
+
+export function* processConflictDataModel(payload) {
+  return yield call(datamodelerService.processConflictDataModel, payload)
+}
+
+export function* getMetadataTable(payload) {
+  return yield call(datamodelerService.getMetadataTable, payload)
+}
+
+export function* conceptualModelCreateDataModel(payload) {
+  return yield call(datamodelerService.conceptualModelCreateDataModel, payload)
+}
\ No newline at end of file

src/service/manualdatamodeler.js

+import { PostFile, GetJSON, PostJSON, Post, Get, Delete, Delete1, Delete2, callFetchRaw } from "../util/axios"
+
+export function loadDataModelCatalog() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/loadDataModelCatalog");
+}
+
+export function refreshDataModelCatalog() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/refreshDataModelCatalog");
+}
+
+export function loadDataModelStateCatalog() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/loadDataModelStateCatalog");
+}
+
+export function saveDataModelCatalog(payload) {
+  return Post("/customDataModeler/easyDataModelerCURD/saveDataModelCatalog", payload);
+} 
+
+export function deleteDataModelCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/deleteDataModelCatalog", payload);
+}
+
+export function upDownModelCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/upDownModelCatalog", payload);
+}
+
+//绑定模型和模型目录
+export function bindCatalogDataModel(payload) {
+  return Post("/customDataModeler/easyDataModelerCURD/catalogDataModel", payload);
+}
+
+//读取当前模型目录中的模型
+export function getCurrentDataModelCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getCurrentDataModelCatalog", payload);
+}
+
+//读取当前模型目录中的模型(状态)
+export function getCurrentDataModelStateCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getCurrentDataModelStateCatalog", payload);
+}
+
+export function nextState(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/nextState", payload);
+}
+
+export function recatalogDataModel(payload) {
+  return Post("/customDataModeler/easyDataModelerCURD/recatalogDataModel", payload);
+}
+
+export function modelCopy(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/copy", payload);
+}
+
+export function getSupportedPartitionTypes(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getSupportedPartitionTypes", payload);
+}
+
+export function savePartitionType(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/savePartitionType", payload);
+}
+
+export function deletePartitionType(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/deletePartitionType", payload);
+}
+
+export function getSupportedIndextypes() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getSupportedIndextypes");
+}
+
+export function savePreference(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/savePreference", payload);
+}
+
+export function getPreference() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getPreference");
+}
+
+export function manualSaveNoticeMessage(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/manualSaveNoticeMessage", payload);
+}
+
+export function extractExcelContent(payload) {
+  return PostFile("/customDataModeler/easyDataModelerDesign/kickStart", payload);
+}
+
+//规则
+export function constraints() {
+  return GetJSON("/customDataModeler/easyDataModelerConstraint/constraints");
+}
+
+//模版
+export function templates(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerTemplateCURD/getAllDataModelTemplates", payload);
+}
+
+export function getTemplate(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerTemplateCURD/getDataModelTemplate", payload);
+}
+
+export function saveTemplate(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerTemplateCURD/saveDataModelTemplate", payload);
+}
+
+export function deleteTemplate(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerTemplateCURD/deleteDataModelTemplate", payload);
+}
+
+//创建初稿
+export function draft(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/draft", payload);
+}
+
+export function draftUsingDDL(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/draftUsingDDL", payload);
+}
+
+//切换模版或者规范时调用
+export function consult(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/consult", payload);
+}
+
+export function translatePhase(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/translatePhase", payload);
+}
+
+//获取支持的数据类型
+export function getSupportedDatatypes() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getSupportedDatatypes");
+}
+
+export function getSuggestionPreference(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerDesign/getSuggestionPreference", payload);
+}
+
+export function suggest(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/suggest", payload);
+}
+
+export function preSaveDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/preSaveDataModel", payload);
+}
+
+//保存模型
+export function saveDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/saveDataModel", payload);
+}
+
+export function deleteDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/deleteDataModel", payload);
+}
+
+export function deleteDataModels(payload) {
+  return Post("/customDataModeler/easyDataModelerCURD/deleteDataModels", payload);
+}
+
+export function getDataModel(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getDataModel", payload);
+}
+
+export function getDataModelWithRecommendedDefinitionAndTermDiscovery(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getDataModelWithRecommendedDefinitionAndTermDiscovery", payload);
+}
+
+export function checkOutDataModel(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/checkOutDataModel", payload);
+}
+
+export function getDataModelLocation(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getDataModelLocation", payload);
+}
+
+export function searchModel(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/searchEasyDataModelerDataModelsByNaming", payload);
+}
+
+export function getVersions(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/getVersions", payload);
+}
+
+export function compare(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/compareVersion", payload);
+}
+
+export function getDataModelByVersionId(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/getDataModelByVersionId", payload);
+}
+
+export function getDataModelDigest(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getDataModelDigest", payload);
+}
+
+export function isSetRootDomainId() {
+  return Get("/customDataModeler/easyDataModelerCURD/isSetRootDomainId");
+}
+
+export function setRootDomainId(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/setRootDomainId", payload);
+}
+
+export function getMaintenanceRecords(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getMaintenanceRecords", payload);
+}
+
+export function getCheckoutDataModel(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getCheckoutDataModel", payload);
+}
+
+export function dataModelRollback(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/reset", payload);
+}
+
+export function compareOtherModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/compareOtherModel", payload);
+}
+
+export function getDataModelStandardMapping(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getDataModelStandardMapping", payload);
+}
+
+export function ddlGenerators() {
+  return GetJSON("/customDataModeler/easyDataModelerExport/ddlGenerators");
+}
+
+export function exportDDLString(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerExport/ddlString", payload);
+}
+
+export function ddlChangeString(payload) {
+  return Get("/customDataModeler/easyDataModelerExport/ddlChangeString", payload);
+}
+
+export function exportERWinString(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerExport/erWinPluginString", payload);
+}
+
+export function uploadWordTemplate(payload) {
+  return PostFile("/customDataModeler/easyDataModelerExport/word/uploadTemplate", payload);
+}
+
+export function importWordGenerateModel(payload) {
+  return PostFile("/customDataModeler/easyDataModelerExport/word", payload);
+}
+
+export function importWordLogs(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerExport/log/list", payload);
+}
+
+export function importWordGenerateModelDraft(payload) {
+  return PostFile("/customDataModeler/easyDataModelerExport/word/draft", payload);
+}
+
+export function heartbeat() {
+  return Get("/customDataModeler/easyDataModelerExport/heartbeat");
+}
+
+export function exportTableDDLAbstractList(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerExport/exportTableDDLAbstractList", payload);
+}
+
+export function getExportTableDDL(payload) {
+  return Post("/customDataModeler/easyDataModelerExport/getExportTableDDL", payload);
+}
+
+export function downloadExportTableDDLListZip(payload) {
+  return callFetchRaw("post","/customDataModeler/easyDataModelerExport/downloadExportTableDDLListZip", payload);
+}
+
+export function validateDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerConstraint/validateDataModel", payload);
+}
+
+export function autocomplete(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/autocomplete", payload);
+}
+
+export function recommandEnglishWords(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerDesign/recommandEnglishWords", payload);
+}
+
+export function startFlow(payload) {
+  return Post("/customDataModeler/easyDataModelerWorkflowSupport/startModelFlow", payload);
+}
+
+export function getDatasourcesByEnv (payload) {
+  return GetJSON("/metadatarepo/rest/metadata/findByModelAndSys", payload);
+}
+
+export function getSchemasByDatasourceId(payload) {
+  return GetJSON("/metadatarepo/rest/query/getChild", payload);
+}
+
+export function getParent(payload) {
+  return GetJSON("/metadatarepo/rest/query/getParent", payload);
+}
+
+export function autoCreateTable(payload) {
+  return PostJSON("/metadataharvester/datasource/createTableByDDLList", payload);
+}
+
+export function dataTypeList() {
+  return GetJSON("/customDataModeler/easyDataModelerDataType/dataTypeList");
+}
+
+export function bindingLoadRangeList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerDataType/bindingLoadRangeList", payload);
+}
+
+export function getInheritanceTypes() {
+  return PostJSON("/customDataModeler/easyDataModelerInheritance/getInheritanceTypes");
+}
+
+export function inheriteDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerInheritance/inheriteDataModel", payload);
+}
+
+export function getConfigPrivilege() {
+  return GetJSON("/customDataModeler/easyDataModelerPrivilegeProvider/getConfigPrivilege");
+}
+
+export function getCatalogAdmin() {
+  return Get("/customDataModeler/easyDataModelerPrivilegeProvider/getCatalogAdmin");
+}
+
+export function getPrivilegeBranchAdmin() {
+  return Get("/customDataModeler/easyDataModelerPrivilegeProvider/getBranchCreation");
+}
+
+export function getModelPrivilege(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerPrivilegeProvider/getModelFullPrivilege", payload);
+}
+
+export function getRuleTemplateList() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/list");
+}
+
+export function getRuleTemplateReferenceRuleCatalogList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/referenceRuleCatalogList", payload);
+}
+
+/* rule template */
+export function addRuleTemplate(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleTemplate/add", payload);
+}
+
+export function updateRuleTemplate(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleTemplate/update", payload);
+}
+
+export function deletesRuleTemplate(payload) {
+  return Delete("/customDataModeler/easyDataModelerRuleTemplate/dels", payload);
+}
+
+export function deleteRuleTemplate(payload) {
+  return Delete("/customDataModeler/easyDataModelerRuleTemplate/del", payload);
+}
+
+export function getRuleTemplateDetail(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/getById", payload);
+}
+
+export function getRuleTemplateCheckTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/getCheckTypes");
+}
+
+export function getRuleTemplateAllCheckPropertyTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/getAllCheckPropertyTypes");
+}
+
+export function getRuleTemplateAllVerifyExpressionTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/getAllVerifyExpressionTypes")
+}
+
+export function getRuleTemplateAllVertifyExpressions() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleTemplate/getAllVerifyExpressions")
+}
+
+/* rule catalog  */
+export function addRuleCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleCatalog/add", payload)
+}
+
+export function updateRuleCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleCatalog/update", payload)
+}
+
+export function upRuleCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleCatalog/up", payload)
+}
+
+export function downRuleCatalog(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRuleCatalog/down", payload)
+}
+
+export function deleteRuleCatalog(payload) {
+  return Delete("/customDataModeler/easyDataModelerRuleCatalog/del", payload)
+}
+
+export function getRuleCatalogList() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleCatalog/list")
+}
+
+export function getRuleCatalogEnableList() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleCatalog/enableList")
+}
+
+export function getRuleCatalogVersionList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerRuleCatalog/versionList", payload)
+}
+
+export function compareRuleCatalogVersion(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerRuleCatalog/compare", payload)
+}
+
+export function getRuleCatalogStatus() {
+  return GetJSON("/customDataModeler/easyDataModelerRuleCatalog/getRuleStatus")
+}
+
+/* rule */
+export function addRule(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRule/add", payload)
+}
+
+export function updateRule(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerRule/update", payload)
+}
+
+export function deleteRules(payload) {
+  return Delete("/customDataModeler/easyDataModelerRule/dels", payload)
+}
+
+export function getRuleList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerRule/getListByCatalogId", payload)
+}
+
+export function getRuleAlertTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerRule/getRuleAlertTypes")
+}
+
+export function getRuleStatus() {
+  return GetJSON("/customDataModeler/easyDataModelerRule/getRuleStatus")
+}
+
+export function addComment(payload) {
+  return PostJSON("/datamodelercomment/comment/add", payload)
+}
+
+export function deleteComment(payload) {
+  return Delete("/datamodelercomment/comment/del", payload)
+}
+
+export function getComments(payload) {
+  return GetJSON("/datamodelercomment/comment/list", payload)
+}
+
+export function uploadCommentFile(payload) {
+  return PostFile("/datamodelercomment/file/upload", payload)
+}
+
+export function deleteCommentFile(payload) {
+  return Delete("/datamodelercomment/file/del", payload) 
+}
+
+export function getSearchProperties() {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getModelSearchProperties")
+}
+
+export function searchModelBySearchProperties(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCURD/searchEasyDataModelerDataModelsByModelSearchProperties", payload);
+}
+
+export function getNoticeDataModelById(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getNoticeDataModelById", payload)
+}
+
+export function getNoticeDataModelByVersionId(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCURD/getNoticeDataModelByVersionId", payload)
+}
+
+/* compare */
+export function getCompareJobList() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/listAll")
+}
+
+export function getCompareJobDetail(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/findById", payload)
+}
+
+export function addCompareJob(payload) {
+  return PostJSON("/customDataModeler/easyDataModelModelCompareJob/addJob", payload)
+}
+
+export function updateCompareJob(payload) {
+  return PostJSON("/customDataModeler/easyDataModelModelCompareJob/updateJob", payload)
+}
+
+export function deleteCompareJobs(payload) {
+  return Delete2("/customDataModeler/easyDataModelModelCompareJob/delModelCompareJobs", payload)
+}
+
+export function runCompareJob(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/runJob", payload)
+}
+
+export function runCompareJobLog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/runJobLog", payload)
+}
+
+export function reRunCompareJob(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/reRunJob", payload)
+}
+
+export function cancelCompareJob(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/cancelJob", payload)
+}
+
+export function getCompareJobStates() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/getJobStatusTypes")
+}
+
+export function getCompareJobModelStates() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/getModelStatusTypes")
+}
+
+export function getModelCompareJobCompareTypes() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/getModelCompareJobCompareTypes")
+}
+
+export function getStrategyItemPropertyTypes() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/getStrategyItemPropertyTypes")
+}
+
+export function getCompareJobCronCycleTypes() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJob/getCronCycleTypes")
+}
+
+export function getSettingCols(payload) {
+  return GetJSON("/dataquality/setting/get", payload)
+}
+
+export function setSettingCols(payload) {
+  return PostJSON("/dataquality/setting/set", payload)
+}
+
+export function getCompareJobResultList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getList", payload)
+}
+
+export function getCompareJobRunStateTypes() {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getModelCompareJobRunStateTypes")
+}
+
+export function getCompareJobResultPerfectMatchList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getPerfectMatchList", payload)
+}
+
+export function getCompareJobResultPartialMatchList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getPartialMatchList", payload)
+}
+
+export function getCompareJobResultNotMatchModelList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getNotMatchModelList", payload)
+}
+
+export function getCompareJobResultNotMatchMetadataList(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getNotMatchMetadataList", payload)
+}
+
+export function getCompareJobResultDeployModels(payload) {
+  return PostJSON("/customDataModeler/easyDataModelModelCompareJobResult/deployModelByResultItemIds", payload)
+}
+
+export function getCompareJobResultMetadataNotMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getMetadataNotMatchCatalog", payload)
+}
+
+export function getCompareJobResultMetadataPartialMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getMetadataPartialMatchCatalog", payload)
+}
+
+export function getCompareJobResultMetadataPerfectMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getMetadataPerfectMatchCatalog", payload)
+}
+
+export function getCompareJobResultModelNotMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getModelNotMatchCatalog", payload)
+}
+
+export function getCompareJobResultModelPartialMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getModelPartialMatchCatalog", payload)
+}
+
+export function getCompareJobResultModelPerfectMatchCatalog(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getModelPerfectMatchCatalog", payload)
+}
+
+export function getCompareJobResultDeployWaitingTotalCount(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getDeployWaitingTotalCount", payload)
+}
+
+export function getCompareJobResultDeployWaitingModelPage(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getDeployWaitingModelPage", payload)
+}
+
+export function getCompareJobResultDeployedTotalCount(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getDeployedTotalCount", payload)
+}
+
+export function getCompareJobResultDeployedModelPage(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getDeployedModelPage", payload)
+}
+
+
+export function getCompareJobResultOfflineTotalCount(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getOfflineTotalCount", payload)
+}
+
+export function getCompareJobResultOfflineModelPage(payload) {
+  return GetJSON("/customDataModeler/easyDataModelModelCompareJobResult/getOfflineModelPage", payload)
+}
+
+/*type config*/
+export function addDataTypeConfig(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerColumnDataType/addDataTypeConfig", payload)
+}
+
+export function batchDeleteDataTypeConfig(payload) {
+  return Delete1("/customDataModeler/easyDataModelerColumnDataType/dels", payload)
+}
+
+export function getDataTypeConfigs() {
+  return GetJSON("/customDataModeler/easyDataModelerColumnDataType/getList")
+}
+
+export function getStandardTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerColumnDataType/getStandardTypes")
+}
+
+export function getSupportDBTypes() {
+  return GetJSON("/customDataModeler/easyDataModelerColumnDataType/getSupportDBTypes")
+}
+
+export function getColumnTypes(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerColumnDataType/getColumnTypes", payload)
+}
+
+/*branch*/
+export function getAllBranches() {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/getAllBranches")
+}
+
+export function upDownBranch(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerBranching/moveBranchUpOrDown", payload)
+}
+
+export function saveBranch(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerBranching/saveBranch", payload)
+}
+
+export function getBranch(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/getBranch", payload)
+}
+
+export function deleteBranch(payload) {
+  return Delete("/customDataModeler/easyDataModelerBranching/deleteBranch", payload)
+}
+
+export function getBranchDiffForked(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/diffEasyDataModelerDataModelWithForked", payload)
+}
+
+export function joinBranch(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/joinEasyDataModelerDataModel", payload)
+}
+
+export function behindAlarmInBranch(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/easyDataModelerDataModelBehindAlarmInBranch", payload)
+}
+
+export function syncBranch(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerBranching/syncWithForkedEasyDataModelerDataModel", payload)
+}
+
+export function getForkedModel(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/getForkedEasyDataModelerDataModel", payload)
+}
+
+export function getForkEasyDataModelerDataModelDistributions(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerBranching/getForkEasyDataModelerDataModelDistributions", payload)
+}
+
+export function mergeBranch(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerBranching/merge", payload)
+}
+
+/*approval*/
+export function getApprovalUsers(payload) {
+  return GetJSON("/baseservice/sync/getUserByUserName", payload)
+}
+
+export function addPhysicalModelApproval(payload) {
+  return Post("/customDataModeler/easyDataModelerApproval/addPhysicalModelApproval", payload)
+}
+export function getPhysicalModelApproval(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerApproval/getPhysicalModelApprovalById", payload)
+}
+
+export function updatePhysicalModelApproval(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerApproval/updatePhysicalModelApproval", payload)
+}
+
+export function commitPhysicalModelApproval(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerApproval/commitPhysicalModelApproval", payload)
+}
+
+export function setPhysicalModelApprovalTip(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerApproval/setAlertContent", payload)
+}
+
+export function getPhysicalModelApprovalTip(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerApproval/getAlertContent", payload)
+}
+
+export function approvalUploadFile(payload) {
+  return PostFile("/customDataModeler/file/upload", payload)
+}
+
+export function approvalDeleteFile(payload) {
+  return Delete("/customDataModeler/file/del", payload)
+}
+
+/*协同工作*/
+export function getCooperationUsers(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCooperation/users", payload)
+}
+
+//权限共享
+export function getCooperatorCandidates(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCooperation/getDataModelCooperatorCandidates", payload)
+}
+
+export function getCooperators(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCooperation/getDataModelCooperators", payload)
+}
+
+export function setCooperators(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCooperation/setDataModelCooperators", payload)
+}
+
+//权限转移
+export function getOwner(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCooperation/getDataModelOwner", payload)
+}
+
+export function setOwner(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCooperation/setDataModelOwner", payload) 
+}
+
+//模型和元数据关联
+export function findAssociationMetadataByModelId(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerMetadataAssociation/findAssociationByModelId", payload)
+}
+
+export function getMatchMetadataTableById(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerCompareMetadata/getMatchMetadataTableById", payload)
+}
+
+export function getModelMetadataCompareResult(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerCompareMetadata/getModelMetadataCompareResult", payload)
+}
+
+export function getModelBranchNotice(payload) {
+  return GetJSON("/customDataModeler/easyDataModelerNotice/getModelBranchNotice", payload)
+}
+
+export function processConflictDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerNotice/processConflictDataModel", payload)
+}
+
+export function getMetadataTable(payload) {
+  return PostJSON("/baseservice/dataSecurityGrade/getTablePage", payload)
+}
+
+export function conceptualModelCreateDataModel(payload) {
+  return PostJSON("/customDataModeler/easyDataModelerConceptualModeling/populdateDataModel", payload)
+}
\ No newline at end of file

src/view/Manage/Manual/Component/ColSettingModal.jsx

@@ -29,7 +29,7 @@ const ColSettingModal = (props) => {
 
   const getPreference = () => {
     dispatch({
-      type: 'datamodel.getPreference',
+      type: 'manualdatamodel.getPreference',
       callback: data => {
         if ((data.cols||'') === '') {
           onCheckAllChange(true);
@@ -76,7 +76,7 @@ const ColSettingModal = (props) => {
   const onModalOk = () => {
     setConfirmLoading(true);
     dispatch({
-      type: 'datamodel.savePreference',
+      type: 'manualdatamodel.savePreference',
       payload: { 
         data: {
           cols: checkedKeys.join(',')

src/view/Manage/Manual/Component/EditInherited.jsx

@@ -40,7 +40,7 @@ const FC = (props) => {
 
   const getInheriteDataModel = (type) => {
     dispatch({
-      type: 'datamodel.inheriteDataModel',
+      type: 'manualdatamodel.inheriteDataModel',
       payload: {
         params: {
           id: modelerData.id,
@@ -80,7 +80,7 @@ const FC = (props) => {
 
       setConfirmLoading(true);
       dispatch({
-        type: 'datamodel.saveDataModel',
+        type: 'manualdatamodel.saveDataModel',
         payload: { 
           data: newModelerData
         },

src/view/Manage/Manual/Component/EditModel.jsx

@@ -139,13 +139,13 @@ const EditModel = (props) => {
 
   const heartbeat = () => {
     dispatchLatest({
-      type: 'datamodel.heartbeat'
+      type: 'manualdatamodel.heartbeat'
     });
   }
 
   const getModelPrivilege = () => {
     dispatch({
-      type: 'datamodel.getModelPrivilege',
+      type: 'manualdatamodel.getModelPrivilege',
       payload: {
         easyDataModelerDataModelId: modelerId,
       },
@@ -158,7 +158,7 @@ const EditModel = (props) => {
   const getApprovalDetail = () => {
     setLoadingApprovalData(true)
     dispatch({
-      type: 'datamodel.getPhysicalModelApproval',
+      type: 'manualdatamodel.getPhysicalModelApproval',
       payload: {
         id: approvalId,
       },
@@ -241,14 +241,14 @@ const EditModel = (props) => {
 
       setConfirmLoading(true);
       dispatchLatest({
-        type: 'datamodel.saveDataModel',
+        type: 'manualdatamodel.saveDataModel',
         payload: { 
           data: newModelerData
         },
         callback: data => {
           if (action === 'add') {
             dispatchLatest({
-              type: 'datamodel.bindCatalogDataModel',
+              type: 'manualdatamodel.bindCatalogDataModel',
               payload: { 
                 params: {
                   easyDataModelCatalogId: ((cid||'')!=='')?cid:catalogId,
@@ -316,7 +316,7 @@ const EditModel = (props) => {
 
   const manualSaveNoticeMessage = (id) => {
     dispatch({
-      type: 'datamodel.manualSaveNoticeMessage',
+      type: 'manualdatamodel.manualSaveNoticeMessage',
       payload: { 
         easyDataModelerDataModelId: id
       },
@@ -326,7 +326,7 @@ const EditModel = (props) => {
 
   const processConflictDataModel = () => {
     dispatch({
-      type: 'datamodel.processConflictDataModel',
+      type: 'manualdatamodel.processConflictDataModel',
       payload: { 
         params: {
           conflictItemId
@@ -373,7 +373,7 @@ const EditModel = (props) => {
       content: '您确定要删除该模型吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteDataModel',
+          type: 'manualdatamodel.deleteDataModel',
           payload: {
             params: {
               id: modelerId
@@ -435,7 +435,7 @@ const EditModel = (props) => {
       onOk: () => {
         setConfirmLoading(true);
         dispatch({
-          type: 'datamodel.dataModelRollback',
+          type: 'manualdatamodel.dataModelRollback',
           payload: { 
             params: {
               id: modelerId,
@@ -892,7 +892,7 @@ const PhysicalModelApprovalBottom = ({ loading, type, data, modelerData, id, tas
     
     setWaiting(true);
     dispatch({
-      type: 'datamodel.updatePhysicalModelApproval',
+      type: 'manualdatamodel.updatePhysicalModelApproval',
       payload: {
         params: {
           taskId,

src/view/Manage/Manual/Component/ExpandedModelTable.jsx

@@ -199,7 +199,7 @@ const ExpandedModelTable = (props) => {
 
   const getCheckoutDataModel = () => {
     dispatch({
-      type: 'datamodel.getCheckoutDataModel',
+      type: 'manualdatamodel.getCheckoutDataModel',
       payload: {
         id: pid
       },

src/view/Manage/Manual/Component/ExportDDLModal.jsx

@@ -58,7 +58,7 @@ class ExportDDLModal extends React.Component {
   getDDLGenerators = (needDB = false) => {
     this.setState({ loadingDDLGenerators: true }, () => {
       dispatch({
-        type: 'datamodel.ddlGenerators',
+        type: 'manualdatamodel.ddlGenerators',
         callback: data => {
           this.setState({ ddlGenerators: data, loadingDDLGenerators: false, selectDDLGeneratorName: (data||[]).length>0?data[0].name:'' }, () => {
             if (needDB) {
@@ -81,7 +81,7 @@ class ExportDDLModal extends React.Component {
 
     this.setState({ loadingDatabases: true }, () => {
       dispatch({
-        type: 'datamodel.getDatasourcesByEnv',
+        type: 'manualdatamodel.getDatasourcesByEnv',
         payload: {
           catalog: env?.value,
           model: 'Catalog,Database'
@@ -114,7 +114,7 @@ class ExportDDLModal extends React.Component {
   getSchemas = (dbId) => {
     this.setState({ loadingSchemas: true }, () => {
       dispatch({
-        type: 'datamodel.getSchemasByDatasourceId',
+        type: 'manualdatamodel.getSchemasByDatasourceId',
         payload: {
           parentId: dbId||''
         },
@@ -155,7 +155,7 @@ class ExportDDLModal extends React.Component {
 
     this.setState({ confirmLoading: true }, () => {
       dispatch({
-        type: 'datamodel.exportDDLString',
+        type: 'manualdatamodel.exportDDLString',
         payload: {
           ids: ids.join(','),
           ddlGeneratorName: selectDDLGeneratorName
@@ -207,7 +207,7 @@ class ExportDDLModal extends React.Component {
 
     this.setState({ confirmLoading: true }, () => {
       dispatch({
-        type: 'datamodel.autoCreateTable',
+        type: 'manualdatamodel.autoCreateTable',
         payload: {
           params: {
             namespace,

src/view/Manage/Manual/Component/ImportAction.jsx

@@ -72,7 +72,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
     setLoading(true);
     dispatch({
-      type: 'datamodel.getAllConstraints',
+      type: 'manualdatamodel.getAllConstraints',
       callback: data => {
         setConstraints(data);
         if (action === 'add') {
@@ -124,7 +124,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
       setLoading(true);
       dispatch({
-        type: 'datamodel.getAllConstraints',
+        type: 'manualdatamodel.getAllConstraints',
         callback: data => {
           setConstraints(data);
           getCurrentDataModel();
@@ -181,7 +181,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getTemplates = () => {
     dispatch({
-      type: 'datamodel.getAllTemplates',
+      type: 'manualdatamodel.getAllTemplates',
       payload: {
         constraintName: constraint.name
       },
@@ -193,7 +193,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const conceptualModelCreateDataModel = () => { 
     dispatch({
-      type: 'datamodel.conceptualModelCreateDataModel',
+      type: 'manualdatamodel.conceptualModelCreateDataModel',
       payload: {
         data: [logicId]  
       },
@@ -211,7 +211,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getDraft = (_constraint, _template, _hints) => { 
     dispatch({
-      type: 'datamodel.getDraft',
+      type: 'manualdatamodel.getDraft',
       payload: {
         params: {
           dataCatalogId: catalogId,
@@ -235,7 +235,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getDraftUsingDDL = (_constraint, _template, _ddl) => { 
     dispatch({
-      type: 'datamodel.getDraftUsingDDL',
+      type: 'manualdatamodel.getDraftUsingDDL',
       payload: {
         params: {
           branchId
@@ -258,7 +258,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getConsult = (data) => {
     dispatch({
-      type: 'datamodel.getConsult',
+      type: 'manualdatamodel.getConsult',
       payload: {
         data  
       },
@@ -290,19 +290,19 @@ const ImportAction = React.forwardRef((props, ref) => {
       return 
     }
 
-    let type = 'datamodel.getDataModel';
+    let type = 'manualdatamodel.getDataModel';
 
     let params = { id: modelerId };
 
     if (action === 'add') {
-      type = 'datamodel.modelCopy';
+      type = 'manualdatamodel.modelCopy';
     } else if (action === 'flow') {
-      type = 'datamodel.getDataModelWithRecommendedDefinitionAndTermDiscovery';
+      type = 'manualdatamodel.getDataModelWithRecommendedDefinitionAndTermDiscovery';
       if (approvalModelId) {
         params = { id: approvalModelId }
       }
     } else if (action === 'detail-version') {
-      type = 'datamodel.getDataModelByVersionId';
+      type = 'manualdatamodel.getDataModelByVersionId';
       params = {
         params: {
           id: modelerId||'',
@@ -310,9 +310,9 @@ const ImportAction = React.forwardRef((props, ref) => {
         }
       }
     } else if (action==='edit' && permitCheckOut) {
-      type = 'datamodel.checkOutDataModel';
+      type = 'manualdatamodel.checkOutDataModel';
     } else if (action === 'edit' && mergeId) {
-      type = 'datamodel.mergeBranch';
+      type = 'manualdatamodel.mergeBranch';
       params = {
         params: {
           current: modelerId,
@@ -329,13 +329,13 @@ const ImportAction = React.forwardRef((props, ref) => {
     } else if (action === 'detail') {
       if (noticeModelerId) {
         if (noticeModelerLatestVersionId) {
-          type = 'datamodel.getNoticeDataModelByVersionId'
+          type = 'manualdatamodel.getNoticeDataModelByVersionId'
           params = {
             easyDataModelerDataModelId: noticeModelerId,
             operationDataModelLatestVersionId: noticeModelerLatestVersionId
           }
         } else {
-          type = 'datamodel.getNoticeDataModelById'
+          type = 'manualdatamodel.getNoticeDataModelById'
           params = {
             easyDataModelerDataModelId: noticeModelerId,
           }
@@ -435,7 +435,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getSupportedDatatypes = () => {
     dispatch({
-      type: 'datamodel.getSupportedDatatypes',
+      type: 'manualdatamodel.getSupportedDatatypes',
       callback: data => {
         setSupportedDatatypes(data||[]);
       }
@@ -444,7 +444,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getSupportedPartitionTypes = () => {
     dispatch({
-      type: 'datamodel.getSupportedPartitionTypes',
+      type: 'manualdatamodel.getSupportedPartitionTypes',
       payload: {
         excludeBuiltin: false
       },
@@ -456,7 +456,7 @@ const ImportAction = React.forwardRef((props, ref) => {
 
   const getSupportedIndextypes = () => {
     dispatch({
-      type: 'datamodel.getSupportedIndextypes',
+      type: 'manualdatamodel.getSupportedIndextypes',
       callback: data => {
         setSupportedIndextypes(data||[]);
       }
@@ -551,7 +551,7 @@ const ImportAction = React.forwardRef((props, ref) => {
     const row = form?.getFieldsValue();
 
     dispatch({
-      type: 'datamodel.validateDataModel',
+      type: 'manualdatamodel.validateDataModel',
       payload: {
         data: (action==='detail'||action==='flow'||action==='detail-version')?data:{ ...data, ...{ name: row?.name||'', cnName: row?.cnName||'' } },
       },

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

@@ -38,7 +38,7 @@ const FC = (props) => {
 
   const getComments = () => {
     dispatch({
-      type: 'datamodel.getComments',
+      type: 'manualdatamodel.getComments',
       payload: {
         modelId: modelerData?.id
       },
@@ -55,7 +55,7 @@ const FC = (props) => {
     }
 
     dispatch({
-      type: 'datamodel.addComment',
+      type: 'manualdatamodel.addComment',
       payload: {
         data: {
           fileList,
@@ -78,7 +78,7 @@ const FC = (props) => {
       content: '确定删除该评论嘛?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteComment',
+          type: 'manualdatamodel.deleteComment',
           payload: { 
             id: item?.id
           },
@@ -106,7 +106,7 @@ const FC = (props) => {
 
       setUploading(true)
       dispatch({
-        type: 'datamodel.uploadCommentFile',
+        type: 'manualdatamodel.uploadCommentFile',
         payload: {
           fileList: [file]
         },
@@ -219,7 +219,7 @@ const AttachesItem = ({ value, onChange, readOnly }) => {
                     type='danger'
                     onClick={() => {
                       dispatch({
-                        type: 'datamodel.deleteCommentFile',
+                        type: 'manualdatamodel.deleteCommentFile',
                         payload: {
                           id: item?.id
                         },

src/view/Manage/Manual/Component/ImportActionHeader.jsx

@@ -188,7 +188,7 @@ const ImportActionHeader = (props) => {
 
   const getDataTypeList = () => {
     dispatch({
-      type: 'datamodel.dataTypeList',
+      type: 'manualdatamodel.dataTypeList',
       callback: data => {
         setDataTypeList(data);
       }
@@ -197,7 +197,7 @@ const ImportActionHeader = (props) => {
 
   const getBindingLoadRangeList = (dataTypeName) => {
     dispatch({
-      type: 'datamodel.bindingLoadRangeList',
+      type: 'manualdatamodel.bindingLoadRangeList',
       payload: {
         dataTypeName
       },
@@ -232,7 +232,7 @@ const ImportActionHeader = (props) => {
     const _searchText = searchText.replace(/ /g,'');
     if (_searchText !== '') {
       dispatchLatest({
-        type: 'datamodel.autocomplete',
+        type: 'manualdatamodel.autocomplete',
         payload: {
           params: {
             word: _searchText,
@@ -250,7 +250,7 @@ const ImportActionHeader = (props) => {
       })
     } else {
       dispatchLatest({
-        type: 'datamodel.recommandEnglishWords',
+        type: 'manualdatamodel.recommandEnglishWords',
         payload: {
           params: {
             chineseWord: modelerData.cnName,
@@ -279,7 +279,7 @@ const ImportActionHeader = (props) => {
     } else if (changedValues.hasOwnProperty('cnName')) {
       if (autoTranslate) {
         dispatchLatest({
-          type: 'datamodel.translatePhase',
+          type: 'manualdatamodel.translatePhase',
           payload: {
             params: {
               phaseInChinese: changedValues.cnName,
@@ -885,7 +885,7 @@ const ItemTitle = ({ name, cnName, validateReports }) => {
   return (
     <Space size={2}>
       {cnName}
-      <ValidateTip validateReports={validateReports} type='DataModel' propertyName={name} />
+      <ValidateTip validateReports={validateReports} type='manualdatamodel' propertyName={name} />
     </Space>
   )
 }

src/view/Manage/Manual/Component/ImportActionManage.jsx

@@ -60,7 +60,7 @@ const FC = (props) => {
 
   const getMaintenanceRecords = () => {
     dispatch({
-      type: 'datamodel.getMaintenanceRecords',
+      type: 'manualdatamodel.getMaintenanceRecords',
       payload: {
         id: modelerData?.id
       },
@@ -175,7 +175,7 @@ const UsersItem = ({ value, onChange }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperationUsers',
+      type: 'manualdatamodel.getCooperationUsers',
       payload: {
         match: searchValue,
       },

src/view/Manage/Manual/Component/ImportActionRelation.jsx

@@ -65,7 +65,7 @@ const FC = (props) => {
 
   const getAssociationMetadata = () => {
     dispatch({
-      type: 'datamodel.findAssociationMetadataByModelId',
+      type: 'manualdatamodel.findAssociationMetadataByModelId',
       payload: {
         easyDataModelerDataModelId: modelerData?.id,
       },

src/view/Manage/Manual/Component/ImportActionTable.jsx

@@ -671,7 +671,7 @@ export const ImportActionTable = (props) => {
     if (type === 'template') return 
     
     dispatch({
-      type: 'datamodel.getDataModelStandardMapping',
+      type: 'manualdatamodel.getDataModelStandardMapping',
       payload: { 
         easyDataModelerDataModelId: modelerData?.id
       },
@@ -851,7 +851,7 @@ export const ImportActionTable = (props) => {
 
   const preSaveDataModel = (attribute) => {
     dispatch({
-      type: 'datamodel.preSaveDataModel',
+      type: 'manualdatamodel.preSaveDataModel',
       payload: { 
         data: attribute
       },
@@ -949,7 +949,7 @@ export const ImportActionTable = (props) => {
     if (changedValues.hasOwnProperty('cnName')) {
       if (autoTranslateRef.current) {
         dispatchLatest({
-          type: 'datamodel.translatePhase',
+          type: 'manualdatamodel.translatePhase',
           payload: {
             params: {
               phaseInChinese: changedValues.cnName,

src/view/Manage/Manual/Component/ImportExcel.jsx

@@ -19,7 +19,7 @@ class ImportExcel extends React.Component {
   }
 
   downloadTemplate = () => {
-    window.open("/data-govern-bj/docs/DataModel.xlsx");
+    window.open("/data-govern-bj/docs/manualdatamodel.xlsx");
   }
 
   normFile = (e) => {  

src/view/Manage/Manual/Component/ImportMetadata.jsx

@@ -53,7 +53,7 @@ class ImportMetadata extends React.Component {
 
     this.setState({ loadingSystem: true, loadingDb: true }, () => {
       dispatchLatest({
-        type: 'datamodel.getAllSystemAndDatabase',
+        type: 'manualdatamodel.getAllSystemAndDatabase',
         callback: data => {
           if (data && data.systems && data.systems.length) {
             const _system = data.systems[0].scopeId;
@@ -85,7 +85,7 @@ class ImportMetadata extends React.Component {
       
       this.setState({ loadingDb: true, system: value }, () => {
         dispatchLatest({
-          type: "datamodel.getAllSystemDatabase",
+          type: "manualdatamodel.getAllSystemDatabase",
           payload: {
             sysCodedataTables: value
           },
@@ -112,7 +112,7 @@ class ImportMetadata extends React.Component {
       
       this.setState({ loadingSchema: true, db: value }, () => {
         dispatchLatest({
-          type: "datamodel.getAllScheme",
+          type: "manualdatamodel.getAllScheme",
           payload: {
             db: value
           },
@@ -155,7 +155,7 @@ class ImportMetadata extends React.Component {
 
     this.setState({ loadingDataTable: true }, () => {
       dispatchLatest({
-        type: "datamodel.getAllDataTable",
+        type: "manualdatamodel.getAllDataTable",
         payload: {
           pageNum: pageNumDataTables,
           pageSize: pageSizeDataTables,
@@ -184,7 +184,7 @@ class ImportMetadata extends React.Component {
 
         this.setState({ selectedDataTableRowKeys: selectedRowKeys, loadingDataFiled: true }, () => {
           dispatchLatest({
-            type: "datamodel.getAllFileds",
+            type: "manualdatamodel.getAllFileds",
             payload: {
               parentId: selectedRowKeys[0],
               model:'Column,InterfaceColumn,HanaViewColumn'

src/view/Manage/Manual/Component/ImportModal.jsx

@@ -40,7 +40,7 @@ const ImportModal = (props) => {
   
         setConfirmLoading(true);
         dispatchLatest({
-          type: 'datamodel.importWordGenerateModelDraft',
+          type: 'manualdatamodel.importWordGenerateModelDraft',
           payload: { 
             params: {
               catalogId,
@@ -62,7 +62,7 @@ const ImportModal = (props) => {
   
         setConfirmLoading(true);
         dispatchLatest({
-          type: 'datamodel.extractExcelContent',
+          type: 'manualdatamodel.extractExcelContent',
           payload: { fileList: row.upload },
           callback: data => {
             setConfirmLoading(false);

src/view/Manage/Manual/Component/ImportStockWordDrawer.jsx

@@ -130,7 +130,7 @@ const ImportStockWordModal = (props) => {
   const getLogs = (p = 1, s = 20) => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.importWordLogs',
+      type: 'manualdatamodel.importWordLogs',
       payload: {
         params: {
           page: p,
@@ -179,7 +179,7 @@ const ImportStockWordModal = (props) => {
 
     setConfirmLoading(true);
     dispatchLatest({
-      type: 'datamodel.importWordGenerateModel',
+      type: 'manualdatamodel.importWordGenerateModel',
       payload: {
         params: {
           catalogId,

src/view/Manage/Manual/Component/ModelTable.jsx

@@ -129,7 +129,7 @@ export const ModelNameColumn = (props) => {
       onVisibleChange={(visible) => {
         if (visible && !record.digest) {
           dispatch({
-            type: 'datamodel.getDataModelDigest',
+            type: 'manualdatamodel.getDataModelDigest',
             payload: {
               id: record.id
             },
@@ -471,7 +471,7 @@ const ModelTable = (props) => {
 
   const getBehindAlarmInBranch = () => {
     dispatch({
-      type: 'datamodel.behindAlarmInBranch',
+      type: 'manualdatamodel.behindAlarmInBranch',
       payload: {
         id: catalogId,
       },
@@ -526,7 +526,7 @@ const ModelTable = (props) => {
       content: `您确定要${action.cnName||''}该模型吗?`,
       onOk: () => {
         dispatch({
-          type: 'datamodel.nextState',
+          type: 'manualdatamodel.nextState',
           payload: {
             easyDataModelerDataModelId: record.id,
             actionId: action.id
@@ -555,7 +555,7 @@ const ModelTable = (props) => {
       content: '您确定要删除该模型吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteDataModel',
+          type: 'manualdatamodel.deleteDataModel',
           payload: {
             params: {
               id: record.id
@@ -680,7 +680,7 @@ const ModelTable = (props) => {
       onAuthShare?.(currentItem)
     } else if (key === 'viewBaselineModel') {
       dispatch({
-        type: 'datamodel.getForkedModel',
+        type: 'manualdatamodel.getForkedModel',
         payload: {
           id: currentItem?.id
         },

src/view/Manage/Manual/Component/ModelTree.jsx

@@ -106,7 +106,7 @@ const ModelTree = (props) => {
 
   const getShowSyncAndDomains = () => {
     dispatch({
-      type: 'datamodel.isSetRootDomainId',
+      type: 'manualdatamodel.isSetRootDomainId',
       callback: data => {
         if (data === 'false') {
           dispatch({
@@ -125,7 +125,7 @@ const ModelTree = (props) => {
 
   const getCatalogAdmin = () => {
     dispatch({
-      type: 'datamodel.getCatalogAdmin',
+      type: 'manualdatamodel.getCatalogAdmin',
       callback: data => {
         setCatalogAdmin(data==='true'?true:false);
       }
@@ -134,7 +134,7 @@ const ModelTree = (props) => {
 
   const getPrivilegeBranchAdmin = () => {
     dispatch({
-      type: 'datamodel.getPrivilegeBranchAdmin',
+      type: 'manualdatamodel.getPrivilegeBranchAdmin',
       callback: data => {
         setBranchAdmin(data==='true'?true:false);
       }
@@ -144,7 +144,7 @@ const ModelTree = (props) => {
   const getDataModelLocationThenGetDirTreeData = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getDataModelLocation',
+      type: 'manualdatamodel.getDataModelLocation',
       payload: {
         id
       },
@@ -162,7 +162,7 @@ const ModelTree = (props) => {
 
     setLoading(true);
     dispatch({
-      type: (type==='refresh')?'datamodel.refreshDataModelCatalog':'datamodel.loadDataModelCatalog',
+      type: (type==='refresh')?'manualdatamodel.refreshDataModelCatalog':'manualdatamodel.loadDataModelCatalog',
       callback: data => {
 
         data.key = data.id||'';
@@ -240,7 +240,7 @@ const ModelTree = (props) => {
   const getStateTreeData = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.loadDataModelStateCatalog',
+      type: 'manualdatamodel.loadDataModelStateCatalog',
       callback: data => {
         setLoading(false);
         let _treeData = data?.subCatalogs||[];
@@ -263,7 +263,7 @@ const ModelTree = (props) => {
   const getRootThenGetBranchTreeData = () => {
     setLoadingRoot(true)
     dispatch({
-      type: 'datamodel.refreshDataModelCatalog',
+      type: 'manualdatamodel.refreshDataModelCatalog',
       callback: data => {
         setLoadingRoot(false)
         setRootNode?.(data)
@@ -278,7 +278,7 @@ const ModelTree = (props) => {
   const getBranchTreeData = (defaultSelectedId) => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getAllBranches',
+      type: 'manualdatamodel.getAllBranches',
       callback: data => {
         setLoading(false);
         const newData = produce(data??[], (draft) => {
@@ -374,7 +374,7 @@ const ModelTree = (props) => {
 
     setDomainSelectedKey(key);
     dispatch({
-      type: 'datamodel.setRootDomainId',
+      type: 'manualdatamodel.setRootDomainId',
       payload: {
         params: {
           domainId: key
@@ -428,7 +428,7 @@ const ModelTree = (props) => {
     setLoading(true);
     if (viewSelectedKey === 'dir') {
       dispatch({
-        type: 'datamodel.upDownModelCatalog',
+        type: 'manualdatamodel.upDownModelCatalog',
         payload: {
           params: {
             modelCatalogId: currentRightClickDir.id,
@@ -445,7 +445,7 @@ const ModelTree = (props) => {
       });
     } else if (viewSelectedKey === 'branch') {
       dispatch({
-        type: 'datamodel.upDownBranch',
+        type: 'manualdatamodel.upDownBranch',
         payload: {
           params: {
             id: currentRightClickDir.id,
@@ -471,7 +471,7 @@ const ModelTree = (props) => {
         setLoading(true);
         if (viewSelectedKey === 'dir') {
           dispatch({
-            type: 'datamodel.deleteDataModelCatalog',
+            type: 'manualdatamodel.deleteDataModelCatalog',
             payload: {
               params: {
                 easyDataModelerCatalogId: currentRightClickDir.id
@@ -492,7 +492,7 @@ const ModelTree = (props) => {
           });
         } else if (viewSelectedKey === 'branch') {
           dispatch({
-            type: 'datamodel.deleteBranch',
+            type: 'manualdatamodel.deleteBranch',
             payload: {
               id: currentRightClickDir?.id,
             },

src/view/Manage/Manual/Component/RecatalogModal.jsx

@@ -23,7 +23,7 @@ const RecatalogModal = (props) => {
     
     setConfirmLoading(true);
     dispatch({
-      type: 'datamodel.recatalogDataModel',
+      type: 'manualdatamodel.recatalogDataModel',
       payload: {
         params: {
           easyDataModelCatalogId: catalogId,

src/view/Manage/Manual/Component/StartFlowModal.jsx

@@ -33,7 +33,7 @@ const StartFlowModal = (props) => {
         type: 'user.fetchSessionInfo',
         callback: session => {
           dispatchLatest({
-            type: 'datamodel.startFlow',
+            type: 'manualdatamodel.startFlow',
             payload: {
               params: {
                 user: session?.userName,

src/view/Manage/Manual/Component/UpdateTreeItemModal.jsx

@@ -138,7 +138,7 @@ const UpdateTreeItemModal = (props) => {
       }
 
       dispatchLatest({
-        type: 'datamodel.saveDataModelCatalog',
+        type: 'manualdatamodel.saveDataModelCatalog',
         payload: {
           data: payload
         },

src/view/Manage/Manual/Component/VersionCompare.jsx

@@ -65,7 +65,7 @@ const VersionCompare = (props) => {
   const getVersions = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getVersions',
+      type: 'manualdatamodel.getVersions',
       payload: {
         params: {
           id
@@ -135,7 +135,7 @@ const VersionCompare = (props) => {
   const getCompare = (value1=basicVersion, value2=incVersion, value3=onlyShowChange) => {
     setLoadingCompare(true);
     dispatchLatest({
-      type: 'datamodel.compare',
+      type: 'manualdatamodel.compare',
       payload: {
         params: {
           id,

src/view/Manage/Manual/Component/VersionHistory.jsx

@@ -22,7 +22,7 @@ const VersionHistory = (props) => {
   const getVersions = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getVersions',
+      type: 'manualdatamodel.getVersions',
       payload: {
         params: {
           id

src/view/Manage/Manual/Component/approval-tip.jsx

@@ -23,7 +23,7 @@ const FC = (props) => {
 
   const getTip = () => {
     dispatch({
-      type: 'datamodel.getPhysicalModelApprovalTip',
+      type: 'manualdatamodel.getPhysicalModelApprovalTip',
       payload: {
         type
       },

src/view/Manage/Manual/Component/auth-share.jsx

@@ -23,7 +23,7 @@ const FC = (props) => {
   const getCooperators = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperators',
+      type: 'manualdatamodel.getCooperators',
       payload: {
         id: item?.id
       },
@@ -50,7 +50,7 @@ const FC = (props) => {
 
       setWaiting(true)
       dispatch({
-        type: 'datamodel.setCooperators',
+        type: 'manualdatamodel.setCooperators',
         payload: {
           params: {
             id: item?.id,
@@ -151,7 +151,7 @@ const UsersItem = ({ modelId, value, onChange, readonly = false }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperatorCandidates',
+      type: 'manualdatamodel.getCooperatorCandidates',
       payload: {
         id: modelId,
         match: searchValue,

src/view/Manage/Manual/Component/auth-transfer.jsx

@@ -23,7 +23,7 @@ const FC = (props) => {
   const getOwner = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getOwner',
+      type: 'manualdatamodel.getOwner',
       payload: {
         id: item?.id
       },
@@ -50,7 +50,7 @@ const FC = (props) => {
 
       setWaiting(true)
       dispatch({
-        type: 'datamodel.setOwner',
+        type: 'manualdatamodel.setOwner',
         payload: {
           params: {
             id: item?.id,
@@ -151,7 +151,7 @@ const UsersItem = ({ modelId, value, onChange }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperatorCandidates',
+      type: 'manualdatamodel.getCooperatorCandidates',
       payload: {
         id: modelId,
         match: searchValue,

src/view/Manage/Manual/Component/branch-add-model.jsx

@@ -74,7 +74,7 @@ const Basic = React.forwardRef(function ({}, ref) {
   const getTreeData = () => {
     setLoadingTreeData(true)
     dispatch({
-      type: 'datamodel.refreshDataModelCatalog',
+      type: 'manualdatamodel.refreshDataModelCatalog',
       callback: (data) => {
         setLoadingTreeData(false)
 

src/view/Manage/Manual/Component/branch-model-sync.jsx

@@ -20,7 +20,7 @@ const FC = (props) => {
   const save = () => {
     setWaiting(true)
     dispatch({
-      type: 'datamodel.getForkedModel',
+      type: 'manualdatamodel.getForkedModel',
       payload: {
         id: item?.id,
       },
@@ -87,7 +87,7 @@ const Basic = ({ item }) => {
   const getDiffForked = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getBranchDiffForked',
+      type: 'manualdatamodel.getBranchDiffForked',
       payload: {
         id: item?.id,
         includeSame: !onlyShowChange,

src/view/Manage/Manual/Component/branch-select-model.jsx

@@ -159,7 +159,7 @@ const Basic = React.forwardRef(function ({ items }, ref) {
     
     if (args.keyword) {
       dispatch({
-        type: 'datamodel.searchModel',
+        type: 'manualdatamodel.searchModel',
         payload: {
           term: args.keyword,
           catalogId: node?.id,
@@ -175,7 +175,7 @@ const Basic = React.forwardRef(function ({ items }, ref) {
       })
     } else {
       dispatch({
-        type: 'datamodel.getCurrentDataModelCatalog',
+        type: 'manualdatamodel.getCurrentDataModelCatalog',
         payload: {
           easyDataModelerCatalogId: node?.id,
         },

src/view/Manage/Manual/Component/export-ddl.jsx

@@ -54,7 +54,7 @@ const FC = (props) => {
   const onDownload = () => {
     setDownloading(true)
     dispatch({
-      type: 'datamodel.downloadExportTableDDLListZip',
+      type: 'manualdatamodel.downloadExportTableDDLListZip',
       payload: {
         data: basicRef.current.configs??[],
         headers: {
@@ -151,7 +151,7 @@ const Basic = React.forwardRef(function ({ ids }, ref) {
   const exportTableDDLAbstractList = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.exportTableDDLAbstractList',
+      type: 'manualdatamodel.exportTableDDLAbstractList',
       payload: {
         data: ids,
       },
@@ -168,7 +168,7 @@ const Basic = React.forwardRef(function ({ ids }, ref) {
   const getDDLGenerators = (needDB = false) => {
     setLoadingDDLGenerators(true)
     dispatch({
-      type: 'datamodel.ddlGenerators',
+      type: 'manualdatamodel.ddlGenerators',
       callback: data => {
         setLoadingDDLGenerators(false)
         setDDLGenerators(data)
@@ -308,7 +308,7 @@ const DDLDetail = ({ config, setConfig }) => {
     setLoadingVersions(true)
     setVersions()
     dispatch({
-      type: 'datamodel.getVersions',
+      type: 'manualdatamodel.getVersions',
       payload: {
         params: {
           id: config?.easyDataModelerDataModelId,
@@ -371,7 +371,7 @@ const DDLDetail = ({ config, setConfig }) => {
   const getDDL = () => {
     setLoadingDDL(true)
     dispatch({
-      type: 'datamodel.getExportTableDDL',
+      type: 'manualdatamodel.getExportTableDDL',
       payload: {
         data: config,
       },

src/view/Manage/Manual/Component/export-options.jsx

@@ -31,7 +31,7 @@ const FC = (props) => {
         setExportDDLParams({ visible: true })
       } if (modeKey === 'erwin') {
         dispatch({
-          type: 'datamodel.exportERWinString',
+          type: 'manualdatamodel.exportERWinString',
           payload: {
             ids: (ids??[]).toString(),
           },

src/view/Manage/Manual/Component/merge-to-master.jsx

@@ -20,7 +20,7 @@ const FC = (props) => {
   const save = () => {
     setWaiting(true)
     dispatch({
-      type: 'datamodel.joinBranch',
+      type: 'manualdatamodel.joinBranch',
       payload: {
         ids: (items??[]).map(item => item.id).toString(),
       },
@@ -130,7 +130,7 @@ export const Diff = ({ item }) => {
   const getDiffForked = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getBranchDiffForked',
+      type: 'manualdatamodel.getBranchDiffForked',
       payload: {
         id: item?.id,
         includeSame: !onlyShowChange,

src/view/Manage/Manual/Component/metadata-compare-select-metadata.jsx

@@ -179,7 +179,7 @@ const Basic = React.forwardRef(function ({}, ref) {
       params.keyword = args.keyword
     }
     dispatch({
-      type: 'datamodel.getMetadataTable',
+      type: 'manualdatamodel.getMetadataTable',
       payload: {
         params
       },

src/view/Manage/Manual/Component/metadata-compare.jsx

@@ -46,7 +46,7 @@ const Basic = ({ leftItem, rightItem }) => {
   const compare = () => {
     setLoadingResult(true)
     dispatch({
-      type: 'datamodel.getModelMetadataCompareResult',
+      type: 'manualdatamodel.getModelMetadataCompareResult',
       payload: {
         easyDataModelerDataModelId: rightItem?.id,
         metadataId: leftItem?.tableId,

src/view/Manage/Manual/Component/model-compare-select-model.jsx

@@ -186,7 +186,7 @@ const Basic = React.forwardRef(function ({}, ref) {
   const getDirModelsByCatalog = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCurrentDataModelCatalog',
+      type: 'manualdatamodel.getCurrentDataModelCatalog',
       payload: {
         easyDataModelerCatalogId: node?.id,
       },
@@ -203,7 +203,7 @@ const Basic = React.forwardRef(function ({}, ref) {
   const getStateModelsByCatalog = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCurrentDataModelStateCatalog',
+      type: 'manualdatamodel.getCurrentDataModelStateCatalog',
       payload: {
         easyDataModelerStateCatalogId: node?.id,
       },
@@ -220,7 +220,7 @@ const Basic = React.forwardRef(function ({}, ref) {
   const getBranchModelsByCatalog = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCurrentDataModelCatalog',
+      type: 'manualdatamodel.getCurrentDataModelCatalog',
       payload: {
         easyDataModelerCatalogId: rootNode?.id,
         branchId: node?.id,
@@ -247,7 +247,7 @@ const Basic = React.forwardRef(function ({}, ref) {
 
     setLoading(true)
     dispatch({
-      type: 'datamodel.searchModel',
+      type: 'manualdatamodel.searchModel',
       payload: params,
       callback: (data) => {
         setLoading(false)
@@ -400,7 +400,7 @@ export const ModelTree = ({ states, setStates, showTypeOptions = true, treeHeigh
   const getDirTreeData = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.refreshDataModelCatalog',
+      type: 'manualdatamodel.refreshDataModelCatalog',
       callback: (data) => {
         setLoading(false)
 
@@ -421,7 +421,7 @@ export const ModelTree = ({ states, setStates, showTypeOptions = true, treeHeigh
   const getStateTreeData = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.loadDataModelStateCatalog',
+      type: 'manualdatamodel.loadDataModelStateCatalog',
       callback: (data) => {
         setLoading(false)
 
@@ -442,7 +442,7 @@ export const ModelTree = ({ states, setStates, showTypeOptions = true, treeHeigh
   const getBranchTreeData = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getAllBranches',
+      type: 'manualdatamodel.getAllBranches',
       callback: (data) => {
         setLoading(false)
 

src/view/Manage/Manual/Component/model-compare.jsx

@@ -44,7 +44,7 @@ const Basic = ({ leftItem, rightItem }) => {
   const compareOtherModel = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.compareOtherModel',
+      type: 'manualdatamodel.compareOtherModel',
       payload: {
         params: {
           leftEasyDataModelerDataModelId: leftItem?.id,

src/view/Manage/Manual/Component/model-fork-detail.jsx

@@ -51,7 +51,7 @@ const FC = ({ visible, item, onCancel }) => {
   const getList = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getForkEasyDataModelerDataModelDistributions',
+      type: 'manualdatamodel.getForkEasyDataModelerDataModelDistributions',
       payload: {
         id: item?.id
       },

src/view/Manage/Manual/Component/select-search-properties.jsx

@@ -98,7 +98,7 @@ export const Basic = React.forwardRef(function ({}, ref) {
   const getProperties = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getSearchProperties',
+      type: 'manualdatamodel.getSearchProperties',
       callback: data => {
         setLoading(false)
         setProperties(data)

src/view/Manage/Manual/Component/start-flow.jsx

@@ -35,7 +35,7 @@ const FC = (props) => {
       console.log('table data', tableData)
       setWaiting(true)
       dispatch({
-        type: 'datamodel.addPhysicalModelApproval',
+        type: 'manualdatamodel.addPhysicalModelApproval',
         payload: {
           data: {
             ...basicRows,
@@ -123,7 +123,7 @@ const Basic = React.forwardRef(function ({}, ref) {
 
       setUploading(true)
       dispatch({
-        type: 'datamodel.approvalUploadFile',
+        type: 'manualdatamodel.approvalUploadFile',
         payload: {
           fileList: [file],
         },
@@ -232,7 +232,7 @@ const RuleReviewItem = ({ value = {}, onChange }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperationUsers',
+      type: 'manualdatamodel.getCooperationUsers',
       payload: {
         match: searchValue,
       },
@@ -415,7 +415,7 @@ const DesignUsersItem = ({ value, onChange }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperationUsers',
+      type: 'manualdatamodel.getCooperationUsers',
       payload: {
         match: searchValue,
       },
@@ -480,7 +480,7 @@ export const AttachesItem = ({ value, onChange, readOnly }) => {
                       type='danger'
                       onClick={() => {
                         dispatch({
-                          type: 'datamodel.approvalDeleteFile',
+                          type: 'manualdatamodel.approvalDeleteFile',
                           payload: {
                             id: item.id
                           },

src/view/Manage/Manual/Component/suggest.jsx

@@ -148,7 +148,7 @@ const FC = (props) => {
     const tempArray = (id??'').split('=');
     if (tempArray.length>=3) {
       dispatch({
-        type: 'datamodel.getParent',
+        type: 'manualdatamodel.getParent',
         payload: {
           id
         },
@@ -191,7 +191,7 @@ const FC = (props) => {
     }
 
     dispatch({
-      type: 'datamodel.getSuggestionPreference',
+      type: 'manualdatamodel.getSuggestionPreference',
       payload: params,
       callback: data => {
         setLoadingPreference(false)
@@ -206,7 +206,7 @@ const FC = (props) => {
   const getSuggests = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.suggest',
+      type: 'manualdatamodel.suggest',
       payload: {
         params: {
           name: args.name??'',

src/view/Manage/Manual/Component/update-branch.jsx

@@ -53,7 +53,7 @@ const FC = (props) => {
   const getBranch = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getBranch',
+      type: 'manualdatamodel.getBranch',
       payload: {
         id: item?.id,
       },
@@ -87,7 +87,7 @@ const FC = (props) => {
       setWaiting(true)
 
       dispatch({
-        type: 'datamodel.saveBranch',
+        type: 'manualdatamodel.saveBranch',
         payload: {
           data: (type==='add')?basicRows:{...branch, ...basicRows},
         },
@@ -269,7 +269,7 @@ const UsersItem = ({ value, onChange, readonly = false }) => {
   const getUsers = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getCooperationUsers',
+      type: 'manualdatamodel.getCooperationUsers',
       payload: {
         match: searchValue,
       },

src/view/Manage/Manual/Component/version-ddl-alter.jsx

@@ -61,7 +61,7 @@ export const Basic = React.forwardRef(function ({ id, versions, defaultBasicVers
   const getDDLGenerators = () => {
     setLoadingGenerators(true)
     dispatch({
-      type: 'datamodel.ddlGenerators',
+      type: 'manualdatamodel.ddlGenerators',
       callback: data => {
         setLoadingGenerators(false)
         setGenerators(data)
@@ -78,7 +78,7 @@ export const Basic = React.forwardRef(function ({ id, versions, defaultBasicVers
   const getDDL = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.ddlChangeString',
+      type: 'manualdatamodel.ddlChangeString',
       payload: {
         easyDataModelerDataModelId: id,
         leftVersionId: basicVersion,

src/view/Manage/Manual/index.jsx

@@ -205,7 +205,7 @@ class Model extends React.Component {
   getModelStates = () => {
     this.setState({ loadingStates: true }, () => {
       dispatch({
-        type: 'datamodel.loadDataModelStateCatalog',
+        type: 'manualdatamodel.loadDataModelStateCatalog',
         callback: data => {
           this.setState({
             loadingStates: false,
@@ -221,7 +221,7 @@ class Model extends React.Component {
 
   getPreference = () => {
     dispatch({
-      type: 'datamodel.getPreference',
+      type: 'manualdatamodel.getPreference',
       callback: data => {
         this.setState();
         if ((data.cols||'') === '') {
@@ -276,7 +276,7 @@ class Model extends React.Component {
         }
 
         dispatchLatestHomepage({
-          type: 'datamodel.searchModel',
+          type: 'manualdatamodel.searchModel',
           payload: params,
           callback: data => {
             let filterTableData = [...data||[]]
@@ -299,7 +299,7 @@ class Model extends React.Component {
         }
 
         dispatch({
-          type: 'datamodel.searchModelBySearchProperties',
+          type: 'manualdatamodel.searchModelBySearchProperties',
           payload: {
             params,
             data: searchProperties
@@ -314,7 +314,7 @@ class Model extends React.Component {
       } else {
         if (currentView === 'dir') {
           dispatchLatestHomepage({
-            type: 'datamodel.getCurrentDataModelCatalog',
+            type: 'manualdatamodel.getCurrentDataModelCatalog',
             payload: {
               easyDataModelerCatalogId: catalogId,
             },
@@ -327,7 +327,7 @@ class Model extends React.Component {
           })
         } else if (currentView === 'state') {
           dispatchLatestHomepage({
-            type: 'datamodel.getCurrentDataModelStateCatalog',
+            type: 'manualdatamodel.getCurrentDataModelStateCatalog',
             payload: {
               easyDataModelerStateCatalogId: catalogId
             },
@@ -347,7 +347,7 @@ class Model extends React.Component {
             params = {...params, stateId: currentModelState}
           }
           dispatchLatestHomepage({
-            type: 'datamodel.getCurrentDataModelCatalog',
+            type: 'manualdatamodel.getCurrentDataModelCatalog',
             payload: params,
             callback: data => {
               const filterTableData = [...data?.easyDataModelerDataModels||[]].filter(item => branchModelForkState===null || branchModelForkState===undefined || item.fork===branchModelForkState)
@@ -650,7 +650,7 @@ class Model extends React.Component {
     this.setState({ showDeleteTip: false });
     if (refresh) {
       dispatch({
-        type: 'datamodel.deleteDataModels',
+        type: 'manualdatamodel.deleteDataModels',
         payload: {
           params: {
             easyDataModelerDataModelIds: selectModelerIds.join(',')

src/view/Manage/ManualModelConfig/Component/ConstraintDetail.jsx

@@ -12,7 +12,7 @@ const ConstraintDetail = (props) => {
   useEffect(() => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getAllConstraints',
+      type: 'manualdatamodel.getAllConstraints',
       callback: data => {
         setLoading(false);
         const _rules = [];

src/view/Manage/ManualModelConfig/Component/EditTemplate.jsx

@@ -37,7 +37,7 @@ const EditTemplate = (props) => {
 
       setConfirmLoading(true);
       dispatchLatest({
-        type: 'datamodel.saveTemplate',
+        type: 'manualdatamodel.saveTemplate',
         payload: { 
           data: newTemplateData
         },

src/view/Manage/ManualModelConfig/Component/PartitionCURD.jsx

@@ -154,7 +154,7 @@ const PartitionCURD = (props) => {
   const getPartitions = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getSupportedPartitionTypes',
+      type: 'manualdatamodel.getSupportedPartitionTypes',
       payload: {
         excludeBuiltin: true
       },
@@ -178,7 +178,7 @@ const PartitionCURD = (props) => {
       content: '您确定要删除该分区吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deletePartitionType',
+          type: 'manualdatamodel.deletePartitionType',
           payload: {
             params: {
               id: record.id

src/view/Manage/ManualModelConfig/Component/TemplateAction.jsx

@@ -40,7 +40,7 @@ const TemplateAction = (props) => {
   const getCurrentTemplate = () => {
     setLoading(true);
     dispatchLatest({
-      type: 'datamodel.getTemplate',
+      type: 'manualdatamodel.getTemplate',
       payload: {
         params: {
           id 
@@ -69,7 +69,7 @@ const TemplateAction = (props) => {
   const getSupportedDatatypes = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getSupportedDatatypes',
+      type: 'manualdatamodel.getSupportedDatatypes',
       callback: data => {
         setLoading(false);
         setSupportedDatatypes(data||[]);

src/view/Manage/ManualModelConfig/Component/TemplateActionHeader.jsx

@@ -16,7 +16,7 @@ const TemplateActionHeader = (props) => {
 
   const getConstraints = () => {
     dispatch({
-      type: 'datamodel.getAllConstraints',
+      type: 'manualdatamodel.getAllConstraints',
       callback: data => {
         setConstraints(data);
       },

src/view/Manage/ManualModelConfig/Component/TemplateCURD.jsx

@@ -133,7 +133,7 @@ const TemplateCURD = (props) => {
 
   const getConstraints = () => {
     dispatch({
-      type: 'datamodel.getAllConstraints',
+      type: 'manualdatamodel.getAllConstraints',
       callback: data => {
         setConstraints(data);
       },
@@ -143,7 +143,7 @@ const TemplateCURD = (props) => {
   const getTemplates = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getAllTemplates',
+      type: 'manualdatamodel.getAllTemplates',
       payload: {
         constraintName: currentConstraint
       },
@@ -171,7 +171,7 @@ const TemplateCURD = (props) => {
       content: '您确定要删除该模版吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteTemplate',
+          type: 'manualdatamodel.deleteTemplate',
           payload: {
             params: {
               id: record.id

src/view/Manage/ManualModelConfig/Component/UpdatePartitionModal.jsx

@@ -45,7 +45,7 @@ const UpdatePartitionModal = (props) => {
       
       setConfirmLoading(true);
       dispatch({
-        type: 'datamodel.savePartitionType',
+        type: 'manualdatamodel.savePartitionType',
         payload: {
           data: newItem
         },

src/view/Manage/ManualModelConfig/Component/WordTemplate.jsx

@@ -55,7 +55,7 @@ const WordTemplate = (props) => {
 
       setConfirmLoading(true);
       dispatchLatest({
-        type: 'datamodel.uploadWordTemplate',
+        type: 'manualdatamodel.uploadWordTemplate',
         payload: { fileList: row.upload },
         callback: data => {
           setConfirmLoading(false);

src/view/Manage/ManualModelConfig/Component/add-rule.jsx

@@ -25,7 +25,7 @@ const FC = (props) => {
 
     setWaiting(true)
     dispatch({
-      type: 'datamodel.addRule',
+      type: 'manualdatamodel.addRule',
       payload: {
         params: {
           catalogId: node?.id,
@@ -164,7 +164,7 @@ export const Basic = React.forwardRef(function ({}, ref) {
   const getTemplates = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateList',
+      type: 'manualdatamodel.getRuleTemplateList',
       callback: data => {
         setLoading(false)
         setData(data)

src/view/Manage/ManualModelConfig/Component/review-tip-config.jsx

@@ -19,7 +19,7 @@ const FC = (props) => {
   const getTip = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getPhysicalModelApprovalTip',
+      type: 'manualdatamodel.getPhysicalModelApprovalTip',
       payload: {
         type: reviewState
       },
@@ -37,7 +37,7 @@ const FC = (props) => {
   const onSave = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.setPhysicalModelApprovalTip',
+      type: 'manualdatamodel.setPhysicalModelApprovalTip',
       payload: {
         params: {
           type: reviewState,

src/view/Manage/ManualModelConfig/Component/rule-catalog-compare.jsx

@@ -41,7 +41,7 @@ const FC = ({ item }) => {
   const getVersions = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleCatalogVersionList',
+      type: 'manualdatamodel.getRuleCatalogVersionList',
       payload: {
         catalogId: item?.id,
       },
@@ -76,7 +76,7 @@ const FC = ({ item }) => {
       setIncVersion(prevIncVersion => {
         setLoadingCompare(true)
         dispatch({
-          type: 'datamodel.compareRuleCatalogVersion',
+          type: 'manualdatamodel.compareRuleCatalogVersion',
           payload: {
             leftVersionId: prevBasicVersion,
             rightVersionId: prevIncVersion

src/view/Manage/ManualModelConfig/Component/rule-catalog-history.jsx

@@ -23,7 +23,7 @@ const FC = ({ item }) => {
   const getVersions = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getRuleCatalogVersionList',
+      type: 'manualdatamodel.getRuleCatalogVersionList',
       payload: {
         catalogId: item?.id,
       },

src/view/Manage/ManualModelConfig/Component/rule-list.jsx

@@ -212,7 +212,7 @@ const FC = (props) => {
   const getRules = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleList',
+      type: 'manualdatamodel.getRuleList',
       payload: {
         catalogId: node?.id,
       },
@@ -229,7 +229,7 @@ const FC = (props) => {
   const getStatus = () => {
     setLoadingStatus(true)
     dispatch({
-      type: 'datamodel.getRuleStatus',
+      type: 'manualdatamodel.getRuleStatus',
       callback: data => {
         setLoadingStatus(false)
         setStatus(data)
@@ -243,7 +243,7 @@ const FC = (props) => {
   const getAlertTypes = () => {
     setLoadingAlertTypes(true)
     dispatch({
-      type: 'datamodel.getRuleAlertTypes',
+      type: 'manualdatamodel.getRuleAlertTypes',
       callback: data => {
         setLoadingAlertTypes(false)
         setAlertTypes(data)
@@ -287,7 +287,7 @@ const FC = (props) => {
       content: '确定将选中的规则从规范中移除吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteRules',
+          type: 'manualdatamodel.deleteRules',
           payload: {
             ids: (selectedRows??[]).map(item => item.id).toString()
           },
@@ -307,7 +307,7 @@ const FC = (props) => {
       content: '确定将选中的规则从规范中移除吗?',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deleteRules',
+          type: 'manualdatamodel.deleteRules',
           payload: {
             ids: record?.id
           },

src/view/Manage/ManualModelConfig/Component/rule-template.jsx

@@ -146,7 +146,7 @@ const FC = (props) => {
   const getTemplates = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateList',
+      type: 'manualdatamodel.getRuleTemplateList',
       callback: data => {
         setLoading(false)
         setData(data)
@@ -171,7 +171,7 @@ const FC = (props) => {
       content: '删除规则，引用的规范将同步删除该规则，确定删除吗？',
       onOk: () => {
         dispatch({
-          type: 'datamodel.deletesRuleTemplate',
+          type: 'manualdatamodel.deletesRuleTemplate',
           payload: {
             templateIds: (selectedRows??[]).map(item => item.id).toString()
           },
@@ -187,7 +187,7 @@ const FC = (props) => {
 
   const onDeteteClick = (record) => {
     dispatch({
-      type: 'datamodel.getRuleTemplateReferenceRuleCatalogList',
+      type: 'manualdatamodel.getRuleTemplateReferenceRuleCatalogList',
       payload: {
         ruleTemplateId: record?.id
       },
@@ -206,7 +206,7 @@ const FC = (props) => {
           content: tip,
           onOk: () => {
             dispatch({
-              type: 'datamodel.deleteRuleTemplate',
+              type: 'manualdatamodel.deleteRuleTemplate',
               payload: {
                 templateId: record?.id
               },
@@ -324,7 +324,7 @@ const ReferenceCountTooltipTitle = ({ id, onClick }) => {
   const getReferenceRuleCatalogList = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateReferenceRuleCatalogList',
+      type: 'manualdatamodel.getRuleTemplateReferenceRuleCatalogList',
       payload: {
         ruleTemplateId: id
       },

src/view/Manage/ManualModelConfig/Component/rule-tree.jsx

@@ -52,7 +52,7 @@ const FC = (props) => {
   const getTreeData = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleCatalogList',
+      type: 'manualdatamodel.getRuleCatalogList',
       callback: data => {
         setLoading(false);
         setData(data)
@@ -103,7 +103,7 @@ const FC = (props) => {
         onOk: () => {
           setLoading(true);
           dispatch({
-            type: 'datamodel.deleteRuleCatalog',
+            type: 'manualdatamodel.deleteRuleCatalog',
             payload: {
               id: node?.id
             },
@@ -128,7 +128,7 @@ const FC = (props) => {
       })
     } else if (key === 'up') {
       dispatch({
-        type: 'datamodel.upRuleCatalog',
+        type: 'manualdatamodel.upRuleCatalog',
         payload: {
           params: {
             id: node?.id
@@ -140,7 +140,7 @@ const FC = (props) => {
       })
     } else if (key === 'down') {
       dispatch({
-        type: 'datamodel.downRuleCatalog',
+        type: 'manualdatamodel.downRuleCatalog',
         payload: {
           params: {
             id: node?.id

src/view/Manage/ManualModelConfig/Component/update-rule-catalog.jsx

@@ -27,7 +27,7 @@ const FC = (props) => {
       setWaiting(true)
       if (type === 'add') {
         dispatch({
-          type: 'datamodel.addRuleCatalog',
+          type: 'manualdatamodel.addRuleCatalog',
           payload: {
             data: rows
           },
@@ -40,7 +40,7 @@ const FC = (props) => {
         })
       } else {
         dispatch({
-          type: 'datamodel.updateRuleCatalog',
+          type: 'manualdatamodel.updateRuleCatalog',
           payload: {
             data: {...item, ...rows}
           },
@@ -116,7 +116,7 @@ export const Basic = React.forwardRef(function ({ type, item }, ref) {
   const getStatus = () => {
     setLoadingStatus(true)
     dispatch({
-      type: 'datamodel.getRuleCatalogStatus',
+      type: 'manualdatamodel.getRuleCatalogStatus',
       callback: (data) => {
         setLoadingStatus(false)
         setStatus(data)        

src/view/Manage/ManualModelConfig/Component/update-rule-template.jsx

@@ -29,7 +29,7 @@ const FC = (props) => {
   const getDetail = () => {
     setLoading(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateDetail',
+      type: 'manualdatamodel.getRuleTemplateDetail',
       payload: {
         ruleTemplateId: item?.id
       },
@@ -56,7 +56,7 @@ const FC = (props) => {
       setWaiting(true)
       if (type === 'add') {
         dispatch({
-          type: 'datamodel.addRuleTemplate',
+          type: 'manualdatamodel.addRuleTemplate',
           payload: {
             data: rows
           },
@@ -69,7 +69,7 @@ const FC = (props) => {
         })
       } else {
         dispatch({
-          type: 'datamodel.updateRuleTemplate',
+          type: 'manualdatamodel.updateRuleTemplate',
           payload: {
             data: {...item, preCheckProperty: null, ...rows}
           },
@@ -172,7 +172,7 @@ export const Basic = React.forwardRef(function ({ type, item }, ref) {
   const getCheckTypes = () => {
     setLoadingCheckTypes(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateCheckTypes',
+      type: 'manualdatamodel.getRuleTemplateCheckTypes',
       callback: (data) => {
         setLoadingCheckTypes(false)
         setCheckTypes(data)        
@@ -387,7 +387,7 @@ const CheckItem = ({ value, onChange, preCatalog }) => {
   const getCheckPropertyTypes = () => {
     setLoadingCheckPrpertyTypes(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateAllCheckPropertyTypes',
+      type: 'manualdatamodel.getRuleTemplateAllCheckPropertyTypes',
       callback: (data) => {
         setLoadingCheckPrpertyTypes(false)
         setCheckPropertyTypes(data)        
@@ -401,7 +401,7 @@ const CheckItem = ({ value, onChange, preCatalog }) => {
   const getExpressionTypes = () => {
     setLoadingExpressionTypes(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateAllVerifyExpressionTypes',
+      type: 'manualdatamodel.getRuleTemplateAllVerifyExpressionTypes',
       callback: (data) => {
         setLoadingExpressionTypes(false)
         setExpressionTypes(data)
@@ -415,7 +415,7 @@ const CheckItem = ({ value, onChange, preCatalog }) => {
   const getExpressions = () => {
     setLoadingExpressionMapping(true)
     dispatch({
-      type: 'datamodel.getRuleTemplateAllVertifyExpressions',
+      type: 'manualdatamodel.getRuleTemplateAllVertifyExpressions',
       callback: (data) => {
         setLoadingExpressionMapping(false)
         setExpressionMapping(data)

src/view/Manage/ManualModelConfig/Component/update-rule.jsx

@@ -18,7 +18,7 @@ const FC = (props) => {
       const rows = await basicRef.current?.validate()
       setWaiting(true)
       dispatch({
-        type: 'datamodel.updateRule',
+        type: 'manualdatamodel.updateRule',
         payload: {
           params: {id: item?.id, ...rows},
         },
@@ -91,7 +91,7 @@ export const Basic = React.forwardRef(function ({ type, item }, ref) {
   const getStatus = () => {
     setLoadingStatus(true)
     dispatch({
-      type: 'datamodel.getRuleStatus',
+      type: 'manualdatamodel.getRuleStatus',
       callback: data => {
         setLoadingStatus(false)
         setStatus(data)
@@ -105,7 +105,7 @@ export const Basic = React.forwardRef(function ({ type, item }, ref) {
   const getAlertTypes = () => {
     setLoadingAlertTypes(true)
     dispatch({
-      type: 'datamodel.getRuleAlertTypes',
+      type: 'manualdatamodel.getRuleAlertTypes',
       callback: data => {
         setLoadingAlertTypes(false)
         setAlertTypes(data)

src/view/Manage/ManualModelConfig/index.jsx

@@ -50,7 +50,7 @@ const ModelConfig = () => {
   const getPermissions = () => {
     setLoading(true);
     dispatch({
-      type: 'datamodel.getConfigPrivilege',
+      type: 'manualdatamodel.getConfigPrivilege',
       callback: data => {
         setLoading(false);
         setPermissions(data);