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