import { EnumValue, enumValueObj } from '@/api/dataset'
|
|
let filterEnumMap = {}
|
|
const filterIdNameEnumMap = {}
|
|
const findFilterEnum = async (val: EnumValue) => {
|
const queryId = val.queryId
|
const displayId = val.displayId
|
const arr = await enumValueObj({ queryId: queryId, displayId: displayId, searchText: '' })
|
return arr?.reduce((acc, item) => {
|
acc[item[displayId]] = item[queryId]
|
return acc
|
}, {})
|
}
|
|
export const filterEnumParams = (queryParams, fieldId: string) => {
|
const resultMap = filterEnumMap[fieldId]
|
if (resultMap) {
|
const resultParams = []
|
queryParams.forEach(param => {
|
resultParams.push(resultMap[param] || param)
|
})
|
return resultParams
|
} else {
|
return queryParams
|
}
|
}
|
|
export const filterEnumParamsReduce = (queryParams, fieldId: string) => {
|
const resultMap = filterEnumMap[fieldId]
|
if (resultMap) {
|
const resultMapReduce = Object.fromEntries(
|
Object.entries(resultMap).map(([key, value]) => [value, key])
|
)
|
const resultParams = []
|
queryParams.forEach(param => {
|
resultParams.push(resultMapReduce[param] || param)
|
})
|
return resultParams
|
} else {
|
return queryParams
|
}
|
}
|
|
export const filterEnumMapSync = async componentData => {
|
filterEnumMap = {}
|
for (const element of componentData) {
|
if (element.component === 'VQuery') {
|
for (const filterItem of element.propValue) {
|
const { optionValueSource, field, displayId } = filterItem
|
if (optionValueSource === 1 && field.id) {
|
filterEnumMap[field.id] = await findFilterEnum({
|
queryId: field.id,
|
displayId,
|
searchText: ''
|
})
|
}
|
}
|
}
|
}
|
}
|
|
export function filterParamsOptions(params, paramsOption) {
|
// 如果 params 为空，直接返回 null
|
if (!params || (Array.isArray(params) && params.length === 0)) {
|
return null
|
}
|
// 如果 paramsOption 为空，直接返回 null
|
if (!paramsOption || paramsOption.length === 0) {
|
return null
|
}
|
// 创建 paramsOption 集合和前缀集合用于快速查找
|
const optionSet = new Set(paramsOption)
|
const prefixSet = new Set()
|
// 收集所有可能的父级前缀
|
paramsOption.forEach(option => {
|
if (option.includes('-de-')) {
|
const parts = option.split('-de-')
|
// 收集所有前缀：父级、祖父级等
|
for (let i = 1; i < parts.length; i++) {
|
const prefix = parts.slice(0, i).join('-de-')
|
prefixSet.add(prefix)
|
}
|
}
|
})
|
|
// 检查一个值是否在 paramsOption 中存在（考虑层级关系）
|
function checkValueExists(value) {
|
// 直接存在
|
if (optionSet.has(value)) {
|
return true
|
}
|
// 如果是层级结构，检查所有父级前缀
|
if (value.includes('-de-')) {
|
const parts = value.split('-de-')
|
|
// 检查所有可能的父级前缀
|
for (let i = 1; i < parts.length; i++) {
|
const prefix = parts.slice(0, i).join('-de-')
|
if (optionSet.has(prefix)) {
|
return true
|
}
|
}
|
}
|
|
// 检查该值是否是某个选项的父级
|
// 如：paramsOption 中有 "香橙店-de-浓郁椰奶"，传入 "香橙店" 也应该匹配
|
if (
|
Array.from(optionSet).some(option => option.startsWith(value + '-de-') || option === value)
|
) {
|
return true
|
}
|
// 检查该值是否是某个选项的前缀（通过 prefixSet）
|
if (prefixSet.has(value)) {
|
return true
|
}
|
return false
|
}
|
// 处理单值情况（字符串）
|
if (typeof params === 'string') {
|
return checkValueExists(params) ? params : null
|
}
|
// 处理数组情况
|
if (Array.isArray(params)) {
|
// 过滤出存在的值
|
const filtered = params.filter(value => typeof value === 'string' && checkValueExists(value))
|
// 如果过滤后为空，返回 null，否则返回过滤后的数组
|
return filtered.length > 0 ? filtered : null
|
}
|
// 其他类型返回 null
|
return null
|
}
|
