|
|
1
2
3
4
5
6
|
/**
* 字典 util
* author: scott
* date: 20190109
*/
|
|
|
7
|
import {ajaxGetDictItems, getDictItemsFromCache} from '@/api/api'
|
|
|
8
9
10
11
12
13
14
15
16
17
18
|
/**
* 获取字典数组
* @param dictCode 字典Code
* @return List<Map>
*/
export async function initDictOptions(dictCode) {
if (!dictCode) {
return '字典Code不能为空!';
}
//优先从缓存中读取字典配置
|
|
|
19
|
if (getDictItemsFromCache(dictCode)) {
|
|
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
let res = {}
res.result = getDictItemsFromCache(dictCode);
res.success = true;
return res;
}
//获取字典数组
let res = await ajaxGetDictItems(dictCode);
return res;
}
/**
* 字典值替换文本通用方法
* @param dictOptions 字典数组
* @param text 字典值
* @return String
*/
export function filterDictText(dictOptions, text) {
// --update-begin----author:sunjianlei---date:20200323------for: 字典翻译 text 允许逗号分隔 ---
if (text != null && Array.isArray(dictOptions)) {
let result = []
// 允许多个逗号分隔，允许传数组对象
let splitText
if (Array.isArray(text)) {
splitText = text
} else {
splitText = text.toString().trim().split(',')
}
for (let txt of splitText) {
let dictText = txt
for (let dictItem of dictOptions) {
if (txt.toString() === dictItem.value.toString()) {
dictText = (dictItem.text || dictItem.title || dictItem.label)
break
}
}
result.push(dictText)
}
return result.join(',')
}
return text
// --update-end----author:sunjianlei---date:20200323------for: 字典翻译 text 允许逗号分隔 ---
}
/**
* 字典值替换文本通用方法(多选)
* @param dictOptions 字典数组
* @param text 字典值
* @return String
*/
export function filterMultiDictText(dictOptions, text) {
//js “!text” 认为0为空，所以做提前处理
|
|
|
71
72
|
if (text === 0 || text === '0') {
if (dictOptions) {
|
|
|
73
74
75
76
77
78
79
80
|
for (let dictItem of dictOptions) {
if (text == dictItem.value) {
return dictItem.text
}
}
}
}
|
|
|
81
|
if (!text || text == 'null' || !dictOptions || dictOptions.length == 0) {
|
|
|
82
83
84
85
86
87
|
return ""
}
let re = "";
text = text.toString()
let arr = text.split(",")
dictOptions.forEach(function (option) {
|
|
|
88
89
|
if (option) {
for (let i = 0; i < arr.length; i++) {
|
|
|
90
|
if (arr[i] === option.value) {
|
|
|
91
|
re += option.text + ",";
|
|
|
92
93
94
95
96
|
break;
}
}
}
});
|
|
|
97
|
if (re == "") {
|
|
|
98
99
|
return text;
}
|
|
|
100
|
return re.substring(0, re.length - 1);
|
|
|
101
102
103
104
105
106
107
108
|
}
/**
* 翻译字段值对应的文本
* @param children
* @returns string
*/
export function filterDictTextByCache(dictCode, key) {
|
|
|
109
|
if (key == null || key.length == 0) {
|
|
|
110
111
112
113
114
|
return;
}
if (!dictCode) {
return '字典Code不能为空!';
}
|
|
|
115
116
|
//优先从缓存中读取字典配置
if (getDictItemsFromCache(dictCode)) {
|
|
|
117
|
let item = getDictItemsFromCache(dictCode).filter(t => t["value"] == key)
|
|
|
118
|
if (item && item.length > 0) {
|
|
|
119
120
121
122
123
124
125
|
return item[0]["text"]
}
}
}
/** 通过code获取字典数组 */
export async function getDictItems(dictCode, params) {
|
|
|
126
127
128
129
130
|
//优先从缓存中读取字典配置
if (getDictItemsFromCache(dictCode)) {
let desformDictItems = getDictItemsFromCache(dictCode).map(item => ({...item, label: item.text}))
return desformDictItems;
}
|
|
|
131
|
|
|
|
132
133
134
135
136
137
138
139
|
//缓存中没有，就请求后台
return await ajaxGetDictItems(dictCode, params).then(({success, result}) => {
if (success) {
let res = result.map(item => ({...item, label: item.text}))
console.log('------- 从DB中获取到了字典-------dictCode : ', dictCode, res)
return Promise.resolve(res)
} else {
console.error('getDictItems error: : ', res)
|
|
|
140
|
return Promise.resolve([])
|
|
|
141
142
143
144
145
|
}
}).catch((res) => {
console.error('getDictItems error: ', res)
return Promise.resolve([])
})
|
|
|
146
|
}
|
