Skip to content

csbr-daop / fe-data-trusted-space

Go to a project
Toggle navigation
Toggle navigation pinning
8a799ac8 by lihua
Options

去掉无用的代码

1 parent fdb8c25b
Expand all
Inline Side-by-side
Showing 126 changed files with 19 additions and 4903 deletions
src/api/modules/dataAsset.ts
......@@ -462,21 +462,21 @@ export const saveDamContract = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-contract/save`,
method: 'post',
data: params
})
})
/** 更新合同 */
export const updateDamContract = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-contract/update`,
method: 'put',
data: params
})
})
/** 删除合同 */
export const delDamContract = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-contract/delete`,
method: 'delete',
data: params
})
})
/** 获取会员列表 */
export const getTenantList = (params) => request({
......@@ -569,4 +569,4 @@ export const getTransactionDetail = (params) => request({
// 获取所有字典
export const getDictAllList = () => request({
url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-all`
})
\ No newline at end of file
})
......
src/api/modules/dataAssetIndex.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取首页组织机构信息 */
export const getHomeServiceInfo = () => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/service-info`,
method: 'get',
})
/** 获取首页资产统计信息 */
export const getStatisticsInfo = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/statistics-info`,
method: 'post',
data
})
/** 获取首页资产登记情况 */
export const getRegisterInfo = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/register-info`,
method: 'post',
data: params
})
/** 获取首页资产质量情况 */
export const getQualityInfo = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/quality-info`,
method: 'post',
data
})
/** 获取首页资产交易情况 */
export const getDaTradeInfo = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/trade-info`,
method: 'post',
data: params
})
/** 获取资产融资情况 */
export const getFinanceInfo = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-financing/page-list`,
method: 'post',
data: params
})
/** 获取资产证件照url */
export const getRegisterUrl = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/company/list-doc-url`,
method: 'post',
data
})
/** 获取资产行业类型分布 */
export const getIndustryInfo = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/industry-statistics`,
method: 'post',
data
})
/** 获取平台授信主体金额分布 */
export const getCreditMoneyInfo = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/credit-money-statistics`,
method: 'post',
data
})
/** 获取平台资产统计信息 */
export const getPlatformStatisticsInfo = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/statistics-info`,
method: 'post',
data
})
/** 获取平台服务企业地区分布 */
export const getPlatformService = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/service-statistics`,
method: 'post',
data
})
/** 获取平台服务企业地区分布-按省 */
export const getPlatformProvinceService = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/service-statistics-province`,
method: 'post',
data
})
/** 获取平台数据资产登记趋势 */
export const getPlatformMonth = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/home/platform/register-month-statistics`,
method: 'post',
data
})
src/api/modules/dataAssetQuality.ts deleted 100644 → 0
/** --------------------- 质量评估模型 ------------------------------- */
import request from "@/utils/request";
/** 获取质量评估方案资产名称列表 */
export const getQualityDamList = () => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/dam-name-list`,
method: 'get'
})
/** 获取质量评估列表 */
export const getQualityList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/dam-list`,
method: 'post',
data: params
})
/** 获取可选择的资产目录列表 */
export const getDamList = () => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/dam-catalog-table/dam-name-list`,
method: 'post',
data: {}
})
/** 获取资产目录的表列表 */
export const getDamTableList = (damGuid) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/dam-catalog-table/get-table-list?damGuid=${damGuid}`,
method: 'get'
})
/** 获取资产目录表的详情 */
export const getTableFields = (subjectGuid) => request({
url:`${import.meta.env.VITE_API_ASSET_BASEURL}/dam-catalog-table/get-table-detail?subjectGuid=${subjectGuid}`,
method: 'get'
});
/** 获取资产表的规则列表 */
export const getDamTableRulesList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/rule-by-dam-guid`,
method: 'post',
data: params
})
/** 批量新增资产表的规则 */
export const saveDamTableRules = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/add`,
method: 'post',
data: params
})
/** 获取资产表的单个规则 */
export const getRuleConfDetail = (param) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/detail?ruleConfGuid=${param}`,
method: 'get'
})
/** 获取对应执行方案的规则详情 */
export const getRecordRuleConfDetail = (param) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-record/conf/detail?ruleConfGuid=${param.ruleConfGuid}&planExecGuid=${param.planExecGuid}`,
method: 'get'
});
/** 编辑资产表的单个规则 */
export const updateDamTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/update`,
method: 'post',
data: params
})
/** 删除资产表的单个规则 */
export const deleteDamTableRule = (ruleConfGuid, planGuid: any = null) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/del?ruleConfGuid=${ruleConfGuid}&planGuid=${planGuid}`,
method: 'delete'
})
// 获取规则类型的接口
export const getRuleTypeList = () => request({
url:`${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-rule/list`,
method: 'post',
data: {}
})
// 获取规则大类的接口
export const getLargeCategoryList = () => request({
url:`${import.meta.env.VITE_APP_API_BASEURL}/data-dict/get-data-list`,
method: 'post',
data: { paramCode: "LARGE-CATEGORY" }
})
// 获取规则小类的接口
export const getSmallCategoryList = () => request({
url:`${import.meta.env.VITE_APP_API_BASEURL}/data-dict/get-data-list`,
method: 'post',
data: { paramCode: "SMALL-CATEGORY" }
})
/** 表的逻辑条件和sql检验。 */
export const validateSubjectTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/sql-operate/check-sql`,
method: 'post',
data: params
})
/** 自定义sql检验 */
export const validateCustomSql = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/check-custom-sql`,
method: 'post',
data: params
})
/** 批量验证过滤条件 */
export const batchValidateSubjectTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/sql-operate/batch-check-sql`,
method: 'post',
data: params
})
/** ---------- 第二步，规则权重设置接口 ------ - */
/** 获取规则大类统计 */
export const getModelRuleCount = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-rule-category-count`,
method: 'post',
data: params
})
/** 保存质量评估方案 */
export const saveQualityPlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/add`,
method: 'post',
data: params
})
/** 更新质量方案 */
export const updateQualityPlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/update`,
method: 'put',
data: params
})
/** 删除质量方案 */
export const deleteQualityPlan = (guids) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/del`,
method: 'delete',
data: guids
})
/** 获取方案详情，用于编辑 */
export const getPlanDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/detail/${params}`,
method: 'get'
})
/** 获取方案详情中的过滤条件，用于编辑 */
export const getPlanFilterDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-plan-filter?planGuid=${params}`,
method: 'get'
})
/** 手动执行方案 */
export const executePlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/dam-exec-plan?planGuid=${params.planGuid}&reportGuid=${params.reportGuid}`,
method: 'post'
})
/** 获取方案查看详情列表数据。 */
export const getAssessDetailTableData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/page-exec-log-list`,
method: 'post',
data: params
})
/** 根据执行guid，获取方案执行详情。 */
export const getExecPlanDetailTableData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-exec-detail?&planExecGuid=${params.planExecGuid}`,
method: 'get'
})
/** 获取方案详情中每个表的规则详细执行列表数据。 */
export const getAssessTableRulesData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-exec-table-detail?planExecGuid=${params.planExecGuid}&qualityModelGuid=${params.qualityModelGuid}`,
method: 'get'
})
/** 下载脏数据 */
export const downloadDirtyData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/down-dirty-data`,
method: 'post',
data: params,
responseType: 'blob'
})
/** html转word接口 */
export const htmlToWord = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/download/html-to-word`,
method: 'postJsonD',
data: params,
responseType: 'blob'
});
/** 获取方案执行表规则查看 */
export const getTableRuleDetail= (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/query-exec-table-rule-detail?reportExecGuid=${params}`,
method: 'get'
});
/** 获取数据质量一级指标得分统计 */
export const getLargeCategoryScore = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/get-largeCategory-score?reportExecGuid=${params}`,
method: 'get'
});
/** 获取质量分析报告的详细内容，根绝报告guid。 */
export const getReportDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/get-report-data`,
method: 'post',
data: params
});
/** 获取方案执行明细 */
export const getPlanReportDetail= (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/query-exec-table-detail?reportExecGuid=${params.reportExecGuid}&planGuid=${params.planGuid}`,
method: 'get'
});
/** 下载sql语句执行 */
export const downPlanSql = (planGuid) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/down-plan-sql?planGuid=${planGuid}`,
method: 'post',
responseType: 'blob'
})
src/api/modules/dataAssetZq.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取登记详情 */
export const getRegiaterDetail = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/public-data-products-main/detail`,
method: 'get',
params
})
/** 获取产品登记详情 */
export const getRegisterCatalogDetail = (damGuid) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/public-data-products-main/detail-by-dam-guid?damGuid=${damGuid}`,
method: 'get'
})
/** 提交登记信息。 */
export const registerSave = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/public-data-products-main/save`,
method: 'post',
data: params
});
/** 更新登记信息 */
export const registerUpdate = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/public-data-products-main/update`,
method: 'post',
data: params
});
/** 删除登记信息 */
export const registerDelete = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/public-data-products-main/delete`,
method: 'delete',
data: params
});
/** 获取可使用的资产目录列表 */
export const getRegisterCatalogList = () => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/public-data/dam-list?isRegister=${'Y'}&foundMode=4`,
method: 'get'
})
src/api/modules/dataEntry.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取资产目录列表 */
export const getAssetCatalog = (params= {}) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/dam-list`,
method: 'get',
params
})
/** 获取成本项列表 */
export const getCostList = () => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/list`,
method: 'post',
})
/** 获取成本项详情 */
export const getCostDetail = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/detail`,
method: 'get',
params
})
/** 新增成本项信息 */
export const costSave = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/save`,
method: 'post',
data: params
});
/** 更新成本项信息 */
export const costUpdate = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/update`,
method: 'post',
data: params
});
/** 删除成本项信息 */
export const costDelete = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/delete`,
method: 'delete',
data: params
});
/** 发送入表咨询消息提醒 */
export const sendEntryMsg = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/tableentry-index-classify/send-message`,
method: 'post',
params
});
/** ----------------------------------------估值模型接口--------------------------------- */
/** 获取数据产品估值模型列表 */
export const getValuationModelList = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/valuation-model/page-list`,
method: 'post',
data: params
})
/** 保存估值模型 */
export const saveValuationMode = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/valuation-model/save`,
method: 'post',
data: params
})
/** 更新估值模型 */
export const updateValuationMode = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/valuation-model/update`,
method: 'put',
data: params
})
/** 删除估值模型 */
export const deleteValuationMode = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/valuation-model/delete`,
method: 'delete',
data: params
})
/** 获取估值模型详情 */
export const getValuationModelDetail = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/valuation-model/detail?guid=${params.guid}`,
method: 'get'
})
src/api/modules/dataFinance.ts deleted 100644 → 0
import request from "@/utils/request";
/**
* 流通撮合
**/
/** 获取已添加的数据产品列表 */
export const getMatchList = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/page-list`,
method: 'post',
data: params
})
/** 获取撮合详情 */
export const getMatchDetail = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/detail`,
method: 'get',
params
})
/** 新增撮合信息 */
export const matchSave = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/save`,
method: 'post',
data: params
});
/** 更新撮合信息 */
export const matchUpdate = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/update`,
method: 'post',
data: params
});
/** 删除撮合信息 */
export const matchDelete = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/delete`,
method: 'delete',
data: params
});
/** 获取撮合日志 */
export const getMatchLog = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/circulation-matching/state-change-log-list`,
method: 'get',
params
});
/**
* 金融产品
**/
/** 获取金融产品列表。 */
export const getFinancialList = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/page-list`,
method: 'post',
data: params
})
/** 获取金融产品详情 */
export const getFinancialDetail = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/detail`,
method: 'get',
params
})
/** 新增金融产品信息 */
export const financialSave = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/save`,
method: 'post',
data: params
});
/** 更新金融产品信息 */
export const financialUpdate = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/update`,
method: 'post',
data: params
});
/** 删除金融产品信息 */
export const financialDelete = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/delete`,
method: 'delete',
data: params
});
/** 更新金融产品上架状态 */
export const financialUpdateStatus = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/update-listing-Status`,
method: 'post',
data: params
});
/** 验证金融产品名称唯一性 */
export const checkFinancialName = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/financial-products/verify-data-name`,
method: 'get',
params
})
// 数据要素乘
export const orderStates = [{
value: 'N',
label: '待沟通'
}, {
value: 'I',
label: '沟通中'
}, {
value: 'R',
label: '达成意向'
}, {
value: 'C',
label: '合同拟定'
}, {
value: 'S',
label: '合同签署'
}, {
value: 'P',
label: '合同执行中'
}, {
value: 'Y',
label: '合同执行完'
}, {
value: 'D',
label: '撮合关闭'
}]
export const filterVal = (val, type) => {
if(type == 'orderState'){
const row = orderStates.filter(d => d.value == val);
return row.length?row[0].label:'--';
} else if(type == 'tenantNature'){
let approval = '--';
switch (val) {
case 1:
approval = '数据字典数据治理';
break;
case 2:
approval = '律师事务所';
break;
case 3:
approval = '会计师事务所';
break;
case 4:
approval = '金融机构';
break;
case 5:
approval = '资产评估机构';
break;
case 6:
approval = '申请数据资产化企业';
break;
case 7:
approval = '其他';
break;
default:
approval = '--';
break;
}
return approval;
}
}
export const filterStatus = (row, type) => {
let state = 'info'
if (type == 'orderState') {
switch (row[type]) {
case "N":
state = 'warning'
break;
case "I":
state = 'warning'
break;
case "R":
state = "warning"
break
case "C":
state = "warning"
break
case "S":
state = "primary"
break
case "P":
state = "primary"
break
case "Y":
state = 'success';
break;
case "D":
state = "info"
break
default:
state = "info"
break
}
}
return state;
}
src/api/modules/dataLabel.ts deleted 100644 → 0
import request from "@/utils/request";
/**
* 远程获取标签
* @param {Object}
* @path /cg-label/label-serach
* @method get
* @des query查询 label
*/
export const getLabelList = (data) => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/label-serach?label=${data.label}`,
method: 'get',
})
/**
* 分类分级树形目录
* @param {no params}
* @path /classify-grade/tree-list
* @method post
*/
export const getClassifyGradeTreeList = () => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/classify-grade/tree-list`,
method: 'post',
})
/**
* @des 新增标签规则
* @param {Object}
* @path /cg-label/save
*/
export const saveLabel = (data) => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/save`,
method: 'post',
data
})
/**
* @des 获取标签页规则列表
* @param {Object}
* @path /cg-label/page-list
*/
export const getLabelPageList = (data) => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/page-list`,
method: 'post',
data
})
/**
* @des 删除标签规则
* @param {Array}
* @path /cg-label/delete
*/
export const deleteLabel = (data) => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/delete`,
method: 'delete',
data
})
/**
* @des 标签规则修改
* @param {Object}
* @path /cg-label/update
*/
export const updateLabel = (data) => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/cg-label/update`,
method: 'post',
data
})
src/api/modules/dataPartners.ts deleted 100644 → 0
import request from "@/utils/request";
/** 校验公司名称是否重复 */
export const checkCompanyName = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/cooperate-register/verify-company-name`,
method: 'get',
params
})
/** 获取短信验证码 */
export const getRegisterCode = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/sms/get-verify-code`,
method: 'post',
params
})
/** 校验短信验证码 */
export const checkRegisterCode = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/sms/get-verify-code-validation`,
method: 'post',
params
})
/** 注册信息申请 */
export const registerInfoSave = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/cooperate/save`,
method: 'post',
data: params
});
/** 获取注册信息列表。 */
export const getRegisterInfoList = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/cooperate-register/page-list`,
method: 'post',
data: params
})
/** 获取注册信息详情 */
export const getRegiaterInfoDetail = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/cooperate-register/detail`,
method: 'get',
params
})
/** 更新注册信息 */
export const registerInfoUpdate = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/cooperate-register/update`,
method: 'post',
data: params
});
/** 删除注册信息 */
export const registerInfoDelete = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/cooperate-register/delete`,
method: 'delete',
data: params
});
/** 验证管理员账号是否重复 */
export const checkAccount = (params) => request({
url: `${import.meta.env.VITE_API_ASSET_BASEURL}/cooperate-register/verify-admin-account`,
method: 'get',
params
})
/** 获取登录日志 */
export const getAccountLog = (params) => request({
url: `${import.meta.env.VITE_APP_API_BASEURL}/user/user-login-record`,
method: 'post',
data: params
})
/** 获取图形验证码 **/
export const getImgCodeSrc = (params={}) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/get-captcha`,
method: 'get',
params
})
/** 校验图形验证码 **/
export const checkImgCode = (params={}) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/check`,
method: 'post',
params
})
src/api/modules/dataPricing.ts deleted 100644 → 0
import request from "@/utils/request";
//获取需求表树形列表
export const getDemandTreeList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-menu/page-list`,
method: "post",
data: params,
});
};
//获取所有需求表列表
export const getDemandAll = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-menu/get-list-data`,
method: "get",
params
});
};
//新增需求列表
export const saveDemandTree = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-menu/save`,
method: "post",
data: params,
});
};
//修改需求列表
export const updateDemandTree = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-menu/update`,
method: "post",
data: params,
});
};
// 删除需求列表
export const deleteDemandTree = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-menu/delete`,
method: "delete",
data: params,
});
};
//获取需求表
export const getDemandList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-table/page-list`,
method: "post",
data: params,
});
};
//获取需求表详情
export const getDemandDetail = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-table/detail`,
method: "get",
params,
});
};
//新增需求表
export const saveDemand = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-table/save`,
method: "post",
data: params,
});
};
//修改需求表
export const updateDemand = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-table/update`,
method: "post",
data: params,
});
};
// 删除需求表
export const deleteDemand = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-demand-table/delete`,
method: "delete",
data: params,
});
};
// 获取疾病列表
export const getDiseaseList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/page-list`,
method: "post",
data: params,
});
};
//获取所有疾病列表
export const getDiseaseAll = () => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/get-list-data`,
method: "post"
});
};
// 获取疾病详情
export const getDiseaseDetail = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/detail`,
method: "get",
params,
});
};
// 新增疾病
export const saveDisease = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/save`,
method: "post",
data: params,
});
};
// 修改疾病
export const updateDisease = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/update`,
method: "post",
data: params,
});
};
// 删除疾病
export const deleteDisease = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/disease-manage/delete`,
method: "delete",
data: params,
});
};
// 获取定价配置
export const getConfigureList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/page-list`,
method: "post",
data: params,
});
};
// 获取配置详情
export const getConfigureDetail = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/detail`,
method: "get",
params,
});
};
// 新增配置
export const saveConfigure = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/save`,
method: "post",
data: params,
});
};
// 修改配置
export const updateConfigure = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/update`,
method: "post",
data: params,
});
};
// 删除配置
export const deleteConfigure = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/delete`,
method: "delete",
data: params,
});
};
// 复制配置
export const addCopyConfigure = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-configure/copy`,
method: "post",
data: params,
});
};
// 获取数据定价
export const getPriceList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/page-list`,
method: "post",
data: params,
});
};
// 获取数据定价详情
export const getPriceDetail = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/detail`,
method: "get",
params,
});
};
// 新增数据定价
export const savePrice = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/save`,
method: "post",
data: params,
});
};
// 修改数据定价
export const updatePrice = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/update`,
method: "post",
data: params,
});
};
// 获取数据定价结果
export const getPriceResult = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/pricing-price`,
method: "post",
data: params,
});
};
// 计算数据定价
export const calculatPrice = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/calculate-price`,
method: "post",
data: params,
});
};
// 删除数据定价
export const deletePrice = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/delete`,
method: "delete",
data: params,
});
};
// 获取数据资源目录
export const getDamCatalogList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/get-table-select-new`,
method: "get",
params,
});
};
// 获取模型相关需求表
export const getModelDemand = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/pricing-model`,
method: "get",
params,
});
};
// 获取质量模型评分
export const getModelScore = (params) => {
return request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/get-quality-score-by-dam-guid-v2`,
method: "get",
params,
});
};
export const exportModelScore = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/pricing-data/download-template`,
method: "post",
data: params,
responseType: 'blob'
});
};
src/api/modules/dataQuality.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取质量模型对应的所有分组表格数据 */
export const getQualityTreeData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/quality-model-tree` + (params ? `?guid=${params}` : ''),
method: 'get'
})
/** 获取数据源下，对应分组的表数据 */
export const getQualityTreeDataByDs = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/quality-model-tree?guid=${params.guid}&dataSourceGuid=${params.dataSourceGuid}`,
method: 'get'
})
/** 获取质量模型对应的所有分组表格分页数据 */
export const getQualityGroupData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/page-list`,
method: 'post',
data: params
})
/** 删除质量模型的指定分组。 */
export const deleteGroup = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/del`,
method: 'delete',
data: params
})
/** 添加分组 */
export const addQualityGroup = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/add`,
method: 'post',
data: params
})
/** 修改分组 */
export const updateQualityGroup = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/update`,
method: 'put',
data: params
})
/** 获取质量分组对应的表格分页数据 */
export const getQualityTable = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/page-list`,
method: 'post',
data: params
})
/** 删除质检表 */
export const deleteQualityTable = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/del`,
method: 'delete',
data: params
})
/** 获取质量表对应的所有规则数据 */
export const getQualityTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-rule`,
method: 'post',
data: params
})
/** 删除质检表规则 */
export const deleteQualityTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/del?ruleConfGuid=${params}`,
method: 'delete'
})
/** 更新质检表规则的禁用和启用状态 */
export const updateRuleBizState = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/upate-bizstate?ruleConfGuid=${params.ruleConfGuid}&bizState=${params.bizState}`,
method: 'post',
})
/** 获取数据库表列表 */
export const getDatabase = (params) => request({
url: `${import.meta.env.VITE_APP_DATA_SOURCE_URL}/data-source/get-source-list`,
method: 'post',
data: params
})
/** 获取盘点的数据库目录 */
export const getInventoryDsDir = () => request({
url: `${import.meta.env.VITE_APP_CHECK_BASEURL}/db-dir/tree-list`,
method: 'post',
data: {}
})
/** 新建质检表，获取主题域分层的主题表树结构 */
export const getSubjectTableTree = (params) => request({
url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-catalog-directory/directory-tree-list`,
method: 'post',
data: params
})
/** 新建质检表，获取主题域分层的主题表树结构 */
export const getSubjectTableByDomain = (params) => request({
url: `${import.meta.env.VITE_APP_PLAN_BASEURL}/data-catalog-subject/list-by-domain-guid?domainGuid=${params}`,
method: 'get',
data: params
})
/** 获取主题表的字段列表，目前应包括盘点目录和元数据目录的表及字段 */
export const getSubjectFields = (tableGuid, dataSource) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/field/list-by-subject-guid?tableGuid=${tableGuid}&dataSource=${dataSource}`,
method: 'post',
})
/** 表的逻辑条件和sql检验。 */
export const validateSubjectTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/sql-operate/check-sql`,
method: 'post',
data: params
})
/** 自定义sql检验 */
export const validateCustomSql = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/check-custom-sql`,
method: 'post',
data: params
})
/** 批量验证过滤条件 */
export const batchValidateSubjectTableRule = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/sql-operate/batch-check-sql`,
method: 'post',
data: params
})
/** 保存质检表 */
export const saveQualityTable = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/add`,
method: 'post',
data: params
})
// 获取规则类型的接口
export const getRuleTypeList = () => request({
url:`${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-rule/list`,
method: 'post',
data: {}
})
// 获取规则大类的接口
export const getLargeCategoryList = () => request({
url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType?dictType=${'规则大类'}`,
method: 'get',
})
// 获取规则小类的接口
export const getSmallCategoryList = () => request({
url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType?dictType=${'规则小类'}`,
method: 'get',
})
// 获取规范性检验规则。
export const getCheckRulesList = () => request({
url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType?dictType=${'正则校验'}`,
method: 'get',
})
// 根据规则guid获取规则的详情信息。
export const getRuleConfDetail = (param) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/detail?ruleConfGuid=${param}`,
method: 'get'
})
// 根据质检模型guid获取详情信息。
export const getModelDetail = (param) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/detail/${param}`,
method: 'get'
})
// 更新规则信息。
export const updateModelRule = (params) => request({
url:`${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/conf/update`,
method: 'post',
data: params
})
// 获取产品目录guid下面的资源表
export const getDamCatalogTableList = (damGuid) => request({
url:`${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/quality/get-table-list?damGuid=${damGuid}`,
method: 'get'
})
\ No newline at end of file
src/api/modules/dataQualityAssess.ts deleted 100644 → 0
import request from "@/utils/request";
/** 根据类型获取方案列表 */
export const getPlanList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/list`,
method: 'post',
data: params
})
/** 删除方案 */
export const deletePlan = (guids) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/del`,
method: 'delete',
data: guids
})
/** 更新指定方案的状态上线，下线。 */
export const updateQualityPlanState = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/state-change?guid=${params.guid}&state=${params.state}`,
method: 'post'
})
/** 手动执行方案 */
export const executePlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/exec-plan?planGuid=${params}`,
method: 'post'
})
/** 获取方案详情，用于编辑 */
export const getAssessPlanDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/detail/${params}`,
method: 'get'
})
/** 获取方案详情中的过滤条件，用于编辑 */
export const getPlanFilterDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-plan-filter?planGuid=${params}`,
method: 'get'
})
/** 获取方案查看详情列表数据。 */
export const getAssessDetailTableData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-exec-list`,
method: 'post',
data: params
})
/** 根据执行guid，获取方案执行详情。 */
export const getExecPlanDetailTableData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-exec-detail?planGuid=${params.planGuid}&planExecGuid=${params.planExecGuid}`,
method: 'get'
})
/** 获取方案详情中每个表的规则详细执行列表数据。 */
export const getAssessTableRulesData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-exec-table-detail?planExecGuid=${params.planExecGuid}&qualityModelGuid=${params.qualityModelGuid}`,
method: 'get'
})
/** 获取脏数据查询 */
export const getQueryDirtyData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-dirty-data`,
method: 'post',
data: params
})
/** 获取脏数据字段列表 */
export const getQueryDirtyFields = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/query-dirty-data-column?qualityModelGuid=${params}`,
method: 'get'
})
/** 获取数据质量模型统计 */
export const getModelCountList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-count`,
method: 'post',
data: params
})
/** 获取规则大类统计 */
export const getModelRuleCount = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-rule-category-count`,
method: 'post',
data: params
})
/** 根据modelGuid获取详细的规则统计 */
export const getModelRules = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-rule`,
method: 'post',
data: params
})
/** 检查质检评估方案名称是否重复 */
export const checkPlanExist = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/exist?planName=${params}`,
method: 'get'
})
/** 获取有效的数据分组，用于评估 表选择 */
export const getValidGroup = () => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-group/valid-group-list`,
method: 'get'
})
/** 获取数据库列表 */
export const getModelDbGp = (dsGuid: any = null) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model/list/model-db-gp` + (!dsGuid ? '' : `?dataSourceGuid=${dsGuid}`),
method: 'get'
})
/** 保存质量方案 */
export const saveQualityPlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/add`,
method: 'post',
data: params
})
/** 更新质量方案 */
export const updateQualityPlan = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/update`,
method: 'put',
data: params
})
/** 下载脏数据 */
export const downloadDirtyData = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-plan/down-dirty-data`,
method: 'post',
data: params,
responseType: 'blob'
})
/** 获取对应执行方案的规则详情 */
export const getRecordRuleConfDetail = (param) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-model-record/conf/detail?ruleConfGuid=${param.ruleConfGuid}&planExecGuid=${param.planExecGuid}`,
method: 'get'
});
\ No newline at end of file
src/api/modules/dataQualityWord.ts deleted 100644 → 0
/** 用于质量分析报告模块 */
import request from "@/utils/request";
/** 获取质量分析报告列表数据。 */
export const getQualityWordList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/page-list`,
method: 'post',
data: params
})
/** 删除质量分析报告 */
export const deleteQualityWord = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/del`,
method: 'delete',
data: params
})
/** 添加质量报告 */
export const addQualityWord = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/add`,
method: 'post',
data: params
})
/** 更新质量报告 */
export const updateQualityWord = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/update`,
method: 'put',
data: params
})
/** 根据质量报告获取对应的执行日志。 */
export const getWordLogList = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/page-exec-list`,
method: 'post',
data: params
});
/** 获取质量分析报告的详细内容，根绝报告guid。 */
export const getReportDetail = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/get-report-data`,
method: 'post',
data: params
});
/** 获取数据质量一级指标得分统计 */
export const getLargeCategoryScore = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/get-largeCategory-score?reportExecGuid=${params}`,
method: 'get'
});
/** 获取方案执行明细 */
export const getPlanDetail= (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/query-exec-table-detail?reportExecGuid=${params.reportExecGuid}&planGuid=${params.planGuid}`,
method: 'get'
});
/** 获取方案执行表规则查看 */
export const getTableRuleDetail= (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/query-exec-table-rule-detail?reportExecGuid=${params}`,
method: 'get'
});
/** 手动执行报告 */
export const executeReport = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/exec?guid=${params}`,
method: 'get'
})
/** html转word接口 */
export const htmlToWord = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/download/html-to-word`,
method: 'postJsonD',
data: params,
responseType: 'blob'
});
/**上下线 */
export const stateChange = (params) => request({
url: `${import.meta.env.VITE_APP_QUALITY_BASEURL}/quality-analysis-report/state-change?guid=${params.guid}&state=${params.state}`,
method: 'post',
});
\ No newline at end of file
src/api/modules/dataTransaction.ts deleted 100644 → 0
import request from "@/utils/request";
/** 入表管理 */
/** 获取资产入表信息 */
export const getEntryList = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-intable/page-list`,
method: 'post',
data: params
})
/** 获取入表资产信息批量删除 */
export const deleteEntryAll = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-intable/delete?guid=${params}`,
method: 'delete',
})
/** 获取资产入表信息新增 */
export const createEntry = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-intable/save`,
method: 'post',
data: params
})
/** 获取资产入表信息修改 */
export const intableUpdate = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-intable/update`,
method: 'post',
data: params
})
/** A类证书列表查询 */
export const getDocumentList = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/register-document/list-a-document`,
method: 'post',
data: params
})
/**资产详情 */
export const getAssetDetail = (data) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/intable/get-table-select`,
method: 'post',
data
})
/** 资产融资管理 */
/** 获取资产融资信息列表 */
export const getFinancingList = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-financing/page-list`,
method: 'post',
data: params
})
/** 资产融资批量删除 */
export const deleteFinancingAll = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-financing/delete?guid=${params}`,
method: 'delete',
data: params
})
/** 资产融资信息新增 */
export const createFinancing = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-financing/save`,
method: 'post',
data: params
})
/** 资产融资信息修改 */
export const financingUpdate = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-financing/update`,
method: 'post',
data: params
})
/** 资产交易管理 */
/** 获取资产交易信息列表 */
export const getTradeList = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-trade/page-list`,
method: 'post',
data: params
})
/** 资产交易批量删除 */
export const deleteTradeAll = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-trade/delete?guid=${params}`,
method: 'delete',
data: params
})
/** 资产交易信息新增 */
export const createTrade = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-trade/save`,
method: 'post',
data: params
})
/** 资产融资信息修改 */
export const tradeUpdate = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/da-trade/update`,
method: 'post',
data: params
})
src/api/modules/dataTrustedSpace.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取首页组织机构信息 */
export const getReleaseYears = () => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-delivery-main/release-year`,
method: 'get',
})
export const getParamsList = (params) => request({
url: `${import.meta.env.VITE_APP_CONFIG_URL}/dict/data/get-by-dictType`,
method: 'get',
params
})
export const getSubjectDomainDataTree = () => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-delivery-main/delivery-data-tree`,
method: 'get',
})
export const getReleaseListData = (params) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-delivery-main/list-all`,
method: 'post',
data: params
})
/** 获取资产登记详情 */
export const getReleaseDataCertiDetail = (guid) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/register-document/detail-by-dam-guid?damGuid=${guid}`,
method: 'get'
})
/** 获取交付物下载附件 */
export const getDeliveryFileDetail = (guid) => request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-delivery-main/detail?guid=${guid}`,
method: 'get'
})
src/api/modules/queryHomeService.ts deleted 100644 → 0
import request from "@/utils/request";
/** 获取资产登记信息分页 */
export const getRegisterPageList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/register/page-list`,
method: 'post',
data: params
});
/** 资产登记统计 */
export const getDamStat = () => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/register/dam-stat`,
method: 'get'
});
/** 异议申请提交接口 */
export const damDissentHandleSave = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/register/dam-dissent-handle/save`,
method: 'post',
data: params
});
/** 获取产品需求列表数据 */
export const getDemandList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/trade/demand-page`,
method: 'post',
data: params
})
/** 获取数据产品列表数据 */
export const getTradeProductList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/trade/product-page`,
method: 'post',
data: params
})
/** 获取融资服务产品列表 */
export const getFinancialProductList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/financial/product-page`,
method: 'post',
data: params
})
/** 流通撮合 */
export const circulationSave = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/circulation/apply-save`,
method: 'post',
data: params
})
/** 获取短信验证码 */
export const getRegisterCode = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/sms/get-verify-code`,
method: 'post',
params
})
/** 校验短信验证码 */
export const checkRegisterCode = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/sms/get-verify-code-validation`,
method: 'post',
params
})
/** 获取图形验证码 **/
export const getImgCodeSrc = (params={}) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/get-captcha`,
method: 'get',
params
})
/** 校验图形验证码 **/
export const checkImgCode = (params={}) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/check`,
method: 'post',
params
})
/** 获取参数数据字典 */
export const getParamsList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/data-dict/get-data-list`,
method: 'post',
data: params
})
/** 获取树形参数字典 */
export const getParamsTreeList = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/get-data-tree`,
method: 'post',
data: params
})
/** 获取产品列表的所属主题属性参数字典，根据产品数据获取。 */
export const getProductParamsTreeList = () => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/trade/product-data-tree`,
method: 'get'
})
/** 获取需求列表的所属主题属性参数字典，根据需求数据获取。*/
export const getDemandParamsTreeList = () => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/trade/demand-data-tree`,
method: 'get'
})
/** 查看图片 */
export const getImageContent = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/portal/obs/view?filePath=${params}`,
method: 'get',
responseType: 'blob'
});
/** 获取产品详情信息 */
export const getProductDetail = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/dam-catalog-table/dam-register?guid=${params.damGuid}&productGuid=${params.guid}`,
method: 'post'
})
/** 获取产品富文本等相关信息 */
export const getDamContent = (params) =>request({
url: `${import.meta.env.VITE_API_PORTALURL}/dam-catalog-table/get-dam-content?bizGuid=${params.guid}`,
method: 'post'
})
/** 获取资产的数据集信息 */
export const getDamTables = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/dam-catalog-table/data-assets?damGuid=${params.damGuid}`,
method: 'post'
})
/** 获取资产表对应的字段信息。 */
export const getTableFields = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/dam-catalog-table/field-list?subjectGuid=${params.guid}`,
method: 'post'
})
/** 查询资产表对应的api接口信息 */
export const getApiInfo = (params) => request({
url: `${import.meta.env.VITE_API_PORTALURL}/dam-catalog-table/api-info?subjectGuid=${params.guid}`,
method: 'post'
})
src/api/modules/securityMenu.ts deleted 100644 → 0
import request from "@/utils/request";
/**
*@description 获取数据产品目录合规信息分页
*@path /dam-catalog-table/compliance-info/page-list
*@method post
*/
export const getComplianceInfoPageList = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/compliance-info/page-list`,
method: 'post',
data: params
})
}
/**
* @description 修改数据产品目录合规信息
* @path /dam-catalog-table/compliance-info/update
* @method post
*/
export const updateComplianceInfo = (params) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/compliance-info/update`,
method: 'post',
data: params
})
}
/** 获取资产合规目录详情 */
export const getComplianceDetail = (guid) => {
return request({
url: `${import.meta.env.VITE_API_NEW_PORTAL}/dam-catalog-table/compliance-info/detail?damGuid=${guid}`,
method: 'get'
})
}
\ No newline at end of file
src/api/modules/workFlowService.ts
......@@ -65,8 +65,21 @@ export const isMyFirstNode = (params) => request({
data: params
})
/** 获取跨平台审批数据节点详情 */
export const getCrossDetailList = (params) => request({
url: `${import.meta.env.VITE_APP_WORK_FLOW_URL}/approve-detail-cross/list`,
method: 'post',
data: params
})
/** 重新发起失败的流程 */
export const crossPlatformApprove = (params) => request({
url: `${import.meta.env.VITE_APP_WORK_FLOW_URL}/approve-detail-cross/add-cross-platform-approve?guid=${params.guid}&approveGuid=${params.approveGuid}`,
method: 'post',
data: {}
})
/** 功能流程配置-获取是否需要审批 */
export const isNeedApprove = (params) => request({
url: `${import.meta.env.VITE_APP_WORK_FLOW_URL}/func-flow-config/is-need-approve?funcCode=${params.funcCode}`,
method: 'get',
})
\ No newline at end of file
})
......
src/router/modules/assetIndex.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-asset-index',
component: Layout,
meta: {
title: '数据资产看板',
icon: 'sidebar-videos',
},
children: [{
path: '',
name: 'assetIndex',
component: () => import('@/views/indexNewBigScreen.vue'),
meta: {
title: '数据资产看板',
sidebar: false,
breadcrumb: false,
cache: true
},
}]
},
]
export default routes
src/router/modules/dataAnonymization.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-anonymization/label-management',
component: Layout,
meta: {
title: '标签管理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'labelManagement',
component: () => import('@/views/data_anonymization/labelManagement.vue'),
meta: {
title: '标签管理',
sidebar: false,
breadcrumb: false,
cache: true
},
}
],
},
{
path: '/data-anonymization/generalize-file',
component: Layout,
meta: {
title: '泛化文件管理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'generalizeFile',
component: () => import('@/views/data_anonymization/generalizeFile.vue'),
meta: {
title: '泛化文件管理',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'generalize-file-edit',
name: 'generalizeFileEdit',
component: () => import('@/views/data_anonymization/generalizeFileEdit.vue'),
meta: {
title: '新建泛化文件',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-anonymization/generalize-file'
},
beforeEnter: (to, from) => {
if (to.query.fileName) {
to.meta.title = `编辑-${to.query.fileName}`;
}
}
},
],
},
{
path: '/data-anonymization/sensitive-identify',
component: Layout,
meta: {
title: '敏感数据识别',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'sensitiveIdentify',
component: () => import('@/views/data_anonymization/sensitiveIdentify.vue'),
meta: {
title: '敏感数据识别',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'sensitive-identify-config',
name: 'sensitiveIdentifyConfig',
component: () => import('@/views/data_anonymization/sensitiveIdentifyConfig.vue'),
meta: {
title: '敏感数据识别查看',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: false,
activeMenu: '/data-anonymization/sensitive-identify'
},
beforeEnter: (to, from) => {
if (to.query.taskName) {
to.meta.title = `敏感数据${to.query.isLook == '1' ? '日志查看' : '查看'}-${to.query.taskName}`;
}
}
},
{
path: 'sensitive-identify-task-exec-log',
name: 'sensitiveIdentifyTaskExecLog',
component: () => import('@/views/data_anonymization/sensitiveIdentifyTaskExecLog.vue'),
meta: {
title: '执行日志',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `日志-${to.query.name}`;
}
}
}
],
},
{
path: '/data-anonymization/result-process',
component: Layout,
meta: {
title: '匿名化处理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'resultProcess',
component: () => import('@/views/data_anonymization/resultProcess.vue'),
meta: {
title: '匿名化处理',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'anon-task-create',
name: 'anonTaskCreate',
component: () => import('@/views/data_anonymization/anonTaskCreate.vue'),
meta: {
title: '匿名化处理任务',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-anonymization/result-process'
},
beforeEnter: (to, from) => {
if (to.query.taskName) {
to.meta.title = `编辑-${to.query.taskName}`;
}
}
},
{
path: 'anonResultView',
name: 'anonResultView',
component: () => import('@/views/data_anonymization/anonResultView.vue'),
meta: {
title: '查看数据',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `查看数据-${to.query.taskName}`;
}
}
},
],
},
]
export default routes
src/router/modules/dataEntry.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-entry/entry-consult',
component: Layout,
meta: {
title: '入表预估',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'entryConsult',
component: () => import('@/views/data_entry/index.vue'),
meta: {
title: '入表预估',
sidebar: false,
breadcrumb: false,
cache: true
},
},
],
},
// {
// path: '/data-guide/entry-table',
// component: Layout,
// meta: {
// title: '入表指南',
// icon: 'sidebar-videos',
// },
// children: [
// {
// path: '',
// name: 'entryTableGuide',
// component: () => import('@/views/data_transaction/entryTableGuide.vue'),
// meta: {
// title: '入表指南',
// sidebar: false,
// breadcrumb: false,
// cache: true
// },
// },
// ],
// },
{
path: '/data-entry/entry-management',
component: Layout,
meta: {
title: '入表管理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'entryManagement',
component: () => import('@/views/data_transaction/entryManagement.vue'),
meta: {
title: '入表管理',
sidebar: false,
breadcrumb: false,
cache: true
},
},
],
},
{
path: '/data-entry/valuation-model',
component: Layout,
meta: {
title: '估值模型',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'valuationModel',
component: () => import('@/views/data_transaction/valuationModel.vue'),
meta: {
title: '估值模型',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'valuation-model-create',
name: 'valuationModelCreate',
component: () => import('@/views/data_transaction/valuationModelCreate.vue'),
meta: {
title: '新建估值模型',
sidebar: false,
breadcrumb: false,
cache: true,
editPage: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `编辑-${to.query.name}`;
}
}
},
],
},
]
export default routes
src/router/modules/dataInventory.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-inventory/classify-grade-manage',
component: Layout,
meta: {
title: '分类分级管理',
icon: 'sidebar-videos',
},
children: [
{
path: 'task-config',
name: 'taskConfig',
component: () => import('@/views/data_inventory/taskConfig.vue'),
meta: {
title: '分类分级任务',
breadcrumb: false,
cache: true
},
},
{
path: 'task-edit',
name: 'taskEdit',
component: () => import('@/views/data_inventory/taskEdit.vue'),
meta: {
title: '编辑-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/task-config'
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `编辑-${to.query.name}`;
} else {
to.meta.title = '分类分级任务-新增';
}
}
},
{
path: 'task-detail',
name: 'taskDetail',
component: () => import('@/views/data_inventory/taskDetail.vue'),
meta: {
title: '结果-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/task-config'
},
beforeEnter: (to, from) => {
const taksExecGuid = sessionStorage.getItem('taksExecGuid') || '';
if(taksExecGuid){
to.meta.title = `${to.query.name}-${to.query.status == 'Y'?'查看结果':'结果确认'}`;
to.meta.editPage = to.query.status == 'Y'? false: true;
} else {
to.meta.title = `${to.query.name}-${to.query.status == 'Y'?'结果修改':'结果确认'}`;
to.meta.editPage = true;
}
}
},
{
path: 'task-log',
name: 'taskLog',
component: () => import('@/views/data_inventory/taskLog.vue'),
meta: {
title: '分级分类日志',
sidebar: false,
breadcrumb: false,
cache: true,
activeMenu: '/data-inventory/classify-grade-manage/task-config'
},
},
{
path: 'template-config',
name: 'templateConfig',
component: () => import('@/views/data_inventory/templateConfig.vue'),
meta: {
title: '分类分级规则',
breadcrumb: false,
cache: true
},
},
{
path: 'data-label',
name: 'dataLabel',
component: () => import('@/views/data_inventory/dataLabel.vue'),
meta: {
title: '标签管理',
breadcrumb: false,
cache: true
},
},
{
path: 'classStandard-edit',
name: 'classStandardEdit',
component: () => import('@/views/data_inventory/classStandardEdit.vue'),
meta: {
title: '编辑-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/template-config'
},
beforeEnter: (to, from) => {
if (to.query.classStandardName) {
to.meta.title = `编辑-${to.query.classStandardName}`;
}
}
},
{
path: 'newCreate-template',
name: 'newCreateTemplate',
component: () => import('@/views/data_inventory/newCreateTemplate.vue'),
meta: {
title: '新增-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/template-config'
},
beforeEnter: (to, from) => {
if (to.query.classStandardName) {
to.meta.title = `新增-${to.query.classStandardName}`;
}
}
},
{
path: 'newCreate-class',
name: 'newCreateClass',
component: () => import('@/views/data_inventory/newCreateClass.vue'),
meta: {
title: '新增分类',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/template-config'
},
},
{
path: 'classifyGrad-edit',
name: 'classifyGradEdit',
component: () => import('@/views/data_inventory/classifyGradEdit.vue'),
meta: {
title: '编辑-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/template-config'
},
beforeEnter: (to, from) => {
if (to.query.classClassifyGradName) {
to.meta.title = `编辑-${to.query.classClassifyGradName}`;
}
}
},
{
path: 'classificationTemplate-edit',
name: 'classificationTemplateEdit',
component: () => import('@/views/data_inventory/classificationTemplateEdit.vue'),
meta: {
title: '编辑-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-manage/template-config'
},
beforeEnter: (to, from) => {
if (to.query.classClassifyGradName) {
to.meta.title = `编辑-${to.query.classClassifyGradName}`;
}
}
},
],
},
{
path: '/data-inventory/classify-grade-catalogue',
component: Layout,
meta: {
title: '分类分级目录',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'classifyGradeCatalogue',
component: () => import('@/views/data_inventory/classifyGradeCatalogue.vue'),
meta: {
title: '分类分级目录',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'configure-rules',
name: 'configureRules',
component: () => import('@/views/data_inventory/configureRules.vue'),
meta: {
title: '配置业务规则',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-inventory/classify-grade-catalogue',
},
},
{
path: 'table-create-existing',
name: 'tableCreateExisting',
component: () => import('@/views/data_inventory/tableCreateExisting.vue'),
meta: {
title: '已有表新建',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.editOpt) {
to.meta.title = `编辑-(${to.query.tableChName})`;
to.meta.editPage = true;
}
}
},
{
path: 'table-create-file',
name: 'tableCreateFile',
component: () => import('@/views/data_inventory/tableCreateFile.vue'),
meta: {
title: '根据文件新建',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
}
},
],
},
{
path: '/data-inventory/data-dictionary',
component: Layout,
meta: {
title: '数据字典',
icon: 'sidebar-cooperation',
},
children: [
{
path: '',
name: 'dictionary',
component: () => import('@/views/data_inventory/dictionary.vue'),
meta: {
title: '数据字典',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: '/data-inventory/data-dictionary/import-file',
name: 'importFile',
component: () => import('@/views/importFile.vue'),
meta: {
title: '文件导入',
sidebar: false,
breadcrumb: false,
cache: true
},
},
],
},
{
path: '/data-inventory/data-source',
component: Layout,
meta: {
title: '数据源管理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'dataSource',
component: () => import('@/views/data_inventory/dataSource.vue'),
meta: {
title: '数据源管理',
sidebar: false,
breadcrumb: false,
cache: true
},
},
],
},
]
export default routes
src/router/modules/dataMeta.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-meta/collect-task',
component: Layout,
meta: {
title: '采集任务',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'collectorTask',
component: () => import('@/views/data_meta/collectorTask.vue'),
meta: {
title: '采集任务',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'excution-log',
name: 'excutionLog',
component: () => import('@/views/data_meta/executionLog.vue'),
meta: {
title: '采集日志',
sidebar: false,
breadcrumb: false,
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `采集日志-${to.query.name}`;
}
}
},
{
path: 'import-file-meta',
name: 'importFileMeta',
component: () => import('@/views/importFile.vue'),
meta: {
title: '导入数据-采集任务',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
}
}
],
},
{
path: '/data-meta/metadata-query',
component: Layout,
meta: {
title: '元数据查询',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'metadataQuery',
component: () => import('@/views/data_meta/metadataQuery.vue'),
meta: {
title: '元数据查询',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'meta-sheet',
name: 'metaSheet',
component: () => import('@/views/data_meta/metaSheet.vue'),
meta: {
title: '元数据详情-',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `元数据详情-${to.query.name}`;
}
}
},
],
},
{
path: '/data-meta/metadata-lineage',
component: Layout,
meta: {
title: '元数据血缘',
icon: 'ep:grid',
},
children: [
{
path: 'analysis-view',
name: 'analysisView',
component: () => import('@/views/data_meta/analysisView.vue'),
meta: {
title: '查看血缘',
breadcrumb: false,
cache: true
},
},
{
path: 'change-detection',
name: 'changeDetection',
component: () => import('@/views/data_meta/changeDetection.vue'),
meta: {
title: '血缘变更检测',
breadcrumb: false,
cache: true
},
},
{
path: 'analysis-reports',
name: 'analysisReports',
component: () => import('@/views/data_meta/analysisReports.vue'),
meta: {
title: '血缘关系解析',
breadcrumb: false,
cache: true
},
},
],
},
{
path: '/data-metas/report',
component: Layout,
meta: {
title: '报表查看',
icon: 'sidebar-videos',
},
children: [
{
path: 'budgetDataIndex',
name: 'budgetDataIndex',
component: () => import('@/views/data_meta/budgetDataIndex.vue'),
meta: {
title: '',
// sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-metas/report/budgetDataIndex',
},
}
]
},
{
path: '/data-metas/reports',
component: Layout,
meta: {
title: '资源目录',
icon: 'ep:grid',
},
children: [
{
path: 'iframePage',
name: 'iframePage',
component: () => import('@/views/data_meta/budgetDataIndex.vue'),
meta: {
title: '',
sidebar: true,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-metas/reports/iframePage',
},
},
{
path: 'portraitMaps',
name: 'portraitMaps',
component: () => import('@/views/data_meta/portraitMap.vue'),
meta: {
title: '全景地图',
sidebar: true,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-metas/reports/portraitMaps',
},
}
]
},
{
path: '/data-metas/reports',
component: Layout,
meta: {
title: '资源目录',
icon: 'ep:grid',
},
children: [
{
path: 'iframePage',
name: 'iframePage',
component: () => import('@/views/data_meta/budgetDataIndex.vue'),
meta: {
title: '',
sidebar: true,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-metas/reports/iframePage',
},
}
]
},
{
path: '/data-meta/portraitMap',
component: Layout,
meta: {
title: '全景地图',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'portraitMap',
component: () => import('@/views/data_meta/portraitMap.vue'),
meta: {
title: '全景地图',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
}
]
},
{
path: '/data-meta/metadata-standard',
component: Layout,
meta: { title: '元数据标准', icon: 'ep:grid' },
children: [
{
path: '',
name: 'metadataStandard',
component: () => import('@/views/data_meta/standard.vue'),
meta: {
title: '元数据标准管理',
breadcrumb: false,
cache: true
}
},
{
path: 'standard-query',
name: 'metadataStandardQuery',
component: () => import('@/views/data_meta/standard-query.vue'),
meta: {
title: '元数据标准查询',
breadcrumb: false,
cache: true
}
},
{
path: 'standard-query-view',
name: 'metadataStandardQueryView',
component: () => import('@/views/data_meta/standard-query-view.vue'),
meta: {
title: '元数据标准查看',
breadcrumb: false,
cache: true,
activeMenu: '/data-meta/metadata-standard'
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `元数据标准查看-${to.query.name}`;
}
}
},
{
path: 'table-create-manual',
name: 'tableCreateManual',
component: () => import('@/views/data_meta/tableCreateManual.vue'),
meta: {
title: '新建表',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-meta/metadata-standard/standard-query'
},
beforeEnter: (to, from) => {
if (to.query.domainName) {
to.meta.title = `新建表(${to.query.domainName})-${to.query.standardName}`;
to.meta.editPage = true;
}
}
},
{
path: 'dim-table-create-manual',
name: 'dimTableCreateManual',
component: () => import('@/views/data_meta/dimTableCreateManual.vue'),
meta: {
title: '新建表',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-meta/metadata-standard/standard-query'
},
beforeEnter: (to, from) => {
if (to.query.domainName) {
to.meta.title = `新建表(${to.query.domainName})-${to.query.standardName}`;
to.meta.editPage = true;
}
}
},
{
path: 'standard-codetable',
name: 'metadataStandardCodetable',
component: () => import('@/views/data_meta/standard-codetable.vue'),
meta: {
title: '标准代码表',
breadcrumb: false,
cache: true
}
},
{
path: 'standard-import',
name: 'metadataStandardImport',
component: () => import('@/views/data_meta/standard-import.vue'),
meta: {
title: '标准代码导入',
breadcrumb: false,
cache: true,
activeMenu: '/data-meta/metadata-standard/standard-codetable'
}
},
{
path: 'standard-meta-import',
name: 'standardMetaImport',
component: () => import('@/views/data_meta/standard-meta-import.vue'),
meta: {
title: '元数据标准导入',
breadcrumb: false,
cache: true,
activeMenu: '/data-meta/metadata-standard'
}
}
]
}
]
export default routes
src/router/modules/dataPricing.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-pricing/pricing-manage',
component: Layout,
meta: {
title: '定价管理',
icon: 'ep:grid',
},
children: [
{
path: 'demand-manage',
name: 'demandManage',
component: () => import('@/views/data_pricing/demandManage.vue'),
meta: {
title: '需求表管理',
breadcrumb: false,
cache: true
},
},
{
path: 'import-file-demand-manage',
name: 'importFileDemandManage',
component: () => import('@/views/importFile.vue'),
meta: {
title: '导入数据-需求表管理',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-pricing/pricing-manage/demand-manage'
}
},
{
path: 'disease-manage',
name: 'diseaseManage',
component: () => import('@/views/data_pricing/diseaseManage.vue'),
meta: {
title: '疾病管理',
breadcrumb: false,
cache: true
},
},
{
path: 'import-file-disease',
name: 'importFileDisease',
component: () => import('@/views/importFile.vue'),
meta: {
title: '导入数据-疾病管理',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
activeMenu: '/data-pricing/pricing-manage/disease-manage'
}
},
{
path: 'price-config',
name: 'priceConfig',
component: () => import('@/views/data_pricing/priceConfig.vue'),
meta: {
title: '定价配置',
breadcrumb: false,
cache: true
},
},
{
path: 'price-model',
name: 'priceModel',
component: () => import('@/views/data_pricing/priceModel.vue'),
meta: {
title: '新增配置',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-pricing/pricing-manage/price-config'
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `编辑-${to.query.name}`;
} else {
to.meta.title = `新增配置`;
}
}
},
{
path: 'price-calculate',
name: 'priceCalculate',
component: () => import('@/views/data_pricing/priceCalculate.vue'),
meta: {
title: '数据定价',
breadcrumb: false,
cache: true
}
},
{
path: 'calculate-config',
name: 'calculateConfig',
component: () => import('@/views/data_pricing/calculateConfig.vue'),
meta: {
title: '新增数据定价',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true,
activeMenu: '/data-pricing/pricing-manage/price-calculate'
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `编辑-${to.query.name}`;
} else {
to.meta.title = `新增数据定价`;
}
}
},
{
path: 'price-calculate-new',
name: 'priceCalculateNew',
component: () => import('@/views/data_pricing/priceCalculateNew.vue'),
meta: {
title: '数据定价(新)',
breadcrumb: false,
cache: true
}
},
{
path: 'calculate-config-new',
name: 'calculateConfigNew',
component: () => import('@/views/data_pricing/calculateConfigNew.vue'),
meta: {
title: '新增数据定价',
sidebar: false,
breadcrumb: false,
cache: true,
editPage: true,
activeMenu: '/data-pricing/pricing-manage/price-calculate-new'
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `编辑-${to.query.name}`;
} else {
to.meta.title = `新增数据定价`;
}
}
},
],
},
]
export default routes
src/router/modules/dataProduct.ts
import { tr } from 'element-plus/es/locale';
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
......
src/router/modules/dataQuality.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-quality/quality-rules',
component: Layout,
meta: {
title: '质量规则管理',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'qualityRules',
component: () => import('@/views/data_quality/qualityRules.vue'),
meta: {
title: '质量规则管理',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'rule-model',
name: 'ruleModel',
component: () => import('@/views/data_quality/ruleModel.vue'),
meta: {
title: '新建质检表',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.groupGuid) {
to.meta.title = `新建质检表(${to.query.name})`;
to.meta.editPage = true;
}
}
},
{
path: 'rule-template',
name: 'ruleTemplate',
component: () => import('@/views/data_quality/ruleTemplate.vue'),
meta: {
title: '新建规则',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.modelGuid) {
to.meta.title = `新建规则(${to.query.name})`;
to.meta.editPage = true;
}
}
},
{
path: 'rule-model-edit',
name: 'ruleModelEdit',
component: () => import('@/views/data_quality/ruleModelEdit.vue'),
meta: {
title: '编辑',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `编辑-`;
}
}
},
{
path: 'import-file',
name: 'importFiles',
component: () => import('@/views/importFile.vue'),
meta: {
title: '文件导入',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
}
],
},
{
path: '/data-quality/quality-assess',
component: Layout,
meta: {
title: '质量评估方案',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'qualityAssess',
component: () => import('@/views/data_quality/qualityAssess.vue'),
meta: {
title: '质量评估方案',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'assess-template',
name: 'assessTemplate',
component: () => import('@/views/data_quality/assessTemplate.vue'),
meta: {
title: '新建质量评估方案',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true,
editPage: true
},
beforeEnter: (to, from) => {
if (to.query.detail) {
to.meta.title = `方案详情-${to.query.planName}`;
to.meta.editPage = false;
} else if (to.query.planName) {
to.meta.title = `方案编辑-${to.query.planName}`;
}
}
},
{
path: 'assess-detail',
name: 'assessDetail',
component: () => import('@/views/data_quality/assessDetail.vue'),
meta: {
title: '查看结果',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `查看结果-${to.query.name}`;
}
}
},
{
path: 'assess-dirty',
name: 'assessDirty',
component: () => import('@/views/data_quality/assessDirty.vue'),
meta: {
title: '脏数据',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `脏数据-${to.query.name}`;
}
}
},
{
path: 'assess-log',
name: 'assessLog',
component: () => import('@/views/data_quality/assessLog.vue'),
meta: {
title: '执行日志',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.guid) {
to.meta.title = `日志-${to.query.name}`;
}
}
},
],
},
{
path: '/data-quality/quality-analysis',
component: Layout,
meta: {
title: '质量分析报告',
icon: 'ep:grid',
},
children: [
{
path: '',
name: 'qualityAnalysis',
component: () => import('@/views/data_quality/qualityAnalysis.vue'),
meta: {
title: '质量分析报告',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: 'analysis-log',
name: 'analysisLog',
component: () => import('@/views/data_quality/analysisLog.vue'),
meta: {
title: '执行日志',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `日志-${to.query.name}`;
}
}
},
{
path: 'analysis-report',
name: 'analysisReport',
component: () => import('@/views/data_quality/analysisReport.vue'),
meta: {
title: '分析报告',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.name) {
to.meta.title = `分析报告-${to.query.name}`;
}
}
},
],
}
]
export default routes
src/router/modules/dataTrustedSpace.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/trusted-space-index',
component: Layout,
meta: {
title: '数据连接件',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'trustedSpaceIndex',
component: () => import('@/views/data_trusted/trustedSpaceIndex.vue'),
meta: {
title: '数据连接件',
sidebar: false,
breadcrumb: false,
cache: true
},
},
{
path: '/down-delivery-file',
name: 'downDeliveryFile',
component: () => import('@/views/data_trusted/downDeliveryFile.vue'),
meta: {
title: '交付物下载',
sidebar: false,
breadcrumb: false,
cache: true,
reuse: true
},
beforeEnter: (to, from) => {
if (to.query.damName) {
to.meta.title = `交付物下载-${to.query.damName}`;
}
}
},
]
}]
export default routes
\ No newline at end of file
src/router/modules/securityMenu.ts deleted 100644 → 0
import type { RouteRecordRaw } from 'vue-router'
function Layout() {
return import('@/layouts/index.vue')
}
const routes: RouteRecordRaw[] = [
{
path: '/data-security/security-menu',
component: Layout,
meta: {
title: '数据资产合规信息',
icon: 'sidebar-videos',
},
children: [
{
path: '',
name: 'securityMenu',
component: () => import('@/views/security_menu/index.vue'),
meta: {
title: '数据资产合规信息',
sidebar: false,
breadcrumb: false,
cache: true
},
},
],
},
]
export default routes
src/router/routes.ts
......@@ -2,16 +2,7 @@ import { setupLayouts } from 'virtual:meta-layouts'
import generatedRoutes from 'virtual:generated-pages'
import type { RouteRecordRaw } from 'vue-router'
import DataAssess from './modules/dataAsset';
import DataMeta from './modules/dataMeta';
import DataQuality from './modules/dataQuality';
import DataInventory from './modules/dataInventory';
import DataAnonymization from './modules/dataAnonymization';
import AssetIndex from './modules/assetIndex';
import DataTrustedSpace from './modules/dataTrustedSpace';
import DataAssetRegistry from './modules/dataAssetRegistry';
import DataEntry from './modules/dataEntry';
import SecurityMenu from './modules/securityMenu';
import DataPricing from './modules/dataPricing';
import useSettingsStore from '@/store/modules/settings'
......
src/views/data_anonymization/anonResultView.vue deleted 100644 → 0
<route lang="yaml">
name: anonResultView
</route>
<script lang="ts" setup name="anonResultView">
import { ref } from "vue";
import {
getAnonPageData,
getLastAnonAnalyzeResult,
exportAnonExecData,
} from "@/api/modules/dataAnonymization";
import { calcColumnWidth } from "@/utils/index";
import Moment from 'moment';
import { TableColumnWidth } from "@/utils/enum";
import { ElMessage } from "element-plus";
import { commonPageConfig } from '@/components/PageNav/index';
import { download } from "@/utils/common";
const { proxy } = getCurrentInstance() as any;
const route = useRoute();
const props = defineProps({
isPage: {
default: true,
type: Boolean
},
execGuid: {
default: '',
type: String
}
});
const tableData: any = ref([]);
const tableDataLoading = ref(false);
const tableFields: any = ref([]);
const pageInfo: any = ref({
...commonPageConfig,
rows: 0,
})
const getData = () => {
tableData.value = [];
if (!tableFields.value?.length) {
return;
}
tableDataLoading.value = true;
getAnonPageData({
pageIndex: pageInfo.value.curr,
pageSize: pageInfo.value.limit,
taskExecGuid: props.isPage ? route.query.execGuid : props.execGuid,
}).then((res: any) => {
tableDataLoading.value = false;
if (res.code == proxy.$passCode) {
tableData.value = [];
res.data?.records?.forEach(d => {
let obj = {};
tableFields.value.forEach(t => {
obj[t.enName] = d.fieldValue?.[t.enName];
});
tableData.value.push(obj);
});
pageInfo.value.rows = res.data?.totalRows ?? 0;
} else {
ElMessage.error(res.msg);
}
});
}
const getTextAlign = (field) => {
if (field.dataType === 'decimal' || field.dataType === 'int' || field.dataType == 'bit' || field.dataType == 'tinyint') {
return 'right';
}
return 'left'
}
/** otherWidth表示使用标题宽度时添加标题排序图标等宽度 */
const calcTableColumnWidth = (data: any[], prop, title, otherWidth = 0) => {
let d: any[] = [];
data.forEach((dt) => d.push(dt[prop]));
return calcColumnWidth(
d,
title,
{
fontSize: 14,
fontFamily: "SimSun",
},
{
fontSize: 14,
fontFamily: "SimSun",
},
otherWidth
);
};
/** 每列字段对应的列宽计算结果。 */
const originTableFieldColumn = ref({});
watch(
tableData,
(val: any[], oldVal) => {
if (!tableFields.value?.length) {
originTableFieldColumn.value = {};
return;
}
originTableFieldColumn.value = {};
tableFields.value.forEach((field, index) => {
originTableFieldColumn.value[field.enName] = calcTableColumnWidth(
val?.slice(0, 20) || [],
field.enName,
field.chName,
24
);
});
},
{
deep: true,
}
);
watch(() => props.execGuid, (val) => {
if (!val) {
return;
}
tableDataLoading.value = true;
getLastAnonAnalyzeResult(val).then((res: any) => {
tableDataLoading.value = false;
if (res.code == proxy.$passCode) {
let column = res.data?.column || {};
tableFields.value = column;
pageInfo.value.curr = 1;
getData();
} else {
ElMessage.error(res.msg);
}
});
}, {
immediate: true
})
onBeforeMount(() => {
if (!props.isPage) {
return;
}
tableDataLoading.value = true;
getLastAnonAnalyzeResult(route.query.execGuid).then((res: any) => {
tableDataLoading.value = false;
if (res.code == proxy.$passCode) {
let column = res.data?.column || {};
tableFields.value = column;
getData();
} else {
ElMessage.error(res.msg);
}
});
});
const formatterPreviewDate = (row, info) => {
let enName = info.enName;
let v = row[enName];
if (v === 0) {
return v;
}
if (!v || v == 'null') {
return '--';
}
if (info.dataType === 'datetime') {
return Moment(v).format('YYYY-MM-DD HH:mm:ss');
}
if (info.dataType === 'date') {
if (isNaN(<any>(new Date(v)))) {
return Moment(parseInt(v)).format('YYYY-MM-DD');
} else {
return Moment(v).format('YYYY-MM-DD');
}
}
return v;
};
const pageChange = (info) => {
pageInfo.value.curr = Number(info.curr);
pageInfo.value.limit = Number(info.limit);
getData();
}
const promise: any = ref(null);
const exportData = () => {
if (promise.value) {
return;
}
promise.value = exportAnonExecData({
taskGuid: route.query.guid,
execGuid: route.query.execGuid
}).then((res: any) => {
promise.value = null;
if (res && !res.msg) {
download(res, route.query.taskName + '_匿名化数据.xlsx', 'excel')
} else {
res?.msg && ElMessage.error(res?.msg);
}
}).catch(() => {
promise.value = null;
})
}
</script>
<template>
<div class="table_tool_wrap" v-loading="tableDataLoading">
<el-button v-show="props.isPage" style="margin-bottom: 8px;" type="primary" @click="exportData"
v-preReClick>导出数据</el-button>
<el-table ref="tableRef" v-show="tableFields.length" :data="tableData" :highlight-current-row="true" stripe border
tooltip-effect="light" height="100%" row-key="guid" :style="{ width: '100%', height: !props.isPage ? 'calc(100% - 34px)' : 'calc(100% - 64px)' }">
<template v-for="(item, index) in (tableFields || [])">
<el-table-column :label="item.chName" :width="item.dataType === 'datetime'
? TableColumnWidth.DATETIME
: item.dataType === 'date'
? TableColumnWidth.DATE
: originTableFieldColumn[item.enName]
" :align="getTextAlign(item)" :header-align="getTextAlign(item)"
:formatter="(row) => formatterPreviewDate(row, item)" :show-overflow-tooltip="true">
</el-table-column>
</template>
</el-table>
<div v-show="!tableFields.length" class="empty-content">
<img src="../../assets/images/empty-data.png" :style="{ width: '168px', height: '96px' }" />
<div class="empty-text">暂无数据</div>
</div>
<PageNav :class="[pageInfo.type]" :pageInfo="pageInfo" @pageChange="pageChange" />
</div>
</template>
<style lang="scss" scoped>
.table_tool_wrap {
width: 100%;
height: 100%;
padding: 8px 16px 16px;
.tips_text {
font-size: 14px;
color: var(--el-text-color-tip);
display: block;
font-weight: normal;
margin-bottom: 8px;
line-height: 21px;
}
.el-table {
display: inline-block;
}
.empty-content {
display: flex;
align-items: center;
justify-content: center;
height: 100%;
width: 100%;
flex-direction: column;
.empty-text {
font-size: 14px;
color: #b2b2b2;
}
}
}
</style>
\ No newline at end of file
src/views/data_anonymization/generalizeFile.vue deleted 100644 → 0
<route lang="yaml">
name: generalizeFile
</route>
<script lang="ts" setup name="generalizeFile">
import TableTools from "@/components/Tools/table_tools.vue";
import { commonPageConfig } from '@/components/PageNav/index';
import { TableColumnWidth } from "@/utils/enum";
import {
deleteGeneralizeFile,
getGeneralizeFileList,
fieldTypeList,
} from '@/api/modules/dataAnonymization';
import useDataAnonymizationStore from "@/store/modules/dataAnonymization";
const anonymizationStore = useDataAnonymizationStore();
const router = useRouter()
const { proxy } = getCurrentInstance() as any;
const searchItemList = ref([{
type: "input",
label: "",
field: "generalizeFileName",
default: "",
placeholder: "泛化文件名称",
clearable: true,
}, {
type: "select",
label: "",
field: "fieldType",
default: null,
options: fieldTypeList,
placeholder: "字段类型",
clearable: true,
filterable: true,
}])
/** 分页及搜索传参信息配置。 */
const page = ref({
...commonPageConfig,
generalizeFileName: '',
fieldType: ''
});
const tableInfo = ref({
id: 'data-file-table',
fields: [
{ label: "序号", type: "index", width: TableColumnWidth.INDEX, align: "center" },
{ label: "泛化文件名称", field: "generalizeFileName", width: 160 },
{ label: "字段类型", field: "fieldType", width: 120, getName: (scope) => {
return scope.row.fieldType && fieldTypeList.find(f => f.value == scope.row.fieldType)?.label || '--';
} },
{ label: "泛化层级", field: "generalizeLevel", width: 120, align: 'right', type: 'chnum' },
{ label: "修改人", field: "updateUserName", width: TableColumnWidth.USERNAME },
{ label: "修改时间", field: "updateTime", width: TableColumnWidth.DATETIME },
],
data: [],
page: {
type: "normal",
rows: 0,
...page.value,
},
loading: false,
actionInfo: {
label: "操作",
type: "btn",
width: 120,
fixed: 'right',
btns: (scope) => {
return [{
label: "编辑", value: "edit", click: (scope) => {
router.push({
name: 'generalizeFileEdit',
query: {
guid: scope.row.guid,
fileName: scope.row.generalizeFileName
}
});
}
}, {
label: "删除", value: "delete", disabled: scope.row.bizState == 'Y', click: (scope) => {
proxy.$openMessageBox("此操作将永久删除, 是否继续?", () => {
let guids = [scope.row.guid];
deleteGeneralizeFile(guids).then((res: any) => {
if (res?.code == proxy.$passCode) {
getTableData();
proxy.$ElMessage({
type: "success",
message: "删除成功",
});
} else {
proxy.$ElMessage({
type: "error",
message: res.msg,
});
}
});
}, () => {
proxy.$ElMessage.info("已取消");
})
}
}]
}
}
})
const toSearch = (val: any, clear: boolean = false) => {
if (clear) {
searchItemList.value.map((item) => (item.default = ""));
page.value.generalizeFileName = '';
page.value.fieldType = '';
} else {
page.value.generalizeFileName = val.generalizeFileName;
page.value.fieldType = val.fieldType;
}
getTableData();
};
const getTableData = () => {
tableInfo.value.loading = true
getGeneralizeFileList({
pageIndex: page.value.curr,
pageSize: page.value.limit,
generalizeFileName: page.value.generalizeFileName,
fieldType: page.value.fieldType
}).then((res: any) => {
if (res?.code == proxy.$passCode) {
const data = res.data || {}
tableInfo.value.data = data.records || []
tableInfo.value.page.limit = data.pageSize
tableInfo.value.page.curr = data.pageIndex
tableInfo.value.page.rows = data.totalRows
} else {
proxy.$ElMessage({
type: 'error',
message: res.msg,
})
}
tableInfo.value.loading = false
})
};
const tablePageChange = (info) => {
page.value.curr = Number(info.curr);
page.value.limit = Number(info.limit);
getTableData();
};
onBeforeMount(() => {
toSearch({});
})
onActivated(() => {
if (anonymizationStore.isRefresh) {//如果是首次加载，则不需要调用
page.value.curr = 1;
getTableData();
anonymizationStore.setIsRefresh(false);
}
})
const handleCreate = () => {
router.push({
name: 'generalizeFileEdit'
});
}
</script>
<template>
<div class="container_wrap">
<div class="table_tool_wrap">
<!-- 头部搜索 -->
<TableTools :searchItems="searchItemList" :searchId="'data-label-search'" @search="toSearch" :init="false" />
<div class="tools_btns">
<el-button type="primary" @click="handleCreate">新建</el-button>
</div>
</div>
<div class="table_panel_wrap">
<!-- 右侧标签管理表格 -->
<Table :tableInfo="tableInfo" @tablePageChange="tablePageChange" />
</div>
</div>
</template>
<style lang="scss" scoped>
.table_tool_wrap {
width: 100%;
height: 84px !important;
padding: 0 8px;
.tools_btns {
padding: 0px 0 0;
}
}
.table_panel_wrap {
width: 100%;
height: calc(100% - 84px);
padding: 0px 8px 0;
}
</style>
\ No newline at end of file
src/views/data_anonymization/resultProcess.vue deleted 100644 → 0
<route lang="yaml">
name: resultProcess
</route>
<script lang="ts" setup name="resultProcess">
import TableTools from "@/components/Tools/table_tools.vue";
import { commonPageConfig } from '@/components/PageNav/index';
import { TableColumnWidth } from "@/utils/enum";
import {
dataSourceTypeList,
getAnonTaskList,
deleteAnonTask,
} from '@/api/modules/dataAnonymization';
import { useValidator } from '@/hooks/useValidator';
import useDataAnonymizationStore from "@/store/modules/dataAnonymization";
const anonymizationStore = useDataAnonymizationStore();
const router = useRouter()
const { proxy } = getCurrentInstance() as any;
const { required } = useValidator();
const searchItemList = ref([{
type: "input",
label: "",
field: "taskName",
default: "",
placeholder: "任务名称",
clearable: true,
}, {
type: "select",
label: "",
field: "dataSource",
default: null,
options: dataSourceTypeList,
placeholder: "数据来源",
clearable: true,
filterable: true,
}])
/** 分页及搜索传参信息配置。 */
const page = ref({
...commonPageConfig,
taskName: '',
dataSource: null
});
const tableInfo = ref({
id: 'data-file-table',
fields: [
{ label: "序号", type: "index", width: TableColumnWidth.INDEX, align: "center" },
{ label: "任务名称", field: "taskName", width: 160 },
{
label: "数据来源", field: "dataSource", width: 100, getName: (scope) => {
return scope.row.dataSource && dataSourceTypeList.find(f => f.value == scope.row.dataSource)?.label || '--';
}
},
{ label: "任务状态", field: "sensitiveIdentifyTaskStatus", width: TableColumnWidth.STATE, align: 'center', type: "tag" },
{ label: "导出时间", field: "exportTime", width: TableColumnWidth.DATETIME },
{ label: "修改人", field: "updateUserName", width: TableColumnWidth.USERNAME },
{ label: "修改时间", field: "updateTime", width: TableColumnWidth.DATETIME },
],
data: [],
page: {
type: "normal",
rows: 0,
...page.value,
},
loading: false,
actionInfo: {
label: "操作",
type: "btn",
width: 180,
fixed: 'right',
btns: (scope) => {
return [{
label: "编辑", value: "edit", click: (scope) => {
router.push({
name: 'anonTaskCreate',
query: {
guid: scope.row.guid,
taskName: scope.row.taskName
}
});
}
}, {
label: '查看数据', value: 'view', disabled: scope.row.status != 'Y', click: (scope) => {
router.push({
name: 'anonResultView',
query: {
guid: scope.row.guid,
execGuid: scope.row.lastExecGuid,
taskName: scope.row.taskName
}
});
}
}, {
label: "删除", value: "delete", click: (scope) => {
proxy.$openMessageBox("此操作将永久删除, 是否继续?", () => {
let guids = [scope.row.guid];
deleteAnonTask(guids).then((res: any) => {
if (res?.code == proxy.$passCode) {
page.value.curr = 1;
getTableData();
proxy.$ElMessage({
type: "success",
message: "删除成功",
});
} else {
proxy.$ElMessage({
type: "error",
message: res.msg,
});
}
});
})
}
}]
}
}
})
const toSearch = (val: any, clear: boolean = false) => {
if (clear) {
searchItemList.value.map((item) => (item.default = ""));
page.value.taskName = '';
page.value.dataSource = null;
} else {
page.value.taskName = val.taskName;
page.value.dataSource = val.dataSource;
}
getTableData();
};
const getTableData = () => {
tableInfo.value.loading = true
getAnonTaskList({
pageIndex: page.value.curr,
pageSize: page.value.limit,
taskName: page.value.taskName,
dataSource: page.value.dataSource
}).then((res: any) => {
if (res?.code == proxy.$passCode) {
const data = res.data || {};
tableInfo.value.data = data.records?.map(d => {
d.sensitiveIdentifyTaskStatus = d.status;
return d;
}) || []
tableInfo.value.page.limit = data.pageSize
tableInfo.value.page.curr = data.pageIndex
tableInfo.value.page.rows = data.totalRows
} else {
proxy.$ElMessage({
type: 'error',
message: res.msg,
})
}
tableInfo.value.loading = false
})
};
const tablePageChange = (info) => {
page.value.curr = Number(info.curr);
page.value.limit = Number(info.limit);
getTableData();
};
const handleCreate = () => {
router.push({
name: 'anonTaskCreate'
});
}
onBeforeMount(() => {
toSearch({});
anonymizationStore.setIsAnonPageRefresh(false);
})
onActivated(() => {
if (anonymizationStore.isAnonPageRefresh) {//如果是首次加载，则不需要调用
page.value.curr = 1;
getTableData();
anonymizationStore.setIsAnonPageRefresh(false);
}
});
</script>
<template>
<div class="container_wrap">
<div class="table_tool_wrap">
<!-- 头部搜索 -->
<TableTools :searchItems="searchItemList" :searchId="'data-label-search'" @search="toSearch" :init="false" />
<div class="tools_btns">
<el-button type="primary" @click="handleCreate">新建</el-button>
</div>
</div>
<div class="table_panel_wrap">
<!-- 右侧标签管理表格 -->
<Table :tableInfo="tableInfo" @tablePageChange="tablePageChange" />
</div>
</div>
</template>
<style lang="scss" scoped>
.table_tool_wrap {
width: 100%;
height: 84px !important;
padding: 0 8px;
.tools_btns {
padding: 0px 0 0;
}
}
.table_panel_wrap {
width: 100%;
height: calc(100% - 84px);
padding: 0px 8px 0;
}
</style>
\ No newline at end of file
src/views/data_anonymization/sensitiveIdentifyTaskExecLog.vue deleted 100644 → 0
<route lang="yaml">
name: sensitiveIdentifyTaskExecLog
</route>
<script lang="ts" setup name="sensitiveIdentifyTaskExecLog">
import { ref } from "vue";
import { useRouter, useRoute } from "vue-router";
import Table from "@/components/Table/index.vue";
import { ElMessage } from "element-plus";
import { commonPageConfig } from '@/components/PageNav/index';
import {
getSensitiveDataTaskExecLog,
} from '@/api/modules/dataAnonymization';
import { TableColumnWidth } from "@/utils/enum";
const { proxy } = getCurrentInstance() as any;
const router = useRouter();
const route = useRoute();
const guid = route.query.guid;
const wordName = route.query.name
const page = ref({
...commonPageConfig
});
const tableInfo = ref({
id: "word-log-table",
loading: false,
fields: [
{ label: "序号", type: "index", width: TableColumnWidth.INDEX, align: "center" },
{ label: "执行人", field: "createUserName", width: TableColumnWidth.USERNAME },
{ label: "执行时间", field: "execTime", width: TableColumnWidth.DATETIME },
{ label: "执行状态", field: "sensitiveIdentifyTaskStatus", width: TableColumnWidth.STATE, align: 'center', type: "tag" },
{ label: "确认人", field: "confirmUserName", width: TableColumnWidth.USERNAME },
{ label: "确认时间", field: "confirmTime", width: TableColumnWidth.DATETIME },
{ label: "确认状态", field: "sensitiveIdentifyConfirmStatus", width: TableColumnWidth.STATE, align: 'center', type: "tag" },
],
data: [],
page: {
type: "normal",
rows: 0,
...page.value,
},
actionInfo: {
label: "操作",
type: "btn",
width: 100,
fixed: 'right',
btns: (scope) => {
return [{
label: "查看", value: "report", disabled: scope.row['status'] != 'Y', click: (scope) => {
router.push({
name: 'sensitiveIdentifyConfig',
query: {
guid: route.query.guid,
execGuid: scope.row.guid,
taskName: route.query.name,
isLook: '1',
}
});
}
}];
}
}
});
const getTableData = () => {
tableInfo.value.loading = true;
getSensitiveDataTaskExecLog({ pageIndex: page.value.curr, pageSize: page.value.limit, taskGuid: guid }).then((res: any) => {
tableInfo.value.loading = false;
if (res?.code == proxy.$passCode) {
const data = res.data || {}
tableInfo.value.data = data.records?.map(d => {
d.sensitiveIdentifyTaskStatus = d.status;
d.sensitiveIdentifyConfirmStatus = d.confirmStatus;
return d;
}) || []
tableInfo.value.page.limit = data.pageSize
tableInfo.value.page.curr = data.pageIndex
tableInfo.value.page.rows = data.totalRows
} else {
ElMessage.error(res.msg);
}
})
};
const tableBtnClick = (scope, btn) => {
const type = btn.value;
const row = scope.row;
if (type == 'reportView') {
router.push({
name: 'analysisReport',
query: {
planGuid: row.planGuid,
reportExecGuid: row.guid,
name: wordName
}
});
}
};
onActivated(() => {
getTableData();
});
</script>
<template>
<div class="container_wrap">
<div class="table_panel_wrap">
<Table :tableInfo="tableInfo" @tableBtnClick="tableBtnClick" />
</div>
</div>
</template>
<style lang="scss" scoped>
.container_wrap {
padding: 0;
.table_panel_wrap {
height: 100%;
padding: 16px 16px 0;
}
}
</style>
\ No newline at end of file
src/views/data_inventory/components/tableDefaultValue.vue deleted 100644 → 0
<template>
<el-select v-if="!readonly && isEdit && isSelectType(dbType, scope)" v-model="scope.row['defaultValue']" placeholder="请选择" collapse-tags-tooltip
filterable allow-create default-first-option :reserve-keyword="false">
<el-option v-for="opt in optionsConfig[dataType]" :key="opt['value']" :label="opt['label']" :value="opt['value']" />
</el-select>
<el-date-picker v-else-if="!readonly && isEdit && dataType === 'date'" v-model="scope.row['defaultValue']" type="date"
format="YYYY-MM-DD" value-format="YYYY-MM-DD" placeholder="请选择" />
<el-date-picker v-else-if="!readonly && isEdit && dbType === 'mysql' && dataType === 'datetime'"
v-model="scope.row['defaultValue']" placeholder="请选择" type="datetime" format="YYYY-MM-DD HH:mm:ss"
value-format="YYYY-MM-DD HH:mm:ss" />
<el-input v-else-if="!readonly && isEdit" v-model.trim="scope.row['defaultValue']" placeholder="请填写"
@input="(val) => inputChange(val, scope.row.dataType, scope)" />
<span v-else>{{ scope.row["defaultValue"] == null ? '--' : (isSelectType(dbType, scope) ?
(optionsConfig[dataType].find(s => s.value == scope.row["defaultValue"])?.label ??
scope.row["defaultValue"]) : scope.row["defaultValue"]) }}</span>
</template>
<script lang="ts" setup name="tableDefaultValue">
import { ref } from "vue";
import { useDefault } from "@/hooks/useDefault";
const { optionsConfig, inputChange, isSelectType } = useDefault()
const props = defineProps({
dbType: {
type: String,
default: ''
},
scope: {
type: Object,
default: {}
},
readonly: {
type: Boolean,
default: false
}
})
const isEdit = computed(() => {
return props.scope.row['isEdit'];
});
const dataType = computed(() => {
return props.scope.row['dataType'];
});
</script>
\ No newline at end of file
src/views/data_inventory/newCreateClass.vue deleted 100644 → 0
<route lang="yaml">
name: newCreateClass //新增分级分类模板
</route>
<script lang="ts" setup name="newCreateClass">
import router from "@/router";
import { getMetaDataBase } from '@/api/modules/dataMetaService';
import { ref } from "vue";
onMounted(async () => {
const params = {
pageIndex: 1,
pageSize: -1,
}
const res = await getMetaDataBase(params)
console.log(res);
});
// 表单引用
const formRef = ref();
const tableRef = ref();
const fullscreenLoading = ref(false);
const isExpand = ref(true);
const newCreateClassFormItems = ref([{
label: '分类名称',
type: 'input',
maxlength: 50,
placeholder: '请输入',
field: 'categoryName',
default: '',
clearable: true,
required: true
}, {
label: '引用分级标准',
type: 'select',
placeholder: '请选择',
field: 'ReferenceGradingStandard',
default: '',
options: [], //TODO
required: true,
filterable: true,
clearable: true,
visible: true,
}]);
const formRules = ref({
templeteName: [
{ required: true, message: '请输入模板名称', trigger: 'blur' },
{ max: 50, message: '长度在 50 个字符以内', trigger: 'blur' }
],
industryCategory: [
{ required: true, message: '请选择行业分类', trigger: 'change' }
],
gradingStandard: [
{ required: true, message: '请选择分级标准', trigger: 'change' }
]
});
const tableInfo = ref({
id: "data-class-standard-table",
fields: [
{ label: "序号", type: "index", width: 56, align: "center" },
{ label: "层级", field: "databaseNameZh", width: 160, },
{ label: "状态", field: "databaseName", width: 120, },
{ label: "定义说明", field: "tableCount", width: 120, align: "right", },
{ label: "最低安全级别", field: "storageCapacities", align: "right", width: 220, },
{ label: "创建时间", field: "columns", width: 140, align: "right", },
],
actionInfo: {
show: false,
},
data: [
{
index: 1,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
{
index: 2,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
{
index: 3,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
{
index: 4,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
{
index: 5,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
{
index: 6,
databaseNameZh: "数据库名称",
databaseName: "数据库名",
tableCount: 0,
storageCapacities: 0,
columns: 0,
},
],
showPage: false,
loading: false,
});
const onTableSelectChange = (selection: any[]) => {
console.log(selection);
};
const cancel = () => {
// 返回上一页路由
router.back();
};
const save = async () => {
console.log('save');
// 校验表单
const res = formRef.value;
res.ruleFormRef.validate((valid: any) => {
if (valid) {
// 表单校验通过
console.log('表单校验通过');
} else {
console.log('表单校验不通过');
return false;
}
});
};
</script>
<template>
<div class="container_wrap" v-loading="fullscreenLoading">
<div class="content_main">
<ContentWrap id="id-baseInfo" title="基础信息" description="" style="margin-top: 8px;" :expandSwicth=isExpand>
<Form ref="formRef" :itemList="newCreateClassFormItems" formId="main-model-edit" col="col3" :rules=formRules />
</ContentWrap>
<ContentWrap id="id-classStandard" class="detail-content" title="分类标准" description="" style="margin-top:16px;"
:expandSwicth=isExpand>
<div class="table-content_wrap">
<Table ref="tableRef" :tableInfo="tableInfo" />
</div>
</ContentWrap>
</div>
<div class="bottom_tool_wrap">
<el-button @click="cancel">取消</el-button>
<el-button type="primary" @click="save">后台运行</el-button>
</div>
</div>
</template>
<style lang="scss" scoped>
.container_wrap {
padding: 0px;
}
.content_main {
height: calc(100% - 44px);
padding: 10px 16px;
.table-content_wrap {
width: 100%;
height: 213px;
}
}
.bottom_tool_wrap {
display: flex;
justify-content: center;
border-top: 1px solid #D9D9D9;
padding-top: 8px;
}
</style>
src/views/data_inventory/newCreateTemplate.vue deleted 100644 → 0
<route lang="yaml">
name: newCreateTemplate //新增分级分类模板
</route>
<script lang="ts" setup name="newCreateTemplate">
import router from "@/router";
import { getMetaDataBase } from '@/api/modules/dataMetaService';
import { ref } from "vue";
import { getClassifyGradList, saveCgTemplate } from "@/api/modules/dataInventory";
onMounted(async () => {
const params = {
pageIndex: 1,
pageSize: -1,
}
const res = await getMetaDataBase(params);
tableInfo.value.data = res.data.records;
getGradListData();
getClassifyDataList();
});
const { proxy } = getCurrentInstance() as any;
const refGradePageParams = ref({
pageIndex: 1,
pageSize: -1,
type: "G"
});
const refClassifyPageParams = ref({
pageIndex: 1,
pageSize: -1,
type: "C"
});
const gradListData = ref([]);
const classifyDataList = ref([]);
// 获取分级列表
const getGradListData = async () => {
const res: any = await getClassifyGradList(refGradePageParams.value);
gradListData.value = res.data.records;
newCreateTemplateFormItems.value[2].options = gradListData.value;
};
// 获取分类列表
const getClassifyDataList = async () => {
const res: any = await getClassifyGradList(refClassifyPageParams.value);
classifyDataList.value = res.data.records;
newCreateTemplateFormItems.value[1].options = classifyDataList.value;
};
// 表单引用
const formRef = ref();
const tableRef = ref();
// 元数据metaGuids
const metaGuids = ref<any>([]);
const fullscreenLoading = ref(false);
const isExpand = ref(true);
const newCreateTemplateFormItems = ref([{
label: '模板名称',
type: 'input',
maxlength: 50,
placeholder: '请输入',
field: 'templateName',
default: '',
clearable: true,
required: true
}, {
label: '行业分类',
type: 'select',
placeholder: '请选择',
field: 'classifyGuid',
default: '',
options: [], //TODO
props: {
label: 'name',
value: 'guid'
},
required: true,
filterable: true,
clearable: true,
visible: true,
}, {
label: '分级标准',
type: 'select',
placeholder: '请选择',
field: 'gradeGuid',
default: '',
options: [], //TODO
props: {
label: 'name',
value: 'guid'
},
required: true,
filterable: true,
clearable: true,
visible: true,
}]);
const formRules = ref({
templeteName: [
{ required: true, message: '请输入模板名称', trigger: 'blur' },
{ max: 50, message: '长度在 50 个字符以内', trigger: 'blur' }
],
industryCategory: [
{ required: true, message: '请选择行业分类', trigger: 'change' }
],
gradingStandard: [
{ required: true, message: '请选择分级标准', trigger: 'change' }
]
});
const tableInfo = ref({
id: "data-class-standard-table",
multiple: true,
fields: [
{ label: "序号", type: "index", width: 56, align: "center" },
{ label: "数据库名称", field: "databaseNameZh", width: 160, },
{ label: "数据库名", field: "databaseName", width: 120, },
{ label: "总表数", field: "tableCount", width: 120, align: "right", },
{ label: "存储量（约/MB）", field: "storageCapacities", align: "right", width: 220, },
{ label: "总字段数", field: "columns", width: 140, align: "right", },
],
actionInfo: {
show: false,
},
data: [],
showPage: false,
loading: false,
});
const onTableSelectChange = (selection: any[]) => {
// 遍历选中的元数据guid，然后存入metaGuids数组中
metaGuids.value = selection.map((item: any) => item.guid);
};
const cancel = () => {
// 返回上一页路由
router.back();
};
const save = async () => {
console.log('save');
// 校验表单
const formRes = formRef.value;
formRes.ruleFormRef.validate(async (valid: any) => {
if (valid) {
// 表单校验通过
const formData = formRes.formInline;
const params = {
...formData,
metaGuids: metaGuids.value,
version: 0
};
const res: any = await saveCgTemplate(params);
if (res.code == proxy.$passCode) {
// 保存成功
proxy.$ElMessage.success(res.msg);
} else {
// 保存失败
proxy.$ElMessage.error(res.msg);
}
} else {
console.log('表单校验不通过');
return false;
}
});
};
</script>
<template>
<div class="container_wrap" v-loading="fullscreenLoading">
<div class="content_main">
<ContentWrap id="id-baseInfo" title="模板信息" description="" style="margin-top: 8px;" :expandSwicth=isExpand>
<Form ref="formRef" :itemList="newCreateTemplateFormItems" formId="main-model-edit" col="col3"
:rules=formRules />
</ContentWrap>
<ContentWrap id="id-classStandard" class="detail-content" title="选择元数据" description="" style="margin-top:16px;"
:expandSwicth=isExpand>
<div class="table-content_wrap">
<Table ref="tableRef" :tableInfo="tableInfo" @tableSelectionChange="onTableSelectChange" />
</div>
</ContentWrap>
</div>
<div class="bottom_tool_wrap">
<el-button @click="cancel">取消</el-button>
<el-button type="primary" @click="save">后台运行</el-button>
</div>
</div>
</template>
<style lang="scss" scoped>
.container_wrap {
padding: 0px;
}
.content_main {
height: calc(100% - 44px);
padding: 10px 16px;
.table-content_wrap {
width: 100%;
height: 213px;
}
}
.bottom_tool_wrap {
display: flex;
justify-content: center;
border-top: 1px solid #D9D9D9;
padding-top: 8px;
}
</style>
src/views/data_inventory/taskConfig.vue deleted 100644 → 0
<route lang="yaml">
name: taskConfig //分类分级任务
</route>
<script lang="ts" setup name="taskConfig">
import { ref, onMounted } from "vue";
import { useRouter, useRoute } from "vue-router";
import { ElMessage, ElMessageBox } from "element-plus";
import useDataAssetStore from "@/store/modules/dataAsset";
import { filterVal, getCgTaskPageList, cgTaskDelete, runExecTask } from "@/api/modules/dataInventory";
import { getClassifyGradList } from "@/api/modules/dataInventory";
import { TableColumnWidth } from '@/utils/enum';
const { proxy } = getCurrentInstance() as any;
const router = useRouter();
const assetStore = useDataAssetStore();
const loading = ref(false);
const page = ref({
limit: 50,
curr: 1,
sizes: [
{ label: "10", value: 10 },
{ label: "50", value: 50 },
{ label: "100", value: 100 },
{ label: "150", value: 150 },
{ label: "200", value: 200 },
],
});
const searchItemValue: any = ref({});
const currTableData: any = ref({});
const tableInfo = ref({
id: "mapping-table",
fields: [
{ label: "序号", type: "index", width: 56, align: "center", fixed: "left" },
{ label: "任务名称", field: "taskName", width: 96 },
{
label: "目录名称", field: "cgDirName", width: 120, type: "text_btn", click: (scope) => {
scope.row.confirmCnt > 0 && router.push({ name: "classifyGradeCatalogue", });
}
},
{
label: "元数据", field: "metaNames", width: 200, getName: (scope) => {
const metaNames = scope.row.metaNames || [];
return metaNames.join(',');
}
},
{
label: "执行状态", field: "status", width: TableColumnWidth.STATE, align: 'center', type: "tag", getName: (scope) => {
return filterVal(scope.row.status, 'status');
}, tagType: (scope) => {
return scope.row.status == 'Y' ? 'success' : scope.row.status == 'E' ? 'danger' : 'info';
}
},
{ label: "任务修改人", field: "updateUserName", width: 120 },
{ label: "修改时间", field: "updateTime", width: TableColumnWidth.DATETIME },
{ label: "确认次数", field: "confirmCnt", width: 96, align: 'right' },
{ label: "结果确认人", field: "confirmUserName", width: 120 },
{ label: "确认时间", field: "confirmTime", width: TableColumnWidth.DATETIME },
{
label: "结果状态", field: "confirmStatus", width: TableColumnWidth.STATE, align: 'center', type: "tag", getName: (scope) => {
return filterVal(scope.row.confirmStatus, 'confirmStatus');
}, tagType: (scope) => {
return scope.row.confirmStatus == 'Y' ? 'success' : 'warning';
}
},
],
data: [],
showPage: false,
actionInfo: {
label: "操作",
type: "btn",
width: 280,
btns: (scope) => {
let row = scope.row, btnArr: any = [
{ label: "手动执行", value: "run", disabled: row.status != 'Y' && row.status != 'E' },
{ label: "编辑", value: "edit", disabled: row.status != 'Y' && row.status != 'E' },
{ label: "日志", value: "log" },
{ label: "删除", value: "delete", disabled: row.status != 'Y' && row.status != 'E' }
];
if (row.confirmStatus == 'Y') {
btnArr.splice(0, 0, { label: "结果修改", value: "modify" });
} else {
btnArr.splice(0, 0, { label: "结果确认", value: "confirm", disabled: row.status != 'Y' });
}
return btnArr;
},
},
});
const getTableData = () => {
loading.value = true;
getCgTaskPageList(
Object.assign({}, searchItemValue.value, {
pageIndex: page.value.curr,
pageSize: -1,
})
).then((res: any) => {
loading.value = false;
if (res.code == proxy.$passCode) {
let data = res.data.records || [];
data.map(item => {
item.cellClass = item.confirmCnt > 0 ? '' : 'is-regular'
})
tableInfo.value.data = data;
} else {
ElMessage({
type: "error",
message: res.msg,
});
}
})
.catch((res) => {
loading.value = false;
});
};
const tableBtnClick = (scope, btn) => {
const type = btn.value;
const row = scope.row;
currTableData.value = row;
if (type == 'confirm' || type == 'modify' || type == 'edit' || type == "log") {
toPath(type);
} else if (type == 'run') {
const params = { guid: currTableData.value.guid };
runExecTask(params).then((res: any) => {
if (res.code == proxy.$passCode) {
getTableData();
} else {
ElMessage({
type: "error",
message: res.msg,
});
}
}).catch((res) => {
ElMessage({
type: "error",
message: '请求失败',
});
});
} else if (type === "delete") {
open("此操作将永久删除，是否继续？", "warning");
}
};
const toPath = (type) => {
if (type == 'add') {
loading.value = true;
getClassifyGradList({ pageIndex: 1, pageSize: 50, type: 'C' }).then((res: any) => {
loading.value = false;
if (res.code == proxy.$passCode) {
const data = res.data?.records || []
if (data.length == 0) {
ElMessageBox.confirm('系统未创建分类分级规则，是否跳转去新建', "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: 'warning',
}).then(() => {
router.push({
name: "templateConfig",
});
});
} else {
router.push({
name: "taskEdit",
query: {
type
},
});
}
}
}).catch(() => {
loading.value = false;
ElMessage({
type: "error",
message: '请求失败',
});
})
} else if (type == 'edit') {
router.push({
name: "taskEdit",
query: {
guid: currTableData.value.guid,
name: currTableData.value.taskName,
type
},
});
} else if (type == 'confirm' || type == 'modify') {
sessionStorage.setItem('taksExecGuid', '');
router.push({
name: "taskDetail",
query: {
guid: currTableData.value.guid,
name: currTableData.value.taskName,
status: currTableData.value.confirmStatus,
type
},
});
} else {
router.push({
name: "taskLog",
query: {
guid: currTableData.value.guid,
name: currTableData.value.taskName,
type
},
});
}
}
const open = (msg, type, isBatch = false) => {
ElMessageBox.confirm(msg, "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: type,
}).then(() => {
const guids = [currTableData.value.guid];
cgTaskDelete(guids).then((res: any) => {
if (res.code == proxy.$passCode) {
getTableData();
ElMessage({
type: "success",
message: "删除成功",
});
} else {
ElMessage({
type: "error",
message: res.msg,
});
}
}).catch((res) => {
});
});
};
onActivated(() => {
if (assetStore.isRefresh) {//如果是首次加载，则不需要调用
getTableData()
assetStore.set(false);
}
})
onBeforeMount(() => {
getTableData()
})
</script>
<template>
<div class="container_wrap" v-loading="loading">
<div class="table_tool_wrap" v-if="tableInfo.data.length">
<div class="table_title">
<span>分类分级任务</span>
<div class="title_tool">
<el-button @click="getTableData" v-preReClick>刷新结果</el-button>
<span class="tips_text">刷新查看任务最新执行结果</span>
</div>
</div>
</div>
<div class="table_panel_wrap" v-if="tableInfo.data.length">
<Table :tableInfo="tableInfo" @tableBtnClick="tableBtnClick" />
</div>
<div class="card-noData" v-else>
<img src="@/assets/images/no-data.png" :style="{ width: '96px', height: '96px' }" />
<p>暂无分类分级任务，<span class="text_btn" @click="toPath('add')">去新建</span></p>
</div>
</div>
</template>
<style scoped lang="scss">
.table_tool_wrap {
width: 100%;
min-height: unset;
padding: 0 8px;
.table_title {
height: 40px;
line-height: 40px;
font-weight: 600;
font-size: 16px;
color: #212121;
display: flex;
.title_tool {
display: flex;
margin-left: 16px;
align-items: center;
.tips_text {
margin-left: 16px;
font-size: 14px;
color: #b2b2b2;
}
}
}
}
.table_panel_wrap {
width: 100%;
height: calc(100% - 40px);
padding: 8px 8px 16px;
}
.card-noData {
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
display: flex;
flex-direction: column;
align-items: center;
}
</style>
Styling with Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!