entity.ts
6.72 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/**
* 在axios的get请求中{a: 1, b: [1, 2]}需要转换为{a: 1, b: "1, 2"}
*/
export function ParamArrToStr(params: any) {
if (typeof params != 'object') {
return params;
}
if (params instanceof Array) {
return params.join(",");
}
const _params = deepClone(params);
// eslint-disable-next-line guard-for-in
for (let key in _params) {
_params[key] = ParamArrToStr(_params[key]);
}
return _params;
}
/**
* 深拷贝
*/
//利用 WeekMap() 的键对自己所引用对象的引用都是弱引用的特性,在没有其他引用和该键引用同一对象的情况下,这个对象将会被垃圾回收
//为了解决循环引用的问题,设置一个哈希表存储已拷贝过的对象进行循环检测,当检测到当前对象已存在于哈希表中时,取出该值并返回即可
export function deepClone(obj: any, hash = new WeakMap()) {
function isComplexDataType(obj: any) {
return (typeof obj === 'object' || typeof obj === 'function') && (obj !== null);
}
//查哈希表,防止循环拷贝。如果成环了(对象循环引用),参数obj = obj.loop = 最初的obj,则会在WeakMap中找到第一次放入的obj提前返回第一次放入WeakMap的cloneObj,解决对象循环引用的问题
if (hash.has(obj)) return hash.get(obj);
//如果参数为Date, RegExp, Set, Map, WeakMap, WeakSet等引用类型,则直接生成一个新的实例
let type = [Date, RegExp, Set, Map, WeakMap, WeakSet];
if (type.includes(obj.constructor)) return new obj.constructor(obj);
//遍历传入参数所有属性描述符
let allDesc = Object.getOwnPropertyDescriptors(obj);
//继承原型
let cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc);
// 获取所有 Symbol 类型键
let symKeys = Object.getOwnPropertySymbols(obj);
// 拷贝 Symbol 类型键对应的属性
if (symKeys.length > 0) {
symKeys.forEach(symKey => {
cloneObj[symKey] = isComplexDataType(obj[symKey]) ? deepClone(obj[symKey], hash) : obj[symKey];
});
}
// 哈希表设值
hash.set(obj, cloneObj);
//Reflect.ownKeys(obj)拷贝不可枚举属性和符号类型
for (let key of Reflect.ownKeys(obj)) {
cloneObj[key] =
(isComplexDataType(obj[key]) && typeof obj[key] !== 'function') ? deepClone(obj[key], hash) : obj[key];
}
return cloneObj;
}
export function flattenDeep(list: any[] = []): any[] {
const arr: any[] = [];
if (list instanceof Array) {
for (let ele of list) {
if (ele instanceof Array) {
const arr1 = flattenDeep(ele);
for (let ele1 of arr1) {
arr.push(ele1);
}
} else {
arr.push(ele);
}
}
}
return arr;
}
export function groupBy(list: any[], key: string) {
const data: any[] = [];
for (let listEle of list) {
let item = data.find(i => i[key] == listEle[key]);
if (!item) {
item = deepClone({...listEle, list: []});
data.push(item);
}
item.list.push(listEle);
}
return data;
}
export function groupBys(list: any[], key1: string, key2: string) {
const data: any[] = [];
for (let listEle of list) {
let item = data.find(i => i[key1] == listEle[key1] && i[key2] == listEle[key2]);
if (!item) {
item = deepClone({...listEle, list: []});
data.push(item);
}
item.list.push(listEle);
}
return data;
}
export function numFormat(num: number = 0, unit?: string): string {
return (unit == '%' ? num * 100 : unit == '万元' ? num / 10000 : num).toFixed(2);
}
/**机油类型 */
export const motorOilTypeData = [
{ value: '全合成机油', label: "全合成机油" },
{ value: '半合成机油', label: "半合成机油" },
{ value: '矿物机油', label: "矿物机油" },
];
/**机油等级 */
export const oilLevelData = [
{value: "SA", label: "SA"},
{value: "SB", label: "SB"},
{value: "SC", label: "SC"},
{value: "SD", label: "SD"},
{value: "SE", label: "SE"},
{value: "SF", label: "SF"},
{value: "SG", label: "SG"},
{value: "SH", label: "SH"},
{value: "SJ", label: "SJ"},
{value: "SL", label: "SL"},
{value: "SM", label: "SM"},
{value: "SN", label: "SN"},
{value: "CA", label: "CA"},
{value: "CB", label: "CB"},
{value: "CC", label: "CC"},
{value: "CD", label: "CD"},
{value: "CE", label: "CE"},
{value: "CF", label: "CF"},
{value: "CF-2", label: "CF-2"},
{value: "CF-4", label: "CF-4"},
{value: "CG-4", label: "CG-4"},
{value: "CH-4", label: "CH-4"},
{value: "CI-4", label: "CI-4"},
{value: "NE1", label: "NE1"},
];
/**粘稠度 */
export const oilViscosityData = [
{value: "0W-20", label: "0W-20"},
{value: "0W-30", label: "0W-30"},
{value: "0W-40", label: "0W-40"},
{value: "0W-50", label: "0W-50"},
{value: "0W-60", label: "0W-60"},
{value: "5W-20", label: "5W-20"},
{value: "5W-30", label: "5W-30"},
{value: "5W-40", label: "5W-40"},
{value: "5W-50", label: "5W-50"},
{value: "5W-60", label: "5W-60"},
{value: "10W-20", label: "10W-20"},
{value: "10W-30", label: "10W-30"},
{value: "10W-40", label: "10W-40"},
{value: "10W-50", label: "10W-50"},
{value: "10W-60", label: "10W-60"},
{value: "15W-20", label: "15W-20"},
{value: "15W-30", label: "15W-30"},
{value: "15W-40", label: "15W-40"},
{value: "15W-50", label: "15W-50"},
{value: "15W-60", label: "15W-60"},
{value: "20W-20", label: "20W-20"},
{value: "20W-30", label: "20W-30"},
{value: "20W-40", label: "20W-40"},
{value: "20W-50", label: "20W-50"},
{value: "20W-60", label: "20W-60"}
];
/**燃油种类 */
export const fuelTypeData = [
{ value: '汽油', label: "汽油" },
{ value: '柴油', label: "柴油" },
];
/**配件类型*/
export const partTypeData = [
{ value: 1, label: "配件" },
{ value: 2, label: "装潢" },
{ value: 4, label: "养护" },
{ value: 5, label: "机修辅料" },
{ value: 6, label: "钣金辅料" },
{ value: 7, label: "喷漆辅料" },
{ value: 8, label: "装潢辅料" },
{ value: 9, label: "打磨辅料" },
];
/**配件类型*/
export const planPoolTypeData = [
{ value: 11, label: "指定金额计划" },
{ value: 12, label: "最低库销比计划" },
{ value: 13, label: "指定配件计划" },
{ value: 10, label: "客户订件计划" },
];
export const typeReceiverObj: {[key: string]: string} = {
'售后工单锁定': '服务',
'装潢零售锁定': '销售',
'调出锁定': '',
'': '',
};
export const typeSenderObj: {[key: string]: string} = {
'售后工单锁定': '送修人:',
'装潢零售锁定': '下单人:',
'调出锁定': '',
'': '',
};
export function getUrl(url: string, obj: object): string {
if (!Object.keys(obj).length) {
return url;
}
const pa: string[] = [];
for (let k in obj) {
if (obj[k]) {
pa.push(`${k}=${obj[k]}`);
}
}
const st = pa.join("&");
if (st) {
return `${url}?${st}`;
}
return '';
}