3812 lines
146 KiB
JavaScript
3812 lines
146 KiB
JavaScript
// 导入 h 函数
|
||
const { createApp, ref, reactive, onMounted, onUnmounted,nextTick, watch, h, computed } = Vue;
|
||
const { ElMessage, ElMessageBox, ElTableV2, ElCheckbox,ElLoading } = ElementPlus;
|
||
// 获取 URL 参数中的 BJDID
|
||
function getUrlParameter(name) {
|
||
const urlParams = new URLSearchParams(window.location.search);
|
||
return urlParams.get(name) || '';
|
||
}
|
||
|
||
function getControlValue(controlId) {
|
||
const exact = document.getElementById(controlId);
|
||
if (exact && typeof exact.value !== 'undefined') {
|
||
return exact.value || '';
|
||
}
|
||
const bySuffix = document.querySelector(`[id$="${controlId}"]`);
|
||
if (bySuffix && typeof bySuffix.value !== 'undefined') {
|
||
return bySuffix.value || '';
|
||
}
|
||
return '';
|
||
}
|
||
|
||
// 获取 BJDID，优先从 URL 参数，其次从输入框
|
||
function getBJDID() {
|
||
// 优先从 URL 参数获取
|
||
const urlBJDID = getUrlParameter('BJDID');
|
||
if (urlBJDID) {
|
||
return urlBJDID;
|
||
}
|
||
|
||
// 如果 URL 中没有，则从输入框获取
|
||
return getControlValue('txtBJDID');
|
||
}
|
||
|
||
const BJDID = getBJDID();
|
||
|
||
function logMappingDebug(stage, payload) {
|
||
try {
|
||
console.log(`[BJCPJXDR][MappingDebug][${stage}]`, payload);
|
||
} catch (e) {}
|
||
}
|
||
|
||
function getDefaultPasteFieldOrder() {
|
||
const defaultOrder = ['包号', '报价产品', '技术规范书ID', '计量单位', '数量'];
|
||
const validFields = new Set(['包号', '报价产品', '技术规范书ID', '计量单位', '数量', '不导入']);
|
||
let rawValue = getControlValue('txtBJU059').trim();
|
||
|
||
if (!rawValue) return defaultOrder;
|
||
|
||
const parsed = rawValue
|
||
.replace(/，/g, ',')
|
||
.split(',')
|
||
.map(item => item.trim())
|
||
.filter(item => item !== '');
|
||
|
||
if (parsed.length === 0) return defaultOrder;
|
||
|
||
const normalized = parsed.map(item => (validFields.has(item) ? item : '不导入'));
|
||
while (normalized.length < defaultOrder.length) normalized.push('不导入');
|
||
const finalOrder = normalized.slice(0, defaultOrder.length);
|
||
logMappingDebug('getDefaultPasteFieldOrder', {
|
||
protocol: window.location.protocol,
|
||
rawValue,
|
||
parsed,
|
||
finalOrder
|
||
});
|
||
return finalOrder;
|
||
}
|
||
|
||
function applyDefaultColumnMapping(columnFieldMapping, detectedColumnCount) {
|
||
logMappingDebug('applyDefaultColumnMapping.before', {
|
||
detectedColumnCount,
|
||
mapping: JSON.parse(JSON.stringify(columnFieldMapping))
|
||
});
|
||
Object.keys(columnFieldMapping).forEach(key => delete columnFieldMapping[key]);
|
||
const fields = getDefaultPasteFieldOrder();
|
||
for (let i = 0; i < Math.min(detectedColumnCount, fields.length); i++) {
|
||
columnFieldMapping[i + 1] = fields[i] === '不导入' ? '' : fields[i];
|
||
}
|
||
logMappingDebug('applyDefaultColumnMapping.after', {
|
||
fields,
|
||
mapping: JSON.parse(JSON.stringify(columnFieldMapping))
|
||
});
|
||
}
|
||
|
||
function forceApplyDefaultColumnMapping(columnFieldMapping, detectedColumnCount) {
|
||
logMappingDebug('forceApplyDefaultColumnMapping.start', {
|
||
detectedColumnCount,
|
||
mapping: JSON.parse(JSON.stringify(columnFieldMapping))
|
||
});
|
||
const applyOnce = () => {
|
||
const fields = getDefaultPasteFieldOrder();
|
||
const maxCount = Math.min(detectedColumnCount, fields.length);
|
||
for (let i = 1; i <= maxCount; i++) {
|
||
const fieldName = fields[i - 1] === '不导入' ? '' : fields[i - 1];
|
||
columnFieldMapping[i] = fieldName;
|
||
columnFieldMapping[i.toString()] = fieldName;
|
||
}
|
||
logMappingDebug('forceApplyDefaultColumnMapping.applyOnce', {
|
||
fields,
|
||
maxCount,
|
||
mapping: JSON.parse(JSON.stringify(columnFieldMapping))
|
||
});
|
||
};
|
||
applyOnce();
|
||
setTimeout(applyOnce, 0);
|
||
setTimeout(applyOnce, 60);
|
||
}
|
||
const app = createApp({
|
||
setup() {
|
||
//进度条
|
||
const showCenterProgress = ref(false);
|
||
const centerProgressPercentage = ref(0);
|
||
const centerProgressStatus = ref('');
|
||
const centerProgressText = ref('');
|
||
let progressTimer = null;
|
||
// 手动粘贴对话框相关变量
|
||
const manualPasteDialogVisible = ref(false);
|
||
const manualPasteText = ref('');
|
||
|
||
// 列映射相关变量
|
||
const pasteStep = ref('input');
|
||
const detectedColumnCount = ref(0);
|
||
const detectedPreviewRows = ref([]);
|
||
const columnFieldMapping = reactive({});
|
||
const pasteFieldOptions = [
|
||
{ value: '', label: '不导入' },
|
||
{ value: '包号', label: '包号' },
|
||
{ value: '报价产品', label: '报价产品' },
|
||
{ value: '技术规范书ID', label: '技术规范书ID' },
|
||
{ value: '计量单位', label: '计量单位' },
|
||
{ value: '数量', label: '数量' }
|
||
];
|
||
|
||
const batchUpdateUseSelect = computed(() =>
|
||
batchUpdateType.value === 'standard' || batchUpdateType.value === 'voltage'
|
||
);
|
||
|
||
const visibleColumns = computed(() => {
|
||
const count = detectedColumnCount.value || 0;
|
||
return Array.from({ length: count }, (_, i) => i + 1);
|
||
});
|
||
let clipboardText = '';
|
||
|
||
// 状态变量
|
||
const loading = ref(false);
|
||
const FGF = ref('');
|
||
const ruleDialogVisible = ref(false);
|
||
const EXRuleDialogVisible = ref(false);
|
||
const syntaxDialogVisible = ref(false);
|
||
const filterDialogVisible = ref(false);
|
||
const YFGZDialogVisible = ref(false);
|
||
const iframeUrl = ref('');
|
||
const BJCPJXDR_XHYF = ref('BJCPJXDR_XHYF.html');
|
||
const tableData = ref([]);
|
||
const tableRef = ref(null);
|
||
const selectedProduct = ref('');
|
||
const currentRowModel = ref(''); // 当前行型号
|
||
|
||
// 批量调整相关变量
|
||
const batchUpdateDialogVisible = ref(false);
|
||
const batchUpdateType = ref('');
|
||
const batchUpdateValue = ref('');
|
||
const batchUpdateOptions = ref([]);
|
||
const batchUpdateFilterQuery = ref('');
|
||
const batchUpdateFilteredOptions = computed(() => {
|
||
const options = batchUpdateOptions.value || [];
|
||
const query = (batchUpdateFilterQuery.value || '').trim().toLowerCase();
|
||
if (!query) return options;
|
||
const normalizedQuery = query.replace(/\s+/g, '');
|
||
return options.filter(option => {
|
||
const label = (option.label || '').toString().toLowerCase();
|
||
const value = (option.value || '').toString().toLowerCase();
|
||
const normalizedLabel = label.replace(/\s+/g, '');
|
||
const normalizedValue = value.replace(/\s+/g, '');
|
||
return label.includes(query)
|
||
|| value.includes(query)
|
||
|| normalizedLabel.includes(normalizedQuery)
|
||
|| normalizedValue.includes(normalizedQuery);
|
||
});
|
||
});
|
||
const filterBatchUpdateOptions = (query) => {
|
||
batchUpdateFilterQuery.value = query || '';
|
||
};
|
||
const resolveBatchUpdateSelectValue = () => {
|
||
const raw = batchUpdateValue.value;
|
||
if (raw == null || raw === '') return '';
|
||
const text = String(raw).trim();
|
||
const options = batchUpdateOptions.value || [];
|
||
const byValue = options.find(item => String(item.value) === text);
|
||
if (byValue) return String(byValue.value);
|
||
const byLabel = options.find(item => String(item.label).trim() === text);
|
||
if (byLabel) return String(byLabel.value);
|
||
return '';
|
||
};
|
||
const hasSelectedRows = ref(false);
|
||
const selectedRowsCount = ref(0);
|
||
const batchUpdateTitle = ref('');
|
||
|
||
|
||
const currentRowVoltage = ref(''); // 当前行电压
|
||
const currentRowStandard = ref(''); // 当前行标准
|
||
const currentRowSpec = ref(''); // 当前行规格
|
||
const currentRowXLJXGZXH = ref('');
|
||
const ruleEditor = ref(null);
|
||
const selection = ref({ start: 0, end: 0, text: '' });
|
||
const resultReceived = ref(false);
|
||
// 规则配置相关变量
|
||
const ruleString = ref('| 电力电缆，AC220kV，YJLW,1600,1,03,ZC,Z');
|
||
// 查询条件变量
|
||
const productQuery = ref(''); // 报价产品（模糊查询）
|
||
const modelQuery = ref(''); // 线缆型号（模糊查询）
|
||
const specQuery = ref(''); // 线缆规格（模糊查询）
|
||
const standardQuery = ref(''); // 线缆标准（精确查询）
|
||
const voltageQuery = ref(''); // 电压等级（精确查询）
|
||
const missingElementQuery = ref([]); // 缺失要素（多选）
|
||
const missingElementOptions = [
|
||
{ value: 'XLXH', label: '线缆型号' },
|
||
{ value: 'XLGG', label: '线缆规格' },
|
||
{ value: 'XLBZ', label: '线缆标准' },
|
||
{ value: 'DYDJ', label: '电压等级' }
|
||
];
|
||
|
||
const buildListQueryParams = () => ({
|
||
XLJXDJ: 'XSBJ',
|
||
XLJXDH: BJDID,
|
||
sXLJXGZXH: filterRule.value || '0',
|
||
sDCZT: filterStatus.value || ' ',
|
||
sBJCP: productQuery.value,
|
||
sXLXH: modelQuery.value,
|
||
sXLGG: specQuery.value,
|
||
sXLBZ: standardQuery.value,
|
||
sDYDJID: voltageQuery.value,
|
||
sQSYS: (missingElementQuery.value && missingElementQuery.value.length > 0)
|
||
? missingElementQuery.value.join(',')
|
||
: ''
|
||
});
|
||
|
||
// 下拉选项变量
|
||
const standardOptions = ref([]); // 线缆标准下拉选项
|
||
const voltageOptions = ref([]); // 电压等级下拉选项
|
||
const standardNameMap = ref({}); // 标准编码->名称映射
|
||
// 线缆型号标记相关变量
|
||
const modelTags = ref([]);
|
||
const modelNextChar = ref(97); // 'a'的ASCII码
|
||
const modelTagOrder = {
|
||
'前缀码': 1,
|
||
'型号码': 2,
|
||
'后缀码': 3,
|
||
'型号': 4
|
||
};
|
||
const modelActualValue = ref('');
|
||
|
||
// 线缆规格标记相关变量
|
||
const specTags = ref([]);
|
||
const specNextChar = ref(97); // 'a'的ASCII码
|
||
const specTagOrder = {
|
||
'芯数': 1,
|
||
'截面': 2,
|
||
'线组数': 3,
|
||
'线对数': 4,
|
||
'规格':5
|
||
};
|
||
const specActualValue = ref('');
|
||
|
||
|
||
const voltageTags = ref([]);
|
||
const voltageNextChar = ref(97); // 'a'的ASCII码
|
||
const voltageTagOrder = {
|
||
'相电压': 1,
|
||
'线电压': 2,
|
||
'电压单位': 3,
|
||
'电压等级': 4
|
||
};
|
||
const voltageActualValue = ref('');
|
||
|
||
const standardTags = ref([]);
|
||
const standardNextChar = ref(97); // 'a'的ASCII码
|
||
const standardTagOrder = {
|
||
'标准名': 1
|
||
};
|
||
const standardActualValue = ref('');
|
||
|
||
// 配置项的值
|
||
const modelValue = ref('');
|
||
const specValue = ref('');
|
||
const voltageValue = ref('');
|
||
const standardValue = ref('');
|
||
const colorValue = ref('');
|
||
|
||
// 筛选条件变量
|
||
const filterRule = ref('0');
|
||
const ExRule = ref('0');
|
||
const filterStatus = ref('');
|
||
const filterEquivalent=ref(false);
|
||
const isLoading = ref(false);
|
||
// 解析规则选项
|
||
const ruleOptions = ref([
|
||
{ value: '0', label: '未解析' }
|
||
]);
|
||
|
||
// 通用解析规则选项
|
||
const commonRuleOptions = ref([
|
||
{ value: '0', label: '请选择通用规则' }
|
||
]);
|
||
|
||
// 删除规则函数
|
||
const deleteRule = async (ruleId) => {
|
||
try {
|
||
const result = await ElMessageBox.confirm(
|
||
'确定要删除此解析规则吗？此操作不可恢复。',
|
||
'确认删除',
|
||
{
|
||
confirmButtonText: '确定',
|
||
cancelButtonText: '取消',
|
||
type: 'warning'
|
||
}
|
||
);
|
||
|
||
if (result) {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 调用删除服务
|
||
const deleteResult = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'DeleteXLJXGZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005,
|
||
'XLJXDH': BJDID,
|
||
'sXLJXGZXH': ruleId
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"DeleteXLJXGZ",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (deleteResult && deleteResult.success) {
|
||
ElMessage.success('解析规则删除成功');
|
||
// 重新加载规则列表
|
||
await loadRuleOptions();
|
||
// 如果删除的是当前选中的规则，重置为默认值
|
||
if (filterRule.value === ruleId) {
|
||
filterRule.value = '0';
|
||
}
|
||
} else {
|
||
ElMessage.error(`删除失败: ${deleteResult?.message || '未知错误'}`);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
if (error !== 'cancel') {
|
||
console.error('删除规则失败:', error);
|
||
ElMessage.error(`删除规则失败: ${error.message || '服务异常'}`);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 删除通用规则函数
|
||
const deleteCommonRule = async (ruleId) => {
|
||
try {
|
||
const result = await ElMessageBox.confirm(
|
||
'确定要删除此通用解析规则吗？此操作不可恢复。',
|
||
'确认删除',
|
||
{
|
||
confirmButtonText: '确定',
|
||
cancelButtonText: '取消',
|
||
type: 'warning'
|
||
}
|
||
);
|
||
|
||
if (result) {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 调用删除通用规则服务
|
||
const deleteResult = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'DeleteXLJXGZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005,
|
||
'XLJXDH':' ',
|
||
'sXLJXGZXH': ruleId
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"DeleteXLJXGZ",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (deleteResult && deleteResult.success) {
|
||
ElMessage.success('通用解析规则删除成功');
|
||
// 重新加载通用规则列表
|
||
await loadCommonRuleOptions();
|
||
} else {
|
||
ElMessage.error(`删除失败: ${deleteResult?.message || '未知错误'}`);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
if (error !== 'cancel') {
|
||
console.error('删除通用规则失败:', error);
|
||
ElMessage.error(`删除通用规则失败: ${error.message || '服务异常'}`);
|
||
}
|
||
}
|
||
};
|
||
|
||
const statusOptions = ref([
|
||
{ value: 'N', label: '未导入' },
|
||
{ value: 'Y', label: '已导入' }
|
||
]);
|
||
//todo
|
||
// 正确声明对象路径
|
||
const cable_model_syntax = ref("/GTHINKING/Components/N_XLBJDX/cable_model_syntax.html");
|
||
// ==== Excel导入相关变量 ====
|
||
const importDialogVisible = ref(false);
|
||
const fileInput = ref(null);
|
||
const excelFile = ref(null);
|
||
const excelColumns = ref([]);
|
||
const previewData = ref([]);
|
||
const columnMapping = reactive({
|
||
'序号': null,
|
||
'包号': null,
|
||
'报价产品': null,
|
||
'技术规范书ID': null,
|
||
'计量单位': null, // 新增
|
||
'数量': null,
|
||
'型号': null,
|
||
'电压等级': null,
|
||
'标准': null,
|
||
'规格': null,
|
||
'等效': null,
|
||
});
|
||
const tableColumns = ref(['包号','报价产品', '技术规范书ID','计量单位', '数量', '型号', '电压等级', '标准', '规格', '等效']);
|
||
const importing = ref(false);
|
||
const importProgress = ref(0);
|
||
const totalRows = ref(0);
|
||
const importedCount = ref(0);
|
||
const importStatus = ref(null);
|
||
const errorMessage = ref('');
|
||
const successMessage = ref('');
|
||
const canImport = ref(false);
|
||
// ==== el-table-v2 相关变量 ====
|
||
const TABLE_CELL_BORDER_STYLE = {
|
||
borderRight: '1px solid #dcdfe6',
|
||
borderBottom: '1px solid #dcdfe6',
|
||
boxSizing: 'border-box'
|
||
};
|
||
const withTableCellBorder = (column) => ({
|
||
...column,
|
||
style: { ...TABLE_CELL_BORDER_STYLE, ...(column.style || {}) }
|
||
});
|
||
|
||
// 表头拖拽排序 / 列宽拖拽：固定列不可排序，配置持久化到 localStorage
|
||
const PINNED_COLUMN_KEYS = new Set(['selection', 'index']);
|
||
const COLUMN_ORDER_STORAGE_KEY = 'BJCPJXDR_tableColumnOrder_v1';
|
||
const COLUMN_WIDTH_STORAGE_KEY = 'BJCPJXDR_tableColumnWidths_v1';
|
||
const MIN_COLUMN_WIDTH = 48;
|
||
const columnDragSourceKey = ref(null);
|
||
const columnDragOverKey = ref(null);
|
||
let resizingColumnKey = null;
|
||
let resizeStartX = 0;
|
||
let resizeStartWidth = 0;
|
||
let resizeRafId = 0;
|
||
let pendingResizeWidth = 0;
|
||
let resizeGuideEl = null;
|
||
let resizeColumnIndex = -1;
|
||
|
||
const refreshTableColumns = () => {
|
||
tableColumnsV2.value = tableColumnsV2.value.map(col => ({ ...col }));
|
||
};
|
||
|
||
const loadSavedColumnWidths = () => {
|
||
try {
|
||
const raw = localStorage.getItem(COLUMN_WIDTH_STORAGE_KEY);
|
||
if (!raw) return null;
|
||
const parsed = JSON.parse(raw);
|
||
return parsed && typeof parsed === 'object' ? parsed : null;
|
||
} catch (e) {
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const applySavedWidthsToColumns = (columns, widths) => {
|
||
if (!widths) return columns;
|
||
return columns.map(col => {
|
||
if (col.hidden) return col;
|
||
const saved = widths[col.key];
|
||
if (typeof saved === 'number' && saved >= MIN_COLUMN_WIDTH) {
|
||
return { ...col, width: Math.round(saved) };
|
||
}
|
||
return col;
|
||
});
|
||
};
|
||
|
||
const saveColumnWidths = () => {
|
||
const widths = {};
|
||
tableColumnsV2.value.forEach(col => {
|
||
if (!col.hidden) widths[col.key] = col.width;
|
||
});
|
||
try {
|
||
localStorage.setItem(COLUMN_WIDTH_STORAGE_KEY, JSON.stringify(widths));
|
||
} catch (e) {}
|
||
};
|
||
|
||
const setColumnWidth = (key, width) => {
|
||
const w = Math.max(MIN_COLUMN_WIDTH, Math.round(width));
|
||
const idx = tableColumnsV2.value.findIndex(col => col.key === key);
|
||
if (idx < 0) return;
|
||
const col = tableColumnsV2.value[idx];
|
||
if (col.width === w) return;
|
||
tableColumnsV2.value[idx] = { ...col, width: w };
|
||
tableColumnsV2.value = [...tableColumnsV2.value];
|
||
};
|
||
|
||
const ensureResizeGuide = () => {
|
||
if (!resizeGuideEl) {
|
||
resizeGuideEl = document.createElement('div');
|
||
resizeGuideEl.className = 'bjcpjxdr-col-resize-guide';
|
||
document.body.appendChild(resizeGuideEl);
|
||
}
|
||
return resizeGuideEl;
|
||
};
|
||
|
||
const getHeaderGuideHost = () => document.querySelector('.table-container .el-table-v2__header-wrapper')
|
||
|| document.querySelector('.el-table-v2__header-wrapper')
|
||
|| document.querySelector('.el-table-v2__header');
|
||
|
||
const getHeaderCellByResizeIndex = () => {
|
||
if (resizeColumnIndex < 0) return null;
|
||
const host = getHeaderGuideHost();
|
||
if (!host) return null;
|
||
const cells = host.querySelectorAll('.el-table-v2__header-cell');
|
||
return cells[resizeColumnIndex] || null;
|
||
};
|
||
|
||
const updateResizeGuide = () => {
|
||
const guide = ensureResizeGuide();
|
||
const headerHost = getHeaderGuideHost();
|
||
if (headerHost) {
|
||
const hRect = headerHost.getBoundingClientRect();
|
||
guide.style.top = `${hRect.top}px`;
|
||
guide.style.height = `${hRect.height}px`;
|
||
}
|
||
const headerCell = getHeaderCellByResizeIndex();
|
||
if (headerCell) {
|
||
const cellRect = headerCell.getBoundingClientRect();
|
||
guide.style.left = `${cellRect.right - 1}px`;
|
||
}
|
||
guide.style.display = 'block';
|
||
};
|
||
|
||
const hideResizeGuide = () => {
|
||
if (resizeGuideEl) resizeGuideEl.style.display = 'none';
|
||
};
|
||
|
||
const applyColumnResizeByPointer = (clientX) => {
|
||
if (!resizingColumnKey) return;
|
||
pendingResizeWidth = Math.max(
|
||
MIN_COLUMN_WIDTH,
|
||
Math.round(resizeStartWidth + (clientX - resizeStartX))
|
||
);
|
||
if (resizeRafId) return;
|
||
resizeRafId = requestAnimationFrame(() => {
|
||
resizeRafId = 0;
|
||
setColumnWidth(resizingColumnKey, pendingResizeWidth);
|
||
updateResizeGuide();
|
||
});
|
||
};
|
||
|
||
const onColumnResizeMove = (e) => {
|
||
if (!resizingColumnKey) return;
|
||
applyColumnResizeByPointer(e.clientX);
|
||
};
|
||
|
||
const stopColumnResize = () => {
|
||
if (!resizingColumnKey) return;
|
||
const key = resizingColumnKey;
|
||
if (resizeRafId) {
|
||
cancelAnimationFrame(resizeRafId);
|
||
resizeRafId = 0;
|
||
}
|
||
setColumnWidth(key, pendingResizeWidth);
|
||
resizingColumnKey = null;
|
||
resizeColumnIndex = -1;
|
||
document.removeEventListener('mousemove', onColumnResizeMove);
|
||
document.removeEventListener('mouseup', stopColumnResize);
|
||
document.body.classList.remove('bjcpjxdr-col-resizing');
|
||
hideResizeGuide();
|
||
saveColumnWidths();
|
||
};
|
||
|
||
const startColumnResize = (columnKey, e) => {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
const headerCell = e.target.closest('.el-table-v2__header-cell');
|
||
const domWidth = headerCell ? headerCell.getBoundingClientRect().width : 0;
|
||
const col = tableColumnsV2.value.find(c => c.key === columnKey);
|
||
const visibleCols = tableColumnsV2.value.filter(c => !c.hidden);
|
||
resizeColumnIndex = visibleCols.findIndex(c => c.key === columnKey);
|
||
resizingColumnKey = columnKey;
|
||
resizeStartX = e.clientX;
|
||
resizeStartWidth = domWidth > 0 ? domWidth : (col ? col.width : MIN_COLUMN_WIDTH);
|
||
pendingResizeWidth = resizeStartWidth;
|
||
document.body.classList.add('bjcpjxdr-col-resizing');
|
||
updateResizeGuide();
|
||
document.addEventListener('mousemove', onColumnResizeMove);
|
||
document.addEventListener('mouseup', stopColumnResize);
|
||
};
|
||
|
||
const createColumnResizeHandle = (columnKey) => h('span', {
|
||
class: 'bjcpjxdr-col-resize-handle',
|
||
title: '拖动调整列宽',
|
||
onMousedown: (e) => startColumnResize(columnKey, e)
|
||
});
|
||
|
||
const loadSavedTableColumnOrder = () => {
|
||
try {
|
||
const raw = localStorage.getItem(COLUMN_ORDER_STORAGE_KEY);
|
||
if (!raw) return null;
|
||
const parsed = JSON.parse(raw);
|
||
return Array.isArray(parsed) ? parsed : null;
|
||
} catch (e) {
|
||
return null;
|
||
}
|
||
};
|
||
|
||
const applySavedOrderToColumns = (columns, savedKeys) => {
|
||
if (!savedKeys || !savedKeys.length) return columns;
|
||
const pinnedStart = columns.filter(c => PINNED_COLUMN_KEYS.has(c.key));
|
||
const hidden = columns.filter(c => c.hidden);
|
||
const draggable = columns.filter(c => !PINNED_COLUMN_KEYS.has(c.key) && !c.hidden);
|
||
const map = new Map(draggable.map(c => [c.key, c]));
|
||
const ordered = [];
|
||
savedKeys.forEach(k => {
|
||
if (map.has(k)) {
|
||
ordered.push(map.get(k));
|
||
map.delete(k);
|
||
}
|
||
});
|
||
map.forEach(c => ordered.push(c));
|
||
return [...pinnedStart, ...ordered, ...hidden];
|
||
};
|
||
|
||
const reorderTableColumns = (fromKey, toKey) => {
|
||
if (!fromKey || !toKey || fromKey === toKey) return;
|
||
if (PINNED_COLUMN_KEYS.has(fromKey) || PINNED_COLUMN_KEYS.has(toKey)) return;
|
||
|
||
const cols = tableColumnsV2.value;
|
||
const draggable = cols.filter(c => !PINNED_COLUMN_KEYS.has(c.key) && !c.hidden);
|
||
const keys = draggable.map(c => c.key);
|
||
const fromIdx = keys.indexOf(fromKey);
|
||
const toIdx = keys.indexOf(toKey);
|
||
if (fromIdx < 0 || toIdx < 0) return;
|
||
|
||
keys.splice(fromIdx, 1);
|
||
keys.splice(toIdx, 0, fromKey);
|
||
|
||
const pinnedStart = cols.filter(c => PINNED_COLUMN_KEYS.has(c.key));
|
||
const hidden = cols.filter(c => c.hidden);
|
||
const map = new Map(draggable.map(c => [c.key, c]));
|
||
const reordered = keys.map(k => map.get(k)).filter(Boolean);
|
||
|
||
tableColumnsV2.value = [...pinnedStart, ...reordered, ...hidden];
|
||
try {
|
||
localStorage.setItem(COLUMN_ORDER_STORAGE_KEY, JSON.stringify(keys));
|
||
} catch (e) {}
|
||
};
|
||
|
||
const withDraggableHeader = (column) => {
|
||
if (column.hidden) return column;
|
||
if (column.key === 'selection') {
|
||
return {
|
||
...column,
|
||
headerCellRenderer: () => h('div', { class: 'bjcpjxdr-header-cell bjcpjxdr-header-pinned' }, [
|
||
h('input', {
|
||
type: 'checkbox',
|
||
onChange: (e) => {
|
||
if (e.target.checked) {
|
||
tableData.value.forEach(row => { row.selected = true; });
|
||
} else {
|
||
tableData.value.forEach(row => { row.selected = false; });
|
||
}
|
||
updateSelectedRows();
|
||
},
|
||
checked: hasSelectedRows.value && selectedRowsCount.value === tableData.value.length
|
||
}),
|
||
createColumnResizeHandle(column.key)
|
||
])
|
||
};
|
||
}
|
||
if (PINNED_COLUMN_KEYS.has(column.key)) {
|
||
return {
|
||
...column,
|
||
headerCellRenderer: () => h('div', { class: 'bjcpjxdr-header-cell bjcpjxdr-header-pinned' }, [
|
||
h('span', column.title),
|
||
createColumnResizeHandle(column.key)
|
||
])
|
||
};
|
||
}
|
||
return {
|
||
...column,
|
||
headerCellRenderer: () => {
|
||
const key = column.key;
|
||
const isDragging = columnDragSourceKey.value === key;
|
||
const isOver = columnDragOverKey.value === key;
|
||
return h('div', {
|
||
class: [
|
||
'bjcpjxdr-header-cell',
|
||
'bjcpjxdr-header-draggable',
|
||
isDragging ? 'is-dragging' : '',
|
||
isOver ? 'is-drag-over' : ''
|
||
],
|
||
draggable: true,
|
||
title: '按住拖动可调整列顺序',
|
||
onDragstart: (e) => {
|
||
columnDragSourceKey.value = key;
|
||
e.dataTransfer.effectAllowed = 'move';
|
||
try { e.dataTransfer.setData('text/plain', key); } catch (err) {}
|
||
},
|
||
onDragover: (e) => {
|
||
e.preventDefault();
|
||
if (columnDragSourceKey.value && columnDragSourceKey.value !== key
|
||
&& columnDragOverKey.value !== key) {
|
||
columnDragOverKey.value = key;
|
||
refreshTableColumns();
|
||
}
|
||
},
|
||
onDragleave: () => {
|
||
if (columnDragOverKey.value === key) {
|
||
columnDragOverKey.value = null;
|
||
refreshTableColumns();
|
||
}
|
||
},
|
||
onDrop: (e) => {
|
||
e.preventDefault();
|
||
const fromKey = columnDragSourceKey.value
|
||
|| (e.dataTransfer && e.dataTransfer.getData('text/plain'));
|
||
reorderTableColumns(fromKey, key);
|
||
columnDragSourceKey.value = null;
|
||
columnDragOverKey.value = null;
|
||
refreshTableColumns();
|
||
},
|
||
onDragend: () => {
|
||
columnDragSourceKey.value = null;
|
||
columnDragOverKey.value = null;
|
||
refreshTableColumns();
|
||
}
|
||
}, [
|
||
h('span', { class: 'bjcpjxdr-header-grip', 'aria-hidden': 'true' }, '⋮⋮'),
|
||
h('span', { class: 'bjcpjxdr-header-title' }, column.title),
|
||
createColumnResizeHandle(column.key)
|
||
]);
|
||
}
|
||
};
|
||
};
|
||
|
||
const createBaseTableColumns = () => ([
|
||
{
|
||
key: 'selection',
|
||
dataKey: 'selection',
|
||
title: '选择',
|
||
width: 60,
|
||
align: 'center',
|
||
cellRenderer: ({ rowData }) => {
|
||
return h('input', {
|
||
type: 'checkbox',
|
||
checked: rowData.selected || false,
|
||
onChange: (e) => {
|
||
rowData.selected = e.target.checked;
|
||
updateSelectedRows();
|
||
}
|
||
});
|
||
}
|
||
},
|
||
{
|
||
key: 'index',
|
||
dataKey: 'index',
|
||
title: '序号',
|
||
width: 50,
|
||
align: 'center'
|
||
},
|
||
{
|
||
key: 'packageNumber',
|
||
dataKey: 'packageNumber',
|
||
title: '包号',
|
||
width: 80,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'product',
|
||
dataKey: 'product',
|
||
title: '报价产品',
|
||
width: 300,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'techSpecId',
|
||
dataKey: 'techSpecId',
|
||
title: '技术规范ID',
|
||
width: 100,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'unit',
|
||
dataKey: 'unit',
|
||
title: '计量单位',
|
||
width: 80,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'quantity',
|
||
dataKey: 'quantity',
|
||
title: '数量',
|
||
width: 80,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'model',
|
||
dataKey: 'model',
|
||
title: '型号',
|
||
width: 150,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'voltage',
|
||
dataKey: 'voltage',
|
||
title: '电压等级',
|
||
width: 100,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'standard',
|
||
dataKey: 'standard',
|
||
title: '标准',
|
||
width: 80,
|
||
align: 'left',
|
||
cellRenderer: ({ rowData }) => {
|
||
const name = standardNameMap.value[rowData.standard];
|
||
return name || rowData.standard || '';
|
||
}
|
||
},
|
||
{
|
||
key: 'spec',
|
||
dataKey: 'spec',
|
||
title: '规格',
|
||
width: 120,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'dx',
|
||
dataKey: 'dx',
|
||
title: '等效',
|
||
width: 200,
|
||
align: 'left'
|
||
},
|
||
{
|
||
key: 'XLJXGZXH',
|
||
dataKey: 'XLJXGZXH',
|
||
title: 'XLJXGZXH',
|
||
width: 0,
|
||
align: 'left',
|
||
hidden: true
|
||
}
|
||
]);
|
||
|
||
const buildTableColumnsV2 = () => {
|
||
const savedOrder = loadSavedTableColumnOrder();
|
||
const ordered = applySavedOrderToColumns(createBaseTableColumns(), savedOrder);
|
||
const withWidths = applySavedWidthsToColumns(ordered, loadSavedColumnWidths());
|
||
return withWidths.map(withDraggableHeader).map(withTableCellBorder);
|
||
};
|
||
|
||
const tableColumnsV2 = ref(buildTableColumnsV2());
|
||
|
||
const getRowKey = row => {
|
||
// 方案1：直接使用唯一字段
|
||
return row.id
|
||
|
||
}
|
||
|
||
const tableWidth = ref(window.innerWidth - 30);
|
||
const tableHeight = ref(window.innerHeight - 50);
|
||
|
||
// 启动进度条显示
|
||
const startCenterProgress = (text) => {
|
||
showCenterProgress.value = true;
|
||
centerProgressPercentage.value = 0;
|
||
centerProgressStatus.value = '';
|
||
centerProgressText.value = text || '处理中...';
|
||
|
||
// 模拟进度增长
|
||
progressTimer = setInterval(() => {
|
||
if (centerProgressPercentage.value < 75) {
|
||
centerProgressPercentage.value += 5;
|
||
}
|
||
}, 300);
|
||
};
|
||
|
||
// 完成进度条显示
|
||
const completeCenterProgress = (success = true, message = '') => {
|
||
if (progressTimer) clearInterval(progressTimer);
|
||
|
||
// 设置完成状态
|
||
centerProgressPercentage.value = 100;
|
||
centerProgressStatus.value = success ? 'success' : 'exception';
|
||
centerProgressText.value = message || (success ? '完成!' : '失败!');
|
||
|
||
// 2秒后自动关闭
|
||
setTimeout(() => {
|
||
showCenterProgress.value = false;
|
||
}, 2000);
|
||
};
|
||
// 显示手动粘贴对话框
|
||
const showManualPasteDialog = () => {
|
||
manualPasteText.value = '';
|
||
manualPasteDialogVisible.value = true;
|
||
};
|
||
|
||
// 处理手动粘贴确认（第一步：粘贴数据）
|
||
const handleManualPasteConfirm = () => {
|
||
logMappingDebug('handleManualPasteConfirm.click', {
|
||
protocol: window.location.protocol,
|
||
textLength: manualPasteText.value ? manualPasteText.value.length : 0
|
||
});
|
||
if (!manualPasteText.value.trim()) {
|
||
ElMessage.warning('请输入要粘贴的数据');
|
||
return;
|
||
}
|
||
|
||
const text = manualPasteText.value.trim();
|
||
const rows = text.split('\n').filter(row => row.trim() !== '');
|
||
|
||
if (rows.length === 0) {
|
||
ElMessage.warning('粘贴的数据为空');
|
||
return;
|
||
}
|
||
|
||
const firstRow = rows[0].split('\t');
|
||
detectedColumnCount.value = firstRow.length;
|
||
logMappingDebug('handleManualPasteConfirm.detected', {
|
||
rows: rows.length,
|
||
detectedColumnCount: detectedColumnCount.value,
|
||
firstRow
|
||
});
|
||
|
||
detectedPreviewRows.value = rows.slice(0, 5).map((row, idx) => {
|
||
const cols = row.split('\t');
|
||
const rowData = { rowIndex: idx + 1 };
|
||
for (let i = 0; i < cols.length; i++) {
|
||
rowData['col' + i] = cols[i];
|
||
}
|
||
return rowData;
|
||
});
|
||
|
||
// 点击“下一步”时强制覆盖列映射（HTTP场景）
|
||
applyDefaultColumnMapping(columnFieldMapping, detectedColumnCount.value);
|
||
pasteStep.value = 'mapping';
|
||
nextTick(() => forceApplyDefaultColumnMapping(columnFieldMapping, detectedColumnCount.value));
|
||
logMappingDebug('handleManualPasteConfirm.toMapping', {
|
||
pasteStep: pasteStep.value,
|
||
mapping: JSON.parse(JSON.stringify(columnFieldMapping))
|
||
});
|
||
};
|
||
|
||
// 处理映射确认（第二步：确认映射并导入）
|
||
const handleMappingConfirm = () => {
|
||
const hasProduct = Object.values(columnFieldMapping).includes('报价产品');
|
||
if (!hasProduct) {
|
||
ElMessage.warning('请设置"报价产品"列的对应位置（必填）');
|
||
return;
|
||
}
|
||
|
||
const fieldMapping = {};
|
||
Object.entries(columnFieldMapping).forEach(([col, field]) => {
|
||
if (field) {
|
||
fieldMapping[field] = col;
|
||
}
|
||
});
|
||
|
||
manualPasteDialogVisible.value = false;
|
||
pasteStep.value = 'input';
|
||
const text = manualPasteText.value;
|
||
manualPasteText.value = '';
|
||
|
||
processPastedTextWithMapping(fieldMapping, text);
|
||
};
|
||
|
||
// 返回上一步
|
||
const handleMappingBack = () => {
|
||
pasteStep.value = 'input';
|
||
};
|
||
|
||
// 处理手动粘贴取消
|
||
const handleManualPasteCancel = () => {
|
||
manualPasteDialogVisible.value = false;
|
||
manualPasteText.value = '';
|
||
pasteStep.value = 'input';
|
||
};
|
||
|
||
// 提取粘贴文本处理逻辑为独立函数
|
||
const processPastedText = async (text) => {
|
||
startCenterProgress('正在处理数据...');
|
||
|
||
// 解析剪贴板数据为表格
|
||
const rows = text.split('\n');
|
||
const itemsToInsert = [];
|
||
const parsedData = [];
|
||
|
||
// 为所有记录生成相同的XLJXDH
|
||
const commonXLJXDH = BJDID;
|
||
|
||
for (let i = 0; i < rows.length; i++) {
|
||
const row = rows[i].split('\t');
|
||
if (row.length > 0 && row[0].trim() !== '') {
|
||
const sequenceNumber = (i + 1).toString();
|
||
const packageNumber = row[0].trim();
|
||
const product= row.length > 1 ? row[1].trim() : ''; // 第二列为计量单位
|
||
const techSpecId= row.length > 2 ? row[2].trim() : ''; // 第三列为数量
|
||
const unit= row.length > 3 ? row[3].trim() : ''; // 第四列为包号
|
||
const quantity = row.length > 4 ? row[4].trim() : ''; // 第五列为技术规范ID
|
||
|
||
// 创建XLJXMX对象
|
||
itemsToInsert.push({
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: commonXLJXDH,
|
||
XLJXMXH: sequenceNumber,
|
||
XLBSC: product,
|
||
XLJXGZXH: "0",
|
||
JXXLXHID: "",
|
||
XLXHID: "",
|
||
JXXLGGID: "",
|
||
XLGGID: "",
|
||
JXDYDJID: "",
|
||
DYDJID: "",
|
||
XLBZID: "",
|
||
JXXLBZID: "",
|
||
XLYSID: "",
|
||
JXXLYSID: "",
|
||
WHR: "",
|
||
WHRID: "",
|
||
WHSJ: "",
|
||
DCZT: "N",
|
||
JLDW: unit, // 计量单位
|
||
SL: quantity, // 数量
|
||
FBH: packageNumber, // 包号
|
||
JSGFID: techSpecId // 技术规范ID
|
||
});
|
||
|
||
parsedData.push({
|
||
index: sequenceNumber,
|
||
product: product,
|
||
unit: unit,
|
||
quantity: quantity,
|
||
packageNumber: packageNumber, // 包号
|
||
techSpecId: techSpecId, // 技术规范ID
|
||
model: '',
|
||
voltage: '',
|
||
standard: '',
|
||
spec: '',
|
||
status: 'N',
|
||
checked: false
|
||
});
|
||
}
|
||
}
|
||
|
||
// 批量插入数据
|
||
if (itemsToInsert.length > 0) {
|
||
loading.value = true;
|
||
const result = await bulkInsertXLJXMX(itemsToInsert);
|
||
|
||
if (result && result.success) {
|
||
await loadTableData();
|
||
ElMessage.success(`已粘贴并插入 ${parsedData.length} 条数据`);
|
||
await commonParse();
|
||
} else {
|
||
completeCenterProgress(false, '粘贴失败');
|
||
ElMessage.error(`插入失败: ${result?.msg || result?.message || '未知错误'}`);
|
||
}
|
||
loading.value = false;
|
||
}
|
||
|
||
completeCenterProgress(true, '数据处理完成!');
|
||
};
|
||
|
||
// 使用动态列映射处理粘贴文本
|
||
const processPastedTextWithMapping = async (fieldMapping, text) => {
|
||
startCenterProgress('正在处理数据...');
|
||
|
||
const rows = text.split('\n');
|
||
const itemsToInsert = [];
|
||
const parsedData = [];
|
||
const commonXLJXDH = BJDID;
|
||
|
||
const getMappedValue = (row, fieldName) => {
|
||
const colIndex = fieldMapping[fieldName];
|
||
if (colIndex) {
|
||
const idx = parseInt(colIndex) - 1;
|
||
return row.length > idx ? row[idx].trim() : '';
|
||
}
|
||
return '';
|
||
};
|
||
|
||
for (let i = 0; i < rows.length; i++) {
|
||
const row = rows[i].split('\t');
|
||
if (row.length > 0 && row[0].trim() !== '') {
|
||
const sequenceNumber = (i + 1).toString();
|
||
const packageNumber = getMappedValue(row, '包号');
|
||
const product = getMappedValue(row, '报价产品');
|
||
const techSpecId = getMappedValue(row, '技术规范书ID');
|
||
const unit = getMappedValue(row, '计量单位');
|
||
const quantity = getMappedValue(row, '数量');
|
||
|
||
itemsToInsert.push({
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: commonXLJXDH,
|
||
XLJXMXH: sequenceNumber,
|
||
XLBSC: product,
|
||
XLJXGZXH: "0",
|
||
JXXLXHID: "",
|
||
XLXHID: "",
|
||
JXXLGGID: "",
|
||
XLGGID: "",
|
||
JXDYDJID: "",
|
||
DYDJID: "",
|
||
XLBZID: "",
|
||
JXXLBZID: "",
|
||
XLYSID: "",
|
||
JXXLYSID: "",
|
||
WHR: "",
|
||
WHRID: "",
|
||
WHSJ: "",
|
||
DCZT: "N",
|
||
JLDW: unit,
|
||
SL: quantity,
|
||
FBH: packageNumber,
|
||
JSGFID: techSpecId
|
||
});
|
||
|
||
parsedData.push({
|
||
index: sequenceNumber,
|
||
product: product,
|
||
unit: unit,
|
||
quantity: quantity,
|
||
packageNumber: packageNumber,
|
||
techSpecId: techSpecId,
|
||
model: '',
|
||
voltage: '',
|
||
standard: '',
|
||
spec: '',
|
||
status: 'N',
|
||
checked: false
|
||
});
|
||
}
|
||
}
|
||
|
||
if (itemsToInsert.length > 0) {
|
||
loading.value = true;
|
||
const result = await bulkInsertXLJXMX(itemsToInsert);
|
||
if (result && result.success) {
|
||
await loadTableData();
|
||
ElMessage.success(`已粘贴并插入 ${parsedData.length} 条数据`);
|
||
await commonParse();
|
||
} else {
|
||
completeCenterProgress(false, '粘贴失败');
|
||
ElMessage.error(`插入失败: ${result?.msg || result?.message || '未知错误'}`);
|
||
}
|
||
loading.value = false;
|
||
}
|
||
|
||
completeCenterProgress(true, '数据处理完成!');
|
||
};
|
||
|
||
// ==== 通用函数 ====
|
||
|
||
// 检查字符是否为字母数字
|
||
const isAlphanumeric = (char) => {
|
||
const code = char.charCodeAt(0);
|
||
return (code >= 48 && code <= 57) || // 0-9
|
||
(code >= 65 && code <= 90) || // A-Z
|
||
(code >= 97 && code <= 122); // a-z
|
||
};
|
||
const isnumeric = (char) => {
|
||
const code = char.charCodeAt(0);
|
||
return (code >= 48 && code <= 57) ; // 0-9
|
||
};
|
||
const isnumericDot = (char) => {
|
||
const code = char.charCodeAt(0);
|
||
return (code >= 48 && code <= 57)||char==='.' ; // 0-9
|
||
};
|
||
const isAlpha= (char) => {
|
||
const code = char.charCodeAt(0);
|
||
return (code >= 65 && code <= 90) || // A-Z
|
||
(code >= 97 && code <= 122); // a-z
|
||
};
|
||
|
||
function validateString(input) {
|
||
// 如果输入为空或不是字符串，直接返回 false
|
||
if (typeof input !== 'string' || input.length === 0) {
|
||
return false;
|
||
}
|
||
|
||
// 正则表达式：匹配中文字符（\u4e00-\u9fa5）或字母数字
|
||
const regex = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/;
|
||
|
||
// 遍历字符串中的每个字符
|
||
for (let i = 0; i < input.length; i++) {
|
||
const char = input[i];
|
||
// 如果字符不符合要求，返回 false
|
||
if (!regex.test(char)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 所有字符都符合要求
|
||
return true;
|
||
}
|
||
|
||
// 通用标记添加函数
|
||
const addTag = (tagName,RuleStr,context) => {
|
||
// 解构上下文对象
|
||
const { tags, nextChar, tagOrder, value } = context;
|
||
const sBSC=GetBSC(RuleStr);
|
||
let sCPH='',sCXH='';
|
||
// 获取当前字符
|
||
if (tagName === 'XLXH') {
|
||
sCPH=ProdCPH_XLXH(sBSC);
|
||
sCXH=ProdCXH_XLXH(sBSC);
|
||
}
|
||
else if (tagName === 'DYDJ') {
|
||
sCPH=ProdCPH_DYDJ(sBSC);
|
||
sCXH=ProdCXH_DYDJ(sBSC);
|
||
}
|
||
else if (tagName === 'XLBZ') {
|
||
sCPH=ProdCPH_XLBZ(sBSC);
|
||
sCXH=ProdCXH_XLBZ(sBSC);
|
||
}
|
||
else if (tagName === 'XLGG') {
|
||
sCPH=ProdCPH_XLGG(sBSC);
|
||
sCXH=ProdCXH_XLGG(sBSC);
|
||
}
|
||
// 生成标记字符串
|
||
value.value =GetMRYFC(tagName,sCPH,sCXH);
|
||
};
|
||
|
||
// 创建上下文对象
|
||
const modelContext = {
|
||
tags: modelTags,
|
||
nextChar: modelNextChar,
|
||
tagOrder: modelTagOrder,
|
||
value: modelValue
|
||
};
|
||
|
||
const specContext = {
|
||
tags: specTags,
|
||
nextChar: specNextChar,
|
||
tagOrder: specTagOrder,
|
||
value: specValue
|
||
};
|
||
|
||
const voltageContext = {
|
||
tags: voltageTags,
|
||
nextChar: voltageNextChar,
|
||
tagOrder: voltageTagOrder,
|
||
value: voltageValue
|
||
};
|
||
|
||
const standardContext = {
|
||
tags: standardTags,
|
||
nextChar: standardNextChar,
|
||
tagOrder: standardTagOrder,
|
||
value: standardValue
|
||
};
|
||
|
||
// 原函数改为调用通用函数
|
||
const addModelTag = RuleStr => addTag('XLXH',RuleStr,modelContext);
|
||
const addSpecTag = RuleStr => addTag('XLGG',RuleStr, specContext);
|
||
const addvoltageTag = RuleStr => addTag('DYDJ',RuleStr, voltageContext);
|
||
const addstandardTag = RuleStr => addTag('XLBZ',RuleStr, standardContext);
|
||
function GetMRYFC(sYFLX, sCPH, sCXH) {
|
||
debugger
|
||
sYFLX = (sYFLX || '').trim();
|
||
sCPH = (sCPH || '').trim();
|
||
sCXH = (sCXH || '').trim();
|
||
let sYFC = '', tmp;
|
||
|
||
// 型号拆分处理（XLXH）
|
||
if (sYFLX === 'XLXH') {
|
||
const processCode = (char, typeName) => {
|
||
let s = sCXH, res = '';
|
||
while (s.includes(char)) {
|
||
const pos = s.indexOf(char);
|
||
res += `[${s.substr(pos, 2).replace(new RegExp(char, 'g'), typeName)}]`;
|
||
s = s.substring(pos + 2);
|
||
}
|
||
return res;
|
||
};
|
||
if(FGF.value==='空')
|
||
return processCode('B', '前缀码') + processCode('A', '型号码') + processCode('C', '后缀码');
|
||
else
|
||
{
|
||
if(processCode('A', '型号码')!=''&&processCode('B', '前缀码')!='')
|
||
return processCode('B', '前缀码') +FGF.value+ processCode('A', '型号码') + processCode('C', '后缀码');
|
||
else
|
||
return processCode('B', '前缀码') + processCode('A', '型号码') + processCode('C', '后缀码');
|
||
}
|
||
}
|
||
|
||
// 规格处理（XLGG）
|
||
else if (sYFLX === 'XLGG') {
|
||
const getCode = (char, typeName) => {
|
||
const pos = sCXH.indexOf(char);
|
||
return pos >= 0 ? `[${sCXH.substr(pos, 2).replace(char, typeName)}]` : '';
|
||
};
|
||
|
||
const getNextCode = (startChar, str, typeName) => {
|
||
const pos = str.indexOf(startChar);
|
||
return pos >= 0 ? `[${str.substr(pos, 2).replace(startChar, typeName)}]` : '';
|
||
};
|
||
|
||
switch (sCPH) {
|
||
case 'A1':
|
||
if (sCXH.includes('A')) sYFC = '[截面a]';
|
||
break;
|
||
case 'A2':
|
||
if (sCXH.includes('A')) sYFC = '[截面a]/[截面b]';
|
||
break;
|
||
case 'A1B1':
|
||
if (sCXH.includes('A') && sCXH.includes('B')) {
|
||
sYFC = `${getCode('B', '芯数')}*${getCode('A', '截面')}`;
|
||
}
|
||
break;
|
||
case 'A1B2':
|
||
const a1Pos = sCXH.indexOf('A');
|
||
if (a1Pos >= 0) {
|
||
tmp = sCXH.substring(a1Pos + 2);
|
||
if (sCXH.includes('B') && tmp.includes('A')) {
|
||
sYFC = `${getCode('B', '芯数')}*${getCode('A', '截面')}`
|
||
+ `+${getCode('B', '芯数')}*${getNextCode('A', tmp, '截面')}`;
|
||
}
|
||
}
|
||
break;
|
||
case 'A2B2':
|
||
const aPos = sCXH.indexOf('A');
|
||
const bPos = sCXH.indexOf('B');
|
||
if (aPos >= 0 && bPos >= 0) {
|
||
const bStr = sCXH.substring(bPos + 2);
|
||
tmp = sCXH.substring(aPos + 2);
|
||
if (bStr.includes('B') && tmp.includes('A')) {
|
||
sYFC = `${getCode('B', '芯数')}*${getCode('A', '截面')}`
|
||
+ `+${getNextCode('B', bStr, '芯数')}*${getNextCode('A', tmp, '截面')}`;
|
||
}
|
||
}
|
||
break;
|
||
case 'A1B1C1':
|
||
if (['A','B','C'].every(c => sCXH.includes(c))) {
|
||
sYFC = `${getCode('C', '线对数')}*${getCode('B', '芯数')}*${getCode('A', '截面')}`;
|
||
}
|
||
break;
|
||
case 'A1B1D1':
|
||
if (['A','B','D'].every(c => sCXH.includes(c))) {
|
||
sYFC = `${getCode('D', '线组数')}*${getCode('B', '芯数')}*${getCode('A', '截面')}`;
|
||
}
|
||
break;
|
||
}
|
||
|
||
// 默认处理规则
|
||
if (!sYFC && sCXH) {
|
||
let result = sCXH
|
||
.replace(/A/g, '][截面')
|
||
.replace(/B/g, '][芯数')
|
||
.replace(/C/g, '][线对数')
|
||
.replace(/D/g, '][线组数');
|
||
sYFC =result.substring(1) + ']';
|
||
}
|
||
return sYFC;
|
||
}
|
||
|
||
// 电压等级（DYDJ）处理
|
||
else if (sYFLX === 'DYDJ') {
|
||
const g = (c, n) => sCXH.includes(c) ? `[${sCXH.substr(sCXH.indexOf(c), 2).replace(c, n)}]` : '';
|
||
switch (sCPH) {
|
||
case 'A1': sYFC = g('A', '相电压'); break;
|
||
case 'B1': sYFC = g('B', '线电压'); break;
|
||
case 'A1B1':
|
||
if (sCXH.includes('A') && sCXH.includes('B')) {
|
||
sYFC = `${g('A', '相电压')}/${g('B', '线电压')}`;
|
||
}
|
||
break;
|
||
case 'B1C1':
|
||
if (sCXH.includes('B') && sCXH.includes('C')) {
|
||
sYFC = `${g('B', '线电压')}${g('C', '电压单位')}`;
|
||
}
|
||
break;
|
||
case 'A1B1C1':
|
||
if (sCXH.includes('A') && sCXH.includes('B') && sCXH.includes('C')) {
|
||
sYFC = `${g('A', '相电压')}/${g('B', '线电压')}${g('C', '电压单位')}`;
|
||
}
|
||
break;
|
||
}
|
||
if (!sYFC && sCXH) {
|
||
let result = sCXH
|
||
.replace(/A/g, '][相电压')
|
||
.replace(/B/g, '][线电压')
|
||
.replace(/C/g, '][电压单位')
|
||
sYFC =result.substring(1) + ']';
|
||
}
|
||
return sYFC;
|
||
}
|
||
|
||
// 标准（XLBZ）处理
|
||
else if (sYFLX === 'XLBZ') {
|
||
if (sCPH === 'A1' && sCXH.includes('A')) {
|
||
sYFC = '[标准名a]';
|
||
}
|
||
if (!sYFC && sCXH) {
|
||
sYFC = `[${sCXH.replace(/A/g, '标准名').replace(/A/g, '][标准名').substring(2)}]`;
|
||
}
|
||
return sYFC;
|
||
}
|
||
|
||
// 颜色（XLYS）处理
|
||
else if (sYFLX === 'XLYS') {
|
||
if (sCPH === 'A1' && sCXH.includes('A')) {
|
||
sYFC = '[颜色名a]';
|
||
} else if (sCPH === 'A2' && sCXH.includes('A')) {
|
||
sYFC = '[颜色名a][颜色名b]';
|
||
}
|
||
if (!sYFC && sCXH) {
|
||
sYFC = `[${sCXH.replace(/A/g, '][颜色名').substring(2)}]`;
|
||
}
|
||
return sYFC;
|
||
}
|
||
|
||
return '';
|
||
}
|
||
|
||
function GetBSC(inputText) {
|
||
// 实现 GetOptionIdList 的功能：提取文本中所有 [XX=YY] 中的 XX
|
||
const getOptionIdList = (str) => {
|
||
const matches = []; // 存储提取结果的数组
|
||
// 使用正则表达式匹配 [XX=YY] 模式，并提取 XX
|
||
const regex = /\[([^\]=]+)=[^\]]+\]/g;
|
||
let match;
|
||
// 循环获取所有匹配项
|
||
while ((match = regex.exec(str)) !== null) {
|
||
matches.push(match[1]); // 将捕获组1（XX）添加到结果数组
|
||
}
|
||
return matches;
|
||
};
|
||
|
||
const str = inputText;
|
||
const BLZList = getOptionIdList(str);
|
||
let sBSC = '';
|
||
// 拼接成 [XX][YY] 格式的字符串
|
||
for (let i = 0; i < BLZList.length; i++) {
|
||
sBSC += '[' + BLZList[i] + ']';
|
||
}
|
||
return sBSC;
|
||
}
|
||
|
||
function ProdCPH_XLXH(aJXGZC) {
|
||
const SBLZsXLXH = ['型号码', '前缀码', '后缀码'];
|
||
return prodCPH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCXH_XLXH(aJXGZC) {
|
||
const SBLZsXLXH = ['型号码', '前缀码', '后缀码'];
|
||
return ProdCXH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCPH_XLGG(aJXGZC) {
|
||
const SBLZsXLXH = ['截面', '芯数', '线对数', '线组数'];
|
||
return prodCPH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCXH_XLGG(aJXGZC) {
|
||
const SBLZsXLXH = ['截面', '芯数', '线对数', '线组数'];
|
||
return ProdCXH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCPH_DYDJ(aJXGZC) {
|
||
const SBLZsXLXH = ['相电压', '线电压', '电压单位'];
|
||
return prodCPH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCXH_DYDJ(aJXGZC) {
|
||
const SBLZsXLXH = ['相电压', '线电压', '电压单位'];
|
||
return ProdCXH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCPH_XLBZ(aJXGZC) {
|
||
const SBLZsXLXH = ['标准名'];
|
||
return prodCPH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function ProdCXH_XLBZ(aJXGZC) {
|
||
const SBLZsXLXH = ['标准名'];
|
||
return ProdCXH(aJXGZC, SBLZsXLXH);
|
||
}
|
||
|
||
function prodCPH(aJXGZC, aBJCTag) {
|
||
// 初始化计数数组
|
||
const tokenCount = new Array(64).fill(0);
|
||
const BJCTagLen = [];
|
||
|
||
// 存储每个标签的长度
|
||
for (let i = 0; i < aBJCTag.length; i++) {
|
||
BJCTagLen[i] = aBJCTag[i].length;
|
||
}
|
||
|
||
let index = 0;
|
||
const inputLength = aJXGZC.length;
|
||
let result = '';
|
||
|
||
while (index < inputLength) {
|
||
// 查找下一个左括号 '['
|
||
while (index < inputLength && aJXGZC[index] !== '[') {
|
||
index++;
|
||
}
|
||
|
||
if (index >= inputLength) break;
|
||
index++; // 跳过 '['
|
||
|
||
const startIndex = index;
|
||
|
||
// 查找下一个右括号 ']'
|
||
while (index < inputLength && aJXGZC[index] !== ']') {
|
||
index++;
|
||
}
|
||
|
||
if (index >= inputLength) break;
|
||
|
||
const tagContent = aJXGZC.substring(startIndex, index);
|
||
const tagLen = tagContent.length;
|
||
let found = false;
|
||
|
||
// 处理单字符标签 (A-Z)
|
||
if (tagLen === 1) {
|
||
const charCode = tagContent.charCodeAt(0);
|
||
if (charCode >= 65 && charCode <= 90) { // A-Z
|
||
const idx = charCode - 65;
|
||
if (idx < aBJCTag.length) {
|
||
tokenCount[idx]++;
|
||
found = true;
|
||
}
|
||
}
|
||
}
|
||
// 处理多字符标签
|
||
else {
|
||
for (let i = 0; i < aBJCTag.length; i++) {
|
||
const tag = aBJCTag[i];
|
||
// 检查标签长度匹配
|
||
if (tagLen === BJCTagLen[i]) {
|
||
// 不区分大小写的比较
|
||
if (tagContent.toLowerCase() === tag.toLowerCase()) {
|
||
tokenCount[i]++;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
index++; // 跳过 ']'
|
||
}
|
||
|
||
// 构造结果字符串
|
||
for (let i = 0; i < aBJCTag.length; i++) {
|
||
if (tokenCount[i] > 0) {
|
||
result += String.fromCharCode(65 + i) + tokenCount[i].toString();
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
function ProdCXH(aJXGZC, aBJCTag) {
|
||
|
||
// 获取选项ID列表 (如 ['型号码', '前缀码', ...])
|
||
const getOptionIdList = (str) => {
|
||
const matches = [];
|
||
const regex = /\[([^\]]+)\]/g;
|
||
let match;
|
||
while ((match = regex.exec(str)) !== null) {
|
||
matches.push(match[1]);
|
||
}
|
||
return matches;
|
||
};
|
||
|
||
let result = '';
|
||
const BLZList = getOptionIdList(aJXGZC);
|
||
let BLZOrder = 97; // 'a'的ASCII码
|
||
|
||
// 遍历每个保留字标识符
|
||
for (let i = 0; i < BLZList.length; i++) {
|
||
const curBLZ = BLZList[i];
|
||
let found = false;
|
||
|
||
// 检查当前保留字是否在指定标签列表中
|
||
for (let j = 0; j < aBJCTag.length; j++) {
|
||
if (aBJCTag[j] === curBLZ) {
|
||
// 生成编码：字母(A,B,C...) + 顺序号(a,b,c...)
|
||
const letter = String.fromCharCode(65 + j);
|
||
const orderChar = String.fromCharCode(BLZOrder);
|
||
result += letter + orderChar;
|
||
BLZOrder++; // 顺序号递增
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
const openSyntaxPage = () => {
|
||
// 构建URL参数
|
||
const title = "线缆型号语法";
|
||
const ruleString1 = encodeURIComponent(ruleString.value);
|
||
const reservedWords = "型号码,前缀码,后缀码";
|
||
const connectors = ",-,/,(,)";
|
||
const syntaxString = encodeURIComponent(modelValue.value);
|
||
// 生成唯一ID用于标识这个窗口
|
||
const windowId = Date.now().toString();
|
||
// 打开新窗口
|
||
const url = `cable_model_syntax.html?title=${title}&ruleString=${ruleString1}&reservedWords=${reservedWords}&connectors=${connectors}&syntaxString=${syntaxString}&windowId=${windowId}`;
|
||
const syntaxWindow = window.open(url, '_blank', 'width=950,height=750,location=no');
|
||
window.syntaxWindows = window.syntaxWindows || {};
|
||
window.syntaxWindows[windowId] = syntaxWindow;
|
||
// 设置轮询检查窗口状态
|
||
const checkWindowClosed = setInterval(() => {
|
||
if (!window.syntaxWindows[windowId] || window.syntaxWindows[windowId].closed) {
|
||
clearInterval(checkWindowClosed);
|
||
handleSyntaxWindowClosed(windowId);
|
||
}
|
||
}, 500);
|
||
};
|
||
|
||
|
||
const closePage = () => {
|
||
let topDocument;
|
||
try {
|
||
topDocument = top.document;
|
||
} catch (e) {
|
||
topDocument = document; // 跨域时回退到当前文档
|
||
}
|
||
try {
|
||
// 获取元素引用
|
||
const divZDY = topDocument.getElementById("div_ZDY");
|
||
const divZDY_100860140 =
|
||
topDocument.getElementById("divZDY_100860140");
|
||
|
||
// 确保主容器存在
|
||
if (!divZDY) return;
|
||
|
||
// 清除divZDY_102849000（如果存在）
|
||
if (divZDY_100860140) {
|
||
divZDY.removeChild(divZDY_100860140);
|
||
}
|
||
while (divZDY.firstChild) {
|
||
divZDY.removeChild(divZDY.firstChild);
|
||
}
|
||
|
||
// 隐藏主容器
|
||
divZDY.style.display = "none";
|
||
} catch (error) {
|
||
console.error("隐藏自定义元素时出错:", error);
|
||
}
|
||
// 刷新报价单
|
||
const frameElement = topDocument.getElementById('XLBJDInfo_frame');
|
||
if (!frameElement) {
|
||
console.log('未找到 XLBJDInfo_frame');
|
||
} else {
|
||
const iframeDoc = frameElement.contentWindow.document;
|
||
if (!iframeDoc) {
|
||
console.log('跨域访问被阻止');
|
||
} else {
|
||
const reloadButton = iframeDoc.getElementById('ctl00_CPHButton_btnReLoad');
|
||
if (reloadButton) {
|
||
reloadButton.click();
|
||
} else {
|
||
console.log('未找到 btnReLoad 控件');
|
||
}
|
||
}
|
||
}
|
||
|
||
};
|
||
|
||
// 处理窗口关闭
|
||
const handleSyntaxWindowClosed = (windowId) => {
|
||
// 从localStorage获取返回值
|
||
const resultKey = `syntaxResult_${windowId}`;
|
||
const result = localStorage.getItem(resultKey);
|
||
|
||
if (result) {
|
||
try {
|
||
const parsedResult = JSON.parse(result);
|
||
processSyntaxResult(parsedResult);
|
||
} catch (e) {
|
||
console.error('解析返回值失败:', e);
|
||
ElMessage.error('解析语法规则返回值失败');
|
||
} finally {
|
||
// 清理存储
|
||
localStorage.removeItem(resultKey);
|
||
delete window.syntaxWindows[windowId];
|
||
}
|
||
} else {
|
||
ElMessage.warning('语法规则窗口已关闭，但未返回任何值');
|
||
}
|
||
};
|
||
|
||
// 处理返回值
|
||
const processSyntaxResult = (result) => {
|
||
if (result && result.modelValue) {
|
||
|
||
// 更新实际值
|
||
if (result.modelValue) {
|
||
modelValue.value = result.modelValue;
|
||
modelActualValue.value = result.modelActualValue;
|
||
}
|
||
|
||
ElMessage.success('语法规则已更新');
|
||
} else {
|
||
ElMessage.warning('未返回有效的语法规则');
|
||
}
|
||
};
|
||
|
||
// 重置线缆型号标记
|
||
const resetTags = () => {
|
||
modelTags.value = [];
|
||
modelNextChar.value = 97;
|
||
modelValue.value = '';
|
||
modelActualValue.value = '';
|
||
specTags.value = [];
|
||
specNextChar.value = 97;
|
||
specValue.value = '';
|
||
specActualValue.value = '';
|
||
voltageTags.value = [];
|
||
voltageNextChar.value = 97;
|
||
voltageValue.value = '';
|
||
voltageActualValue.value = '';
|
||
standardTags.value = [];
|
||
standardNextChar.value = 97;
|
||
standardValue.value = '';
|
||
standardActualValue.value = '';
|
||
|
||
specValue.value = '';
|
||
voltageValue.value = '';
|
||
standardValue.value = '';
|
||
colorValue.value = '';
|
||
};
|
||
|
||
|
||
const parseRuleValue = async () => {
|
||
|
||
if (!ruleString.value) {
|
||
modelActualValue.value = '';
|
||
specActualValue.value = '';
|
||
voltageActualValue.value = '';
|
||
standardActualValue.value = '';
|
||
return;
|
||
}
|
||
|
||
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 创建 XLJXGZ 对象
|
||
const ruleConfig = {
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: BJDID, // 使用固定的解析规则代号
|
||
XLJXGZXH: "0", // 默认序号
|
||
XLJXGZC: ruleString.value,
|
||
XLXHYFC: modelValue.value,
|
||
XLGGYFC: specValue.value,
|
||
DYDJYFC: voltageValue.value,
|
||
XLBZYFC: standardValue.value,
|
||
XLYSYFC: colorValue.value || "",
|
||
WHR: "",
|
||
WHRID: "",
|
||
WHSJ: new Date().toISOString()
|
||
};
|
||
|
||
// 调用 XLYSTZJX 服务
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'XLYSTZJX',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'item': ruleConfig,
|
||
'sXLBSC': ruleString.value.replace(/\[([^\]]+)=([^\]]+)\]/g, '$2') // 添加规则串参数
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"XLYSTZJX",
|
||
50000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
|
||
|
||
// 更新实际值
|
||
if (result) {
|
||
modelActualValue.value = result.XLXH || '';
|
||
specActualValue.value = result.XLGG || '';
|
||
voltageActualValue.value = result.DYDJ || '';
|
||
standardActualValue.value = result.XLBZ || '';
|
||
} else {
|
||
ElMessage.warning('解析服务返回空结果');
|
||
}
|
||
|
||
} catch (error) {
|
||
|
||
console.error('规则解析失败:', error);
|
||
ElMessage.error(`规则解析失败: ${error.message || '服务异常'}`);
|
||
|
||
// 设置默认值
|
||
modelActualValue.value = '';
|
||
specActualValue.value = '';
|
||
voltageActualValue.value = '';
|
||
standardActualValue.value = '';
|
||
}
|
||
|
||
|
||
};
|
||
|
||
// 原始函数改为调用通用函数
|
||
const parseModelValue = parseRuleValue;
|
||
const parseSpecValue = parseRuleValue;
|
||
const parsevoltageValue = parseRuleValue;
|
||
const parsestandardValue = parseRuleValue;
|
||
|
||
// 通用标记函数
|
||
const createMarker = (tagName, validatorFunc, errorMessage) => {
|
||
return () => {
|
||
if (!ruleEditor.value) return;
|
||
|
||
const textarea = ruleEditor.value;
|
||
const text = ruleString.value;
|
||
let start = textarea.selectionStart;
|
||
let end = textarea.selectionEnd;
|
||
|
||
// 检查选中区域是否在已有标记内部
|
||
function isInsideMark(startPos, endPos) {
|
||
let inMark = false;
|
||
let lastOpen = -1;
|
||
|
||
for (let i = 0; i <= endPos; i++) {
|
||
if (i === text.length) break;
|
||
|
||
if (text[i] === '[') {
|
||
lastOpen = i;
|
||
inMark = true;
|
||
} else if (text[i] === ']' && lastOpen !== -1) {
|
||
inMark = false;
|
||
}
|
||
|
||
// 检查当前位置是否在标记范围内
|
||
if (i >= startPos && i < endPos && inMark) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 检查结束位置是否在未闭合的标记内
|
||
return inMark && (lastOpen <= startPos);
|
||
}
|
||
|
||
// 自动扩展选择范围的通用逻辑
|
||
if (end - start <= 0) {
|
||
// 向左扩展
|
||
let left = start;
|
||
while (left > 0 && validatorFunc(text.charAt(left - 1))) left--;
|
||
|
||
// 向右扩展
|
||
let right = start;
|
||
while (right < text.length && validatorFunc(text.charAt(right))) right++;
|
||
|
||
if (left < right) {
|
||
textarea.setSelectionRange(left, right);
|
||
start = left;
|
||
end = right;
|
||
} else {
|
||
ElMessage.warning('请先选中要标记的文本');
|
||
return;
|
||
}
|
||
}
|
||
|
||
const selectedText = text.substring(start, end);
|
||
if (!selectedText) {
|
||
ElMessage.warning('请先选中要标记的文本');
|
||
return;
|
||
}
|
||
|
||
// 精确判断是否在已有标记内部
|
||
if (isInsideMark(start, end)) {
|
||
ElMessage.error('选中区域位于已有标记内部，无法再次标记！');
|
||
return;
|
||
}
|
||
|
||
// 统一使用传入的验证函数
|
||
for (let i = 0; i < selectedText.length; i++) {
|
||
if (!validatorFunc(selectedText[i])) {
|
||
ElMessage.error(errorMessage);
|
||
return;
|
||
}
|
||
}
|
||
|
||
const markedText = `[${tagName}=${selectedText}]`;
|
||
ruleString.value = text.substring(0, start) + markedText + text.substring(end);
|
||
// 统一处理标记分组
|
||
const groups = {
|
||
// 型号分组
|
||
型号: {
|
||
tags: ['前缀码', '型号码', '后缀码', '型号'],
|
||
add: addModelTag,
|
||
parse: parseModelValue
|
||
},
|
||
// 规格分组
|
||
规格: {
|
||
tags: ['芯数', '截面', '线组数', '线对数', '规格'],
|
||
add: addSpecTag,
|
||
parse: parseSpecValue
|
||
},
|
||
// 电压分组
|
||
电压: {
|
||
tags: ['相电压', '线电压', '电压单位', '电压等级'],
|
||
add: addvoltageTag,
|
||
parse: parsevoltageValue
|
||
},
|
||
// 标准分组
|
||
标准: {
|
||
tags: ['标准名'],
|
||
add: addstandardTag,
|
||
parse: parsestandardValue
|
||
}
|
||
};
|
||
|
||
// 找到对应的分组并执行
|
||
Object.values(groups).forEach(group => {
|
||
if (group.tags.includes(tagName)) {
|
||
group.add(ruleString.value);
|
||
group.parse();
|
||
}
|
||
});
|
||
|
||
// 重置选择和设置光标位置
|
||
selection.value = { start: 0, end: 0, text: '' };
|
||
nextTick(() => {
|
||
const newStart = start + markedText.length;
|
||
ruleEditor.value.setSelectionRange(newStart, newStart);
|
||
ruleEditor.value.focus();
|
||
});
|
||
};
|
||
};
|
||
|
||
// ==== 创建具体标记函数 ====
|
||
|
||
// 型号相关标记函数
|
||
const markPrefixCode = createMarker(
|
||
'前缀码',
|
||
isAlphanumeric,
|
||
'前缀码只能包含字母和数字'
|
||
);
|
||
|
||
const markModelCode = createMarker(
|
||
'型号码',
|
||
isAlphanumeric,
|
||
'型号码只能包含字母和数字'
|
||
);
|
||
|
||
const markSuffixCode = createMarker(
|
||
'后缀码',
|
||
isAlphanumeric,
|
||
'后缀码只能包含字母和数字'
|
||
);
|
||
|
||
// 标准名标记函数
|
||
const markStandardName = createMarker(
|
||
'标准名',
|
||
validateString, // 使用统一的验证函数
|
||
'标准名包含无效字符' // 统一错误消息
|
||
);
|
||
|
||
// 电压相关标记函数
|
||
const markVoltagePhase = createMarker(
|
||
'相电压',
|
||
isnumericDot,
|
||
'相电压应为数字'
|
||
);
|
||
|
||
const markVoltageLine = createMarker(
|
||
'线电压',
|
||
isnumericDot,
|
||
'线电压应为数字'
|
||
);
|
||
|
||
const markVoltageUnit = createMarker(
|
||
'电压单位',
|
||
isAlpha,
|
||
'电压单位只能为字母'
|
||
);
|
||
|
||
const markVoltageLevel = createMarker(
|
||
'电压等级',
|
||
isnumeric,
|
||
'电压等级应为数字'
|
||
);
|
||
|
||
// 规格相关标记函数
|
||
const markWireCount = createMarker(
|
||
'芯数',
|
||
isnumeric,
|
||
'芯数必须为数字'
|
||
);
|
||
|
||
const markSection = createMarker(
|
||
'截面',
|
||
isnumericDot,
|
||
'截面必须为数字'
|
||
);
|
||
|
||
const markWireGroup = createMarker(
|
||
'线组数',
|
||
isnumeric,
|
||
'线组数必须为数字'
|
||
);
|
||
|
||
const markWirePair = createMarker(
|
||
'线对数',
|
||
isnumeric,
|
||
'线对数必须为数字'
|
||
);
|
||
|
||
const markSpec = createMarker(
|
||
'规格',
|
||
isnumeric,
|
||
'规格必须为数字'
|
||
);
|
||
|
||
// 批量插入函数
|
||
const bulkInsertXLJXMX = async (items) => {
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 分批处理（每批500条）
|
||
const batchSize = 100000;
|
||
const totalBatches = Math.ceil(items.length / batchSize);
|
||
let successCount = 0;
|
||
let errorMessages = [];
|
||
|
||
for (let i = 0; i < totalBatches; i++) {
|
||
const start = i * batchSize;
|
||
const end = Math.min(start + batchSize, items.length);
|
||
const batch = items.slice(start, end);
|
||
|
||
try {
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'InsertXLJXMXList',
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007,
|
||
'items': batch
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"InsertXLJXMXList",
|
||
300000 // 30秒超时
|
||
);
|
||
});
|
||
|
||
if (result && result.success) {
|
||
successCount += batch.length;
|
||
} else {
|
||
errorMessages.push(`批次${i+1}插入失败: ${result?.message || '未知错误'}`);
|
||
}
|
||
} catch (error) {
|
||
errorMessages.push(`批次${i+1}插入失败: ${error.message || '服务异常'}`);
|
||
}
|
||
|
||
// 更新进度（仅针对导入Excel）
|
||
if (importing.value) {
|
||
importProgress.value = Math.round(((i + 1) / totalBatches) * 100);
|
||
}
|
||
}
|
||
|
||
// 返回合并结果
|
||
if (errorMessages.length === 0) {
|
||
return { success: true, message: `成功插入${successCount}条数据` };
|
||
} else {
|
||
return {
|
||
success: false,
|
||
message: `成功插入${successCount}条，失败${items.length - successCount}条。错误详情:${errorMessages.slice(0, 5).join('')}${errorMessages.length > 5 ? `...等${errorMessages.length}条错误` : ''}`
|
||
};
|
||
}
|
||
} catch (error) {
|
||
console.error('批量插入失败:', error);
|
||
return {
|
||
success: false,
|
||
message: `批量插入失败: ${error.message || '服务异常'}`
|
||
};
|
||
}
|
||
};
|
||
|
||
// ==== Excel导入相关函数 ====
|
||
const showImportDialog = () => {
|
||
importDialogVisible.value = true;
|
||
resetImport();
|
||
};
|
||
|
||
const closeImportDialog = () => {
|
||
importDialogVisible.value = false;
|
||
resetImport();
|
||
};
|
||
|
||
const resetImport = () => {
|
||
excelFile.value = null;
|
||
excelColumns.value = [];
|
||
previewData.value = [];
|
||
importProgress.value = 0;
|
||
importedCount.value = 0;
|
||
totalRows.value = 0;
|
||
importStatus.value = null;
|
||
errorMessage.value = '';
|
||
successMessage.value = '';
|
||
importing.value = false;
|
||
canImport.value = false;
|
||
|
||
// 重置映射关系
|
||
tableColumns.value.forEach(col => {
|
||
columnMapping[col] = null;
|
||
});
|
||
};
|
||
|
||
const triggerFileInput = () => {
|
||
if (fileInput.value) {
|
||
fileInput.value.click();
|
||
}
|
||
};
|
||
|
||
const handleFileChange = (e) => {
|
||
const file = e.target.files ? e.target.files[0] : null;
|
||
if (!file) return;
|
||
|
||
// 检查文件类型
|
||
if (!/\.(xlsx|xls)$/i.test(file.name)) {
|
||
errorMessage.value = '请选择Excel文件(.xlsx或.xls格式)';
|
||
return;
|
||
}
|
||
|
||
// 检查文件大小 (最大100MB)
|
||
if (file.size > 100 * 1024 * 1024) {
|
||
errorMessage.value = '文件过大，请选择小于100MB的Excel文件';
|
||
return;
|
||
}
|
||
|
||
excelFile.value = file;
|
||
errorMessage.value = '';
|
||
|
||
// 开始解析Excel
|
||
readExcelFile(file);
|
||
};
|
||
|
||
const readExcelFile = (file) => {
|
||
importing.value = true;
|
||
errorMessage.value = '';
|
||
importStatus.value = null;
|
||
|
||
const reader = new FileReader();
|
||
reader.onload = function(e) {
|
||
try {
|
||
const data = new Uint8Array(e.target.result);
|
||
const workbook = XLSX.read(data, { type: 'array' });
|
||
|
||
// 获取第一个工作表
|
||
const firstSheetName = workbook.SheetNames[0];
|
||
const worksheet = workbook.Sheets[firstSheetName];
|
||
|
||
// 将工作表转换为JSON
|
||
const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
|
||
|
||
if (jsonData.length === 0) {
|
||
errorMessage.value = 'Excel文件中没有数据';
|
||
importing.value = false;
|
||
return;
|
||
}
|
||
|
||
// 获取列名（假设第一行是列名）
|
||
excelColumns.value = jsonData[0].map(col => col || '未命名列');
|
||
|
||
// 提取预览数据（2-11行）
|
||
previewData.value = [];
|
||
for (let i = 1; i < Math.min(jsonData.length, 11); i++) {
|
||
const rowObj = {};
|
||
jsonData[i].forEach((cell, index) => {
|
||
rowObj[excelColumns.value[index]] = cell;
|
||
});
|
||
previewData.value.push(rowObj);
|
||
}
|
||
|
||
canImport.value = true;
|
||
importing.value = false;
|
||
totalRows.value = jsonData.length - 1;
|
||
ElMessage.success(`成功解析${totalRows.value}条数据`);
|
||
} catch (error) {
|
||
console.error('Excel解析错误:', error);
|
||
errorMessage.value = `Excel文件解析失败: ${error.message}`;
|
||
importing.value = false;
|
||
}
|
||
};
|
||
|
||
reader.onerror = (error) => {
|
||
console.error('文件读取错误:', error);
|
||
errorMessage.value = `文件读取失败: ${error.target.error.message}`;
|
||
importing.value = false;
|
||
};
|
||
|
||
reader.readAsArrayBuffer(file);
|
||
};
|
||
|
||
const startImport = async () => {
|
||
// 验证映射配置
|
||
if (!columnMapping['报价产品']) {
|
||
errorMessage.value = '请至少映射"报价产品"列';
|
||
return;
|
||
}
|
||
|
||
importing.value = true;
|
||
importProgress.value = 0;
|
||
importedCount.value = 0;
|
||
importStatus.value = null;
|
||
errorMessage.value = '';
|
||
successMessage.value = '';
|
||
|
||
// 重新读取文件以获取完整数据
|
||
const reader = new FileReader();
|
||
reader.onload = async function(e) {
|
||
try {
|
||
const data = new Uint8Array(e.target.result);
|
||
const workbook = XLSX.read(data, { type: 'array' });
|
||
const firstSheetName = workbook.SheetNames[0];
|
||
const worksheet = workbook.Sheets[firstSheetName];
|
||
const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
|
||
|
||
// 跳过标题行
|
||
const rows = jsonData.slice(1);
|
||
const itemsToInsert = [];
|
||
const newTableData = [];
|
||
|
||
// 为所有记录生成相同的XLJXDH
|
||
const commonXLJXDH =BJDID;
|
||
|
||
// 处理每一行数据
|
||
for (let i = 0; i < rows.length; i++) {
|
||
const row = rows[i];
|
||
const rowData = {};
|
||
|
||
// 映射Excel列到系统字段
|
||
tableColumns.value.forEach(col => {
|
||
const excelCol = columnMapping[col];
|
||
if (excelCol) {
|
||
const colIndex = excelColumns.value.indexOf(excelCol);
|
||
if (colIndex !== -1) {
|
||
rowData[col.toLowerCase()] = row[colIndex] || '';
|
||
}
|
||
}
|
||
});
|
||
|
||
// 创建数据库对象
|
||
const product = rowData['报价产品'] || '';
|
||
const sequenceNumber = (i + 1).toString(); // 生成序号
|
||
itemsToInsert.push({
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: BJDID, // 使用相同的代号
|
||
XLJXMXH: sequenceNumber,
|
||
XLBSC: product,
|
||
XLJXGZXH: "0",
|
||
JXXLXHID: rowData['型号'] || "",
|
||
XLXHID: "",
|
||
JXXLGGID: rowData['规格'] || "",
|
||
XLGGID: "",
|
||
JXDYDJID: rowData['电压等级'] || "",
|
||
DYDJID: "",
|
||
XLBZID: rowData['标准'] || "",
|
||
JXXLBZID: "",
|
||
XLYSID: "",
|
||
JXXLYSID: "",
|
||
WHR: "",
|
||
WHRID: "",
|
||
WHSJ: "",
|
||
DCZT: "N" ,
|
||
JLDW: rowData['计量单位'] || "",
|
||
SL: rowData['数量'] || ""
|
||
});
|
||
|
||
newTableData.push({
|
||
index: sequenceNumber, // 添加序号字段
|
||
product,
|
||
unit: rowData['计量单位'] || '',
|
||
quantity: rowData['数量'] || '',
|
||
model: rowData['型号'] || '',
|
||
voltage: rowData['电压等级'] || '',
|
||
standard: rowData['标准'] || '',
|
||
spec: rowData['规格'] || '',
|
||
status: 'N',
|
||
checked: false
|
||
});
|
||
|
||
// 更新进度
|
||
importedCount.value = i + 1;
|
||
importProgress.value = Math.round(((i + 1) / rows.length) * 100);
|
||
}
|
||
|
||
// 批量插入数据
|
||
if (itemsToInsert.length > 0) {
|
||
const result = await bulkInsertXLJXMX(itemsToInsert);
|
||
|
||
if (result && result.success) {
|
||
// 重新加载以同步服务端分配的解析序号（与 DRHH 关联）
|
||
await loadTableData();
|
||
|
||
importing.value = false;
|
||
successMessage.value = `成功导入${itemsToInsert.length}条产品数据`;
|
||
ElMessage.success(`成功导入${itemsToInsert.length}条产品数据`);
|
||
} else {
|
||
importing.value = false;
|
||
errorMessage.value = `导入失败: ${result?.message || '未知错误'}`;
|
||
ElMessage.error(`导入失败: ${result?.message || '未知错误'}`);
|
||
}
|
||
} else {
|
||
importing.value = false;
|
||
ElMessage.warning('Excel中没有有效数据');
|
||
}
|
||
} catch (error) {
|
||
console.error('导入错误:', error);
|
||
errorMessage.value = `导入失败: ${error.message}`;
|
||
importing.value = false;
|
||
importStatus.value = 'exception';
|
||
}
|
||
};
|
||
|
||
reader.readAsArrayBuffer(excelFile.value);
|
||
};
|
||
|
||
// 辅助函数：格式化文件大小
|
||
const formatFileSize = (bytes) => {
|
||
if (bytes < 1024) return bytes + ' bytes';
|
||
else if (bytes < 1048576) return (bytes / 1024).toFixed(2) + ' KB';
|
||
else return (bytes / 1048576).toFixed(2) + ' MB';
|
||
};
|
||
|
||
// ==== 其他功能函数 ====
|
||
|
||
// 保存文本选择
|
||
const saveSelection = () => {
|
||
if (!ruleEditor.value) return;
|
||
|
||
const textarea = ruleEditor.value;
|
||
const start = textarea.selectionStart;
|
||
const end = textarea.selectionEnd;
|
||
const text = textarea.value.substring(start, end);
|
||
|
||
selection.value = { start, end, text };
|
||
};
|
||
|
||
// 取消所有标记
|
||
const unmarkAll = () => {
|
||
// 移除所有标记格式 [tag=value]
|
||
ruleString.value = ruleString.value
|
||
.replace(/\[([^\]]+)=([^\]]+)\]/g, '$2');
|
||
|
||
// 清空所有配置项的值
|
||
resetTags();
|
||
|
||
|
||
// ElMessage.success('已取消所有标记');
|
||
};
|
||
|
||
// 粘贴数据
|
||
const pasteData = async () => {
|
||
const isHttps = window.location.protocol === 'https:';
|
||
logMappingDebug('pasteData.enter', { isHttps, protocol: window.location.protocol });
|
||
|
||
if (!isHttps) {
|
||
showManualPasteDialog();
|
||
logMappingDebug('pasteData.http.showManualPasteDialog', {});
|
||
return;
|
||
}
|
||
|
||
// HTTPS环境，使用列映射功能
|
||
try {
|
||
const text = await navigator.clipboard.readText();
|
||
if (!text) {
|
||
ElMessage.warning('剪贴板中没有数据');
|
||
return;
|
||
}
|
||
|
||
clipboardText = text;
|
||
const rows = text.split('\n').filter(row => row.trim() !== '');
|
||
|
||
if (rows.length === 0) {
|
||
ElMessage.warning('剪贴板中的数据为空');
|
||
return;
|
||
}
|
||
|
||
const firstRow = rows[0].split('\t');
|
||
detectedColumnCount.value = firstRow.length;
|
||
|
||
detectedPreviewRows.value = rows.slice(0, 5).map((row, idx) => {
|
||
const cols = row.split('\t');
|
||
const rowData = { rowIndex: idx + 1 };
|
||
for (let i = 0; i < cols.length; i++) {
|
||
rowData['col' + i] = cols[i];
|
||
}
|
||
return rowData;
|
||
});
|
||
|
||
applyDefaultColumnMapping(columnFieldMapping, detectedColumnCount.value);
|
||
|
||
manualPasteText.value = text;
|
||
pasteStep.value = 'mapping';
|
||
manualPasteDialogVisible.value = true;
|
||
nextTick(() => forceApplyDefaultColumnMapping(columnFieldMapping, detectedColumnCount.value));
|
||
|
||
} catch (err) {
|
||
if (err.name === 'NotAllowedError' || err.name === 'NotSupportedError') {
|
||
ElMessage.warning('剪贴板访问被拒绝，请使用手动粘贴');
|
||
showManualPasteDialog();
|
||
} else {
|
||
completeCenterProgress(false, `粘贴失败: ${err.message}`);
|
||
console.error('粘贴失败:', err);
|
||
ElMessage.error('粘贴数据失败: ' + (err.message || '服务异常'));
|
||
loading.value = false;
|
||
}
|
||
}
|
||
};
|
||
|
||
const GetFGF = async () => {
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetXHFGF',
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetXHFGF",
|
||
50000
|
||
);
|
||
});
|
||
|
||
FGF.value = result || [];
|
||
} catch (error) {
|
||
ElMessage.error('获取失败: ' + (error.message || '服务异常'));
|
||
} finally {
|
||
}
|
||
};
|
||
|
||
|
||
|
||
const normalizeBatchSpec = (value) => (value || '').replace(/×/g, '*');
|
||
|
||
// 加载表格数据
|
||
const loadTableData = async (options = {}) => {
|
||
const silent = options && options.silent === true;
|
||
loading.value = true;
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const params = buildListQueryParams();
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetXLJXMXList',
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007,
|
||
...params
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetXLJXMXList",
|
||
50000
|
||
);
|
||
});
|
||
|
||
tableData.value = (result || []).map(item => ({
|
||
index: item.XLJXMXH, // 序号字段
|
||
product: item.XLBSC,
|
||
unit: item.JLDW || '', // 新增
|
||
quantity: item.SL || '', // 新增
|
||
packageNumber:item.FBH, // 包号
|
||
techSpecId:item.JSGFID, // 技术规范ID
|
||
|
||
model: item.JXXLXHID || item.XLXHID,
|
||
XLXHID: item.XLXHID || '',
|
||
voltage: item.JXDYDJID || item.DYDJID,
|
||
standard: item.JXXLBZID || item.XLBZID,
|
||
spec: item.JXXLGGID || item.XLGGID,
|
||
XLGGID: item.XLGGID || '',
|
||
status: item.DCZT,
|
||
dx:item.DX,
|
||
XLJXGZXH:item.XLJXGZXH,
|
||
selected: false,
|
||
current: false // 添加当前行状态标识
|
||
}));
|
||
if (filterEquivalent.value) {
|
||
tableData.value=tableData.value.filter(item => item.dx !== ""&&item.dx != null);
|
||
}
|
||
|
||
// 更新下拉选项
|
||
updateFilterOptions();
|
||
|
||
if (!silent) {
|
||
ElMessage.success(`加载${tableData.value.length}条数据`);
|
||
}
|
||
} catch (error) {
|
||
ElMessage.error('数据加载失败: ' + (error.message || '服务异常'));
|
||
} finally {
|
||
loading.value = false;
|
||
}
|
||
};
|
||
|
||
const deleteData = async () => {
|
||
loading.value = true;
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const params = buildListQueryParams();
|
||
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'DeleteXLJXMX',
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007,
|
||
...params
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"DeleteXLJXMX",
|
||
50000
|
||
);
|
||
});
|
||
|
||
loadTableData();
|
||
ElMessage.success(`删除成功！`);
|
||
} catch (error) {
|
||
ElMessage.error('数据删除失败: ' + (error.message || '服务异常'));
|
||
} finally {
|
||
loading.value = false;
|
||
}
|
||
};
|
||
const exportExcel = () => {
|
||
if (!tableData.value || tableData.value.length === 0) {
|
||
ElMessage.warning('当前列表没有可导出的数据')
|
||
return
|
||
}
|
||
|
||
// Excel 表头（和页面一致）
|
||
const header = [
|
||
'序号',
|
||
'包号',
|
||
'报价产品',
|
||
'技术规范ID',
|
||
'计量单位',
|
||
'数量',
|
||
'型号',
|
||
'电压等级',
|
||
'标准',
|
||
'规格',
|
||
'等效'
|
||
]
|
||
|
||
// 数据行（严格对应 tableData 字段）
|
||
const rows = tableData.value.map((row, idx) => [
|
||
idx + 1, // 序号（按页面顺序）
|
||
row.packageNumber ?? '',
|
||
row.product ?? '',
|
||
row.techSpecId ?? '',
|
||
row.unit ?? '',
|
||
row.quantity ?? '',
|
||
row.model ?? '',
|
||
row.voltage ?? '',
|
||
row.standard ?? '',
|
||
row.spec ?? '',
|
||
row.dx ?? ''
|
||
])
|
||
|
||
const ws = XLSX.utils.aoa_to_sheet([header, ...rows])
|
||
|
||
// 列宽
|
||
ws['!cols'] = [
|
||
{ wch: 6 }, // 序号
|
||
{ wch: 10 }, // 包号
|
||
{ wch: 20 }, // 报价产品
|
||
{ wch: 18 }, // 技术规范ID
|
||
{ wch: 10 }, // 计量单位
|
||
{ wch: 10 }, // 数量
|
||
{ wch: 14 }, // 型号
|
||
{ wch: 14 }, // 电压等级
|
||
{ wch: 14 }, // 标准
|
||
{ wch: 14 }, // 规格
|
||
{ wch: 10 } // 等效
|
||
]
|
||
|
||
const wb = XLSX.utils.book_new()
|
||
XLSX.utils.book_append_sheet(wb, ws, '报价产品明细')
|
||
|
||
XLSX.writeFile(
|
||
wb,
|
||
`报价产品明细_${new Date().toISOString().slice(0, 10)}.xlsx`
|
||
)
|
||
}
|
||
|
||
|
||
// 更新下拉选项
|
||
const updateFilterOptions = () => {
|
||
// 从表格数据中提取唯一的电压等级值
|
||
const voltageSet = new Set();
|
||
const standardSet = new Set();
|
||
|
||
tableData.value.forEach(item => {
|
||
if (item.voltage && item.voltage.trim()) {
|
||
voltageSet.add(item.voltage.trim());
|
||
}
|
||
if (item.standard && item.standard.trim()) {
|
||
standardSet.add(item.standard.trim());
|
||
}
|
||
});
|
||
|
||
// 转换为数组并排序，添加空选项
|
||
voltageOptions.value = [
|
||
{ value: '', label: '全部' },
|
||
{ value: '空', label: '空' }
|
||
].concat(Array.from(voltageSet).sort().map(value => ({
|
||
value: value,
|
||
label: value
|
||
})));
|
||
|
||
standardOptions.value = [
|
||
{ value: '', label: '全部' }
|
||
,
|
||
{ value: '空', label: '空' }
|
||
].concat(Array.from(standardSet).sort().map(value => ({
|
||
value: value,
|
||
label: value
|
||
})));
|
||
};
|
||
|
||
// 更新选中行状态
|
||
const updateSelectedRows = () => {
|
||
const selectedRows = tableData.value.filter(row => row.selected);
|
||
selectedRowsCount.value = selectedRows.length;
|
||
hasSelectedRows.value = selectedRowsCount.value > 0;
|
||
};
|
||
|
||
// 加载批量调整线缆标准选项
|
||
const loadBatchStandardOptions = async () => {
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'XLBZList',
|
||
false,
|
||
{},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"XLBZList_CallBack",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (result) {
|
||
batchUpdateOptions.value = result.map(item => ({
|
||
value: item.XLBZID,
|
||
label: item.XLBZMC
|
||
}));
|
||
}
|
||
} catch (error) {
|
||
console.error('加载线缆标准失败:', error);
|
||
ElMessage.error('加载线缆标准失败');
|
||
}
|
||
};
|
||
|
||
// 加载批量调整电压等级选项
|
||
const loadBatchVoltageOptions = async () => {
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetDYDJList',
|
||
false,
|
||
{},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetDYDJList_CallBack",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (result) {
|
||
batchUpdateOptions.value = result.map(item => ({
|
||
value: item,
|
||
label: item
|
||
}));
|
||
}
|
||
} catch (error) {
|
||
console.error('加载电压等级失败:', error);
|
||
ElMessage.error('加载电压等级失败');
|
||
}
|
||
};
|
||
|
||
// 加载标准编码名称映射
|
||
const loadStandardNameMap = async () => {
|
||
try {
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'XLBZList',
|
||
false,
|
||
{},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"LoadStandardNameMap_CallBack",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (result) {
|
||
const map = {};
|
||
result.forEach(item => {
|
||
map[item.XLBZID] = item.XLBZMC;
|
||
});
|
||
standardNameMap.value = map;
|
||
}
|
||
} catch (error) {
|
||
console.error('加载标准名称映射失败:', error);
|
||
}
|
||
};
|
||
|
||
// 显示批量调整对话框
|
||
const showBatchUpdateDialog = async (type) => {
|
||
batchUpdateType.value = type;
|
||
batchUpdateValue.value = '';
|
||
batchUpdateOptions.value = [];
|
||
batchUpdateFilterQuery.value = '';
|
||
updateSelectedRows();
|
||
|
||
if (type === 'standard') {
|
||
batchUpdateTitle.value = '批量调整线缆标准';
|
||
await loadBatchStandardOptions();
|
||
} else if (type === 'voltage') {
|
||
batchUpdateTitle.value = '批量调整电压等级';
|
||
await loadBatchVoltageOptions();
|
||
} else if (type === 'model') {
|
||
batchUpdateTitle.value = '批量调整线缆型号';
|
||
} else if (type === 'spec') {
|
||
batchUpdateTitle.value = '批量调整线缆规格';
|
||
}
|
||
|
||
batchUpdateDialogVisible.value = true;
|
||
};
|
||
|
||
// 关闭批量调整对话框
|
||
const closeBatchUpdateDialog = () => {
|
||
batchUpdateDialogVisible.value = false;
|
||
batchUpdateValue.value = '';
|
||
batchUpdateFilterQuery.value = '';
|
||
};
|
||
|
||
const buildBatchUpdateItem = (row) => ({
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: BJDID,
|
||
XLJXMXH: (row.index != null ? row.index : '').toString()
|
||
});
|
||
|
||
// 确认批量调整
|
||
const confirmBatchUpdate = async () => {
|
||
if (!batchUpdateValue.value.trim()) {
|
||
ElMessage.warning(batchUpdateUseSelect.value ? '请选择调整值' : '请输入调整值');
|
||
return;
|
||
}
|
||
|
||
const selectedRows = tableData.value.filter(row => row.selected);
|
||
if (selectedRows.length === 0) {
|
||
ElMessage.warning('请先选择要调整的记录');
|
||
return;
|
||
}
|
||
|
||
let updateValue = '';
|
||
if (batchUpdateUseSelect.value) {
|
||
updateValue = resolveBatchUpdateSelectValue();
|
||
if (!updateValue) {
|
||
ElMessage.warning(
|
||
batchUpdateType.value === 'standard'
|
||
? '请从下拉列表中选择有效的线缆标准'
|
||
: '请从下拉列表中选择有效的电压等级'
|
||
);
|
||
return;
|
||
}
|
||
} else {
|
||
updateValue = batchUpdateType.value === 'spec'
|
||
? normalizeBatchSpec(batchUpdateValue.value.trim())
|
||
: batchUpdateValue.value.trim();
|
||
}
|
||
|
||
try {
|
||
startCenterProgress('正在批量调整数据...');
|
||
const items = selectedRows.map(row => buildBatchUpdateItem(row));
|
||
|
||
// 调用后端批量更新服务
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'BatchUpdateXLJXMX',
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007,
|
||
items: items,
|
||
updateType: batchUpdateType.value,
|
||
updateValue: updateValue
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"BatchUpdateXLJXMX",
|
||
50000
|
||
);
|
||
});
|
||
|
||
if (result && result.success) {
|
||
tableData.value = tableData.value.map(row => {
|
||
if (!row.selected) {
|
||
return row;
|
||
}
|
||
if (batchUpdateType.value === 'standard') {
|
||
return { ...row, standard: updateValue };
|
||
}
|
||
if (batchUpdateType.value === 'voltage') {
|
||
return { ...row, voltage: updateValue };
|
||
}
|
||
if (batchUpdateType.value === 'model') {
|
||
return { ...row, model: updateValue, XLXHID: updateValue };
|
||
}
|
||
if (batchUpdateType.value === 'spec') {
|
||
return { ...row, spec: updateValue, XLGGID: updateValue };
|
||
}
|
||
return row;
|
||
});
|
||
|
||
closeBatchUpdateDialog();
|
||
completeCenterProgress(true, '批量调整成功！');
|
||
ElMessage.success(result.msg || `已成功调整 ${selectedRows.length} 条记录`);
|
||
await loadTableData({ silent: true });
|
||
updateSelectedRows();
|
||
} else {
|
||
completeCenterProgress(false, result?.msg || '批量调整失败');
|
||
ElMessage.error(result?.msg || '批量调整失败');
|
||
}
|
||
} catch (error) {
|
||
completeCenterProgress(false, '批量调整失败');
|
||
ElMessage.error('批量调整失败: ' + (error.message || '服务异常'));
|
||
}
|
||
};
|
||
|
||
|
||
|
||
const InsertBJDMX = async () => {
|
||
try {
|
||
if (!tableData.value || tableData.value.length === 0) {
|
||
ElMessage.warning('没有可导入的数据');
|
||
return;
|
||
}
|
||
if (!filterRule.value || filterRule.value=== '0') {
|
||
ElMessage.warning('当前数据未解析，请先解析数据');
|
||
return;
|
||
}
|
||
startCenterProgress('正在导入数据...');
|
||
|
||
if (!BJDID) return; // 用户取消输入
|
||
|
||
// 转换数据
|
||
const items = tableData.value.map((row, index) => ({
|
||
XLJXDJ: "XSBJ",
|
||
XLJXDH: BJDID,
|
||
XLJXMXH: row.index.toString(),
|
||
XLBSC: row.product,
|
||
XLJXGZXH: "0",
|
||
JXXLXHID: row.model,
|
||
XLXHID: "",
|
||
JXXLGGID: row.spec,
|
||
XLGGID: "",
|
||
JXDYDJID: row.voltage,
|
||
DYDJID: "",
|
||
XLBZID: row.standard,
|
||
JXXLBZID: row.standard,
|
||
XLYSID: "",
|
||
JXXLYSID: "",
|
||
WHR: "",
|
||
WHRID: "",
|
||
WHSJ: new Date().toISOString(),
|
||
DCZT: row.status,
|
||
JLDW: row.unit || "",
|
||
SL: row.quantity || "",
|
||
FBH: row.packageNumber || "",
|
||
JSGFID: row.techSpecId || ""
|
||
}));
|
||
|
||
// 设置服务路径（确保正确）
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
isLoading.value = true;
|
||
// 调用服务（使用正确的服务方法名）
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'InsertBJDMX', // 确保这是正确的服务方法名
|
||
false,
|
||
{
|
||
'-RefUmId': 102851007, // 根据实际服务调整
|
||
'items': items,
|
||
'sBJDID': BJDID
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"InsertBJDMX",
|
||
300000
|
||
);
|
||
});
|
||
|
||
if (result && result.success) {
|
||
ElMessage.success(result.msg || `成功导入${items.length}条报价单明细`);
|
||
completeCenterProgress(true, result.msg || '数据导入完成!');
|
||
setTimeout(() => {
|
||
closePage();
|
||
}, 1000); // 延时 2000 毫秒（2 秒）
|
||
|
||
} else {
|
||
const errorMsg = result?.msg || result?.message || '服务返回未知错误';
|
||
ElMessage.error(`导入失败: ${errorMsg}`);
|
||
completeCenterProgress(false, '导入失败');
|
||
}
|
||
isLoading.value = false;
|
||
} catch (error) {
|
||
// 处理用户取消输入的情况
|
||
if (error.toString().includes('cancel')) {
|
||
return;
|
||
}
|
||
isLoading.value = false;
|
||
console.error('导入报价单明细失败:', error);
|
||
const errorMsg = error.message || '服务异常';
|
||
completeCenterProgress(false, '导入失败');
|
||
ElMessage.error(`导入失败: ${errorMsg}`);
|
||
}
|
||
};
|
||
|
||
const loadRuleOptions = async () => {
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 调用服务获取解析规则列表
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetXLJXGZList',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'XLJXDJ': 'XSBJ', // 固定值
|
||
'XLJXDH': BJDID // 可为空
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetXLJXGZList",
|
||
50000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
if (result && Array.isArray(result)) {
|
||
// 去重处理：基于XLJXGZXH
|
||
const uniqueRules = [];
|
||
const seen = new Set();
|
||
uniqueRules.push({
|
||
value: '0',
|
||
label: '未解析'
|
||
});
|
||
uniqueRules.push({
|
||
value: '-1',
|
||
label: '已解析'
|
||
});
|
||
uniqueRules.push({
|
||
value: '-2',
|
||
label: '全部'
|
||
});
|
||
result.forEach(rule => {
|
||
if (!seen.has(rule.XLJXGZXH)) {
|
||
seen.add(rule.XLJXGZXH);
|
||
uniqueRules.push({
|
||
value: rule.XLJXGZXH,
|
||
label: rule.XLJXGZC
|
||
});
|
||
}
|
||
});
|
||
|
||
ruleOptions.value = uniqueRules;
|
||
ElMessage.success(`加载${uniqueRules.length}条解析规则`);
|
||
} else {
|
||
ruleOptions.value = [];
|
||
ElMessage.warning('未获取到解析规则');
|
||
}
|
||
} catch (error) {
|
||
console.error('加载解析规则失败:', error);
|
||
ElMessage.error(`加载解析规则失败: ${error.message || '服务异常'}`);
|
||
ruleOptions.value = [];
|
||
}
|
||
};
|
||
|
||
// 加载通用解析规则选项
|
||
const loadCommonRuleOptions = async () => {
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 调用服务获取通用解析规则列表
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetXLJXGZList',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'XLJXDJ': 'XSBJ',
|
||
'XLJXDH':' ' // 固定值
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetXLJXGZList",
|
||
50000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
if (result && Array.isArray(result)) {
|
||
// 去重处理：基于XLJXGZXH
|
||
const uniqueRules = [];
|
||
const seen = new Set();
|
||
uniqueRules.push({
|
||
value: '0',
|
||
label: '请选择通用规则'
|
||
});
|
||
result.forEach(rule => {
|
||
if (!seen.has(rule.XLJXGZXH)) {
|
||
seen.add(rule.XLJXGZXH);
|
||
uniqueRules.push({
|
||
value: rule.XLJXGZXH,
|
||
label: rule.XLJXGZC
|
||
});
|
||
}
|
||
});
|
||
|
||
commonRuleOptions.value = uniqueRules;
|
||
ElMessage.success(`加载${uniqueRules.length}条通用解析规则`);
|
||
} else {
|
||
commonRuleOptions.value = [];
|
||
ElMessage.warning('未获取到通用解析规则');
|
||
}
|
||
} catch (error) {
|
||
console.error('加载通用解析规则失败:', error);
|
||
ElMessage.error(`加载通用解析规则失败: ${error.message || '服务异常'}`);
|
||
commonRuleOptions.value = [];
|
||
}
|
||
};
|
||
|
||
// 应用通用解析规则
|
||
|
||
const showXlxhDialog = () => {
|
||
// 构建带参数的 URL
|
||
|
||
const params = new URLSearchParams({
|
||
title: '线缆型号语法',
|
||
ruleString1 : ruleString.value,
|
||
reservedWords : "型号码,前缀码,后缀码",
|
||
connectors : ",-,/,(,)",
|
||
syntaxString : modelValue.value
|
||
});
|
||
|
||
// 设置 iframe 的 URL 并添加参数
|
||
iframeUrl.value = `${BJCPJXDR_XHYF.value}?${params.toString()}`;
|
||
|
||
YFGZDialogVisible.value = true;
|
||
resultReceived.value = false;
|
||
};
|
||
const showXLGGDialog = () => {
|
||
// 构建带参数的 URL
|
||
|
||
const params = new URLSearchParams({
|
||
title: '线缆规格语法',
|
||
ruleString1 : ruleString.value,
|
||
reservedWords : "截面,芯数,线对数,线组数",
|
||
connectors : "*,×,+,/,(,)",
|
||
syntaxString : specValue.value
|
||
});
|
||
|
||
// 设置 iframe 的 URL 并添加参数
|
||
iframeUrl.value = `${BJCPJXDR_XHYF.value}?${params.toString()}`;
|
||
|
||
YFGZDialogVisible.value = true;
|
||
resultReceived.value = false;
|
||
};
|
||
const showXlBZDialog = () => {
|
||
// 构建带参数的 URL
|
||
|
||
const params = new URLSearchParams({
|
||
title: '线缆标准语法',
|
||
ruleString1 : ruleString.value,
|
||
reservedWords : "标准名",
|
||
connectors : ",-,/,(,)",
|
||
syntaxString : standardValue.value
|
||
});
|
||
|
||
// 设置 iframe 的 URL 并添加参数
|
||
iframeUrl.value = `${BJCPJXDR_XHYF.value}?${params.toString()}`;
|
||
|
||
YFGZDialogVisible.value = true;
|
||
resultReceived.value = false;
|
||
};
|
||
|
||
const showDYDJDialog = () => {
|
||
// 构建带参数的 URL
|
||
|
||
const params = new URLSearchParams({
|
||
title: '电压等级语法',
|
||
ruleString1 : ruleString.value,
|
||
reservedWords : "相电压,线电压,电压单位",
|
||
connectors : "/,V,kV",
|
||
syntaxString : voltageValue.value
|
||
});
|
||
|
||
// 设置 iframe 的 URL 并添加参数
|
||
iframeUrl.value = `${BJCPJXDR_XHYF.value}?${params.toString()}`;
|
||
|
||
YFGZDialogVisible.value = true;
|
||
resultReceived.value = false;
|
||
};
|
||
|
||
const handleMessage = (event) => {
|
||
|
||
if (event.data && event.data.type === 'SAVE_SYNTAX_RESULT') {
|
||
// 从子页面接收结果
|
||
const result = event.data.payload;
|
||
|
||
const { type, Value, ActualValue } = result;
|
||
|
||
switch(type) {
|
||
case '线缆型号语法':
|
||
modelValue.value = Value;
|
||
modelActualValue.value = ActualValue;
|
||
break;
|
||
case '线缆规格语法':
|
||
specValue.value = Value;
|
||
specActualValue.value = ActualValue;
|
||
break;
|
||
case '电压等级语法':
|
||
voltageValue.value = Value;
|
||
voltageActualValue.value = ActualValue;
|
||
break;
|
||
case '线缆标准语法':
|
||
standardValue.value = Value;
|
||
standardActualValue.value = ActualValue;
|
||
break;
|
||
default:
|
||
console.warn(`未知语法类型: ${type}`);
|
||
return;
|
||
}
|
||
|
||
ElMessage.success(`${type}已更新`);
|
||
|
||
// 关闭对话框
|
||
YFGZDialogVisible.value = false;
|
||
resultReceived.value = true;
|
||
}
|
||
};
|
||
onMounted(() => {
|
||
window.addEventListener('message', handleMessage);
|
||
});
|
||
|
||
// 清理监听器
|
||
onUnmounted(() => {
|
||
window.removeEventListener('message', handleMessage);
|
||
});
|
||
// 显示规则配置对话框
|
||
const showRuleDialog = async () => {
|
||
if (!selectedProduct.value) {
|
||
ElMessage.warning('请先在表格中选择一条数据');
|
||
return;
|
||
}
|
||
GetFGF();
|
||
// 1. 创建请求参数
|
||
const requestItem = {
|
||
XLBSC: selectedProduct.value,
|
||
XLJXDJ:'XSBJ',
|
||
XLJXDH:BJDID,
|
||
XLJXGZXH:filterRule.value<=0?currentRowXLJXGZXH.value:filterRule.value,
|
||
XLXHID: currentRowModel.value, // 当前行型号值
|
||
DYDJID: currentRowVoltage.value, // 当前行电压值
|
||
XLBZID: currentRowStandard.value, // 当前行标准值
|
||
XLGGID: currentRowSpec.value // 当前行规格值
|
||
};
|
||
|
||
|
||
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 调用服务获取解析规则列表
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetJXPZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'item': requestItem
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetJXPZ",
|
||
50000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
if (result) {
|
||
ruleString.value = result.XLJXGZC;
|
||
modelValue.value = result.XLXHYFC;
|
||
modelActualValue.value = result.XLXH;
|
||
specValue.value = result.XLGGYFC;
|
||
specActualValue.value = result.XLGG;
|
||
voltageValue.value = result.DYDJYFC;
|
||
voltageActualValue.value = result.DYDJ;
|
||
standardValue.value = result.XLBZYFC;
|
||
standardActualValue.value = result.XLBZ;
|
||
ruleDialogVisible.value = true;
|
||
|
||
} else {
|
||
|
||
}
|
||
} catch (error) {
|
||
}
|
||
|
||
// 重置选择状态
|
||
nextTick(() => {
|
||
selection.value = { start: 0, end: 0, text: '' };
|
||
if (ruleEditor.value) {
|
||
ruleEditor.value.focus();
|
||
}
|
||
});
|
||
|
||
//parseRuleValue();
|
||
|
||
|
||
|
||
};
|
||
|
||
// 关闭规则配置对话框
|
||
const closeRuleDialog = () => {
|
||
ruleDialogVisible.value = false;
|
||
unmarkAll();
|
||
};
|
||
|
||
//todo
|
||
// todo
|
||
const showSyntaxDialog = () => {
|
||
|
||
syntaxDialogVisible.value = true;
|
||
|
||
};
|
||
|
||
// todo
|
||
const closeSyntaxDialog = () => {
|
||
|
||
syntaxDialogVisible.value = false;
|
||
|
||
};
|
||
|
||
// 保存规则配置
|
||
const saveRuleConfig = async (IsCommon) => {
|
||
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 生成唯一的规则代号（使用时间戳）
|
||
const XLJXDH = BJDID;
|
||
|
||
// 创建XLJXGZ对象
|
||
const ruleConfig = {
|
||
XLJXDJ: "XSBJ", // 固定值
|
||
XLJXDH: XLJXDH,
|
||
XLJXGZXH: filterRule.value<=0?currentRowXLJXGZXH.value:filterRule.value, // 默认序号
|
||
XLJXGZC: ruleString.value,
|
||
XLXHYFC: modelValue.value,
|
||
XLGGYFC: specValue.value,
|
||
DYDJYFC: voltageValue.value,
|
||
XLBZYFC: standardValue.value,
|
||
XLYSYFC: colorValue.value || "", // 颜色标记串（可选）
|
||
WHR: "",
|
||
WHRID: "", // 维护人ID（可选）
|
||
WHSJ: new Date().toISOString() // 当前时间
|
||
};
|
||
isLoading.value = true;
|
||
// 调用服务
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'InsertXLJXGZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'item': ruleConfig,
|
||
'IsCommon':IsCommon
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"InsertXLJXGZ",
|
||
50000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
if (result && result.success) {
|
||
ElMessage.success('解析规则已保存');
|
||
ruleDialogVisible.value = false;
|
||
loadRuleOptions();
|
||
filterRule.value=result.msg;
|
||
filterRule.label=ruleOptions.value[result.msg];
|
||
loadTableData();
|
||
unmarkAll();
|
||
|
||
} else {
|
||
ElMessage.error(`保存失败: ${result?.message || '未知错误'}`);
|
||
}
|
||
isLoading.value = false;
|
||
} catch (error) {
|
||
isLoading.value = false;
|
||
console.error('保存规则失败:', error);
|
||
ElMessage.error(`保存失败: ${error.message || '服务异常'}`);
|
||
}
|
||
};
|
||
|
||
const commonParse = async () => {
|
||
try {
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 生成唯一的规则代号（使用时间戳）
|
||
const XLJXDH = BJDID;
|
||
// 调用服务
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'commonParse',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005, // 替换为实际RefUmId
|
||
'BJDID': XLJXDH
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"commonParse",
|
||
500000 // 5秒超时
|
||
);
|
||
});
|
||
|
||
if (result && result.success) {
|
||
ElMessage.success('通用解析规则已执行');
|
||
loadRuleOptions();
|
||
filterRule.value=result.msg;
|
||
loadTableData();
|
||
|
||
|
||
} else {
|
||
ElMessage.error(`通用解析失败: ${result?.message || '未知错误'}`);
|
||
}
|
||
} catch (error) {
|
||
console.error('通用解析失败:', error);
|
||
ElMessage.error(`通用解析失败: ${error.message || '服务异常'}`);
|
||
}
|
||
};
|
||
|
||
// 解析数据
|
||
const parseData = () => {
|
||
if (tableData.value.length === 0) {
|
||
ElMessage.warning('请先粘贴数据');
|
||
return;
|
||
}
|
||
|
||
loading.value = true;
|
||
|
||
// 模拟解析过程
|
||
setTimeout(() => {
|
||
const parsedData = tableData.value.map(item => {
|
||
// 简单模拟解析逻辑
|
||
const parts = item.product.split('，');
|
||
|
||
return {
|
||
...item,
|
||
model: parts.length > 2 ? parts[2] : '',
|
||
voltage: parts.length > 1 ? parts[1] : '',
|
||
spec: parts.length > 3 ? parts[3] : '',
|
||
status: 'N'
|
||
};
|
||
});
|
||
|
||
tableData.value = parsedData;
|
||
loading.value = false;
|
||
ElMessage.success('解析完成');
|
||
}, 1000);
|
||
};
|
||
|
||
// 显示筛选对话框
|
||
const showFilterDialog = () => {
|
||
loadRuleOptions();
|
||
filterDialogVisible.value = true;
|
||
};
|
||
|
||
const showEXRuleDialog = () => {
|
||
loadRuleOptions();
|
||
EXRuleDialogVisible.value = true;
|
||
};
|
||
|
||
// 关闭筛选对话框
|
||
const closeFilterDialog = () => {
|
||
filterDialogVisible.value = false;
|
||
};
|
||
|
||
// 关闭筛选对话框
|
||
const closeEXRuleDialog = () => {
|
||
EXRuleDialogVisible.value = false;
|
||
};
|
||
|
||
// 应用筛选条件
|
||
const applyFilter = () => {
|
||
// 应用筛选条件后重新加载表格数据
|
||
loadTableData();
|
||
ElMessage.success('筛选条件已应用');
|
||
|
||
};
|
||
|
||
const applyRule = async () => {
|
||
try {
|
||
|
||
// 设置服务路径
|
||
GThinking.Web.AjaxServiceProxy.servicePath = 'S_XLXSBJ/102373012.ashx';
|
||
|
||
// 1. 获取规则数据
|
||
const item = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'GetXLJXGZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005,
|
||
'XLJXDJ': 'XSBJ',
|
||
'XLJXDH': BJDID,
|
||
'XLJXGZXH': ExRule.value
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"GetXLJXGZ",
|
||
50000
|
||
);
|
||
});
|
||
|
||
// 2. 更新规则属性
|
||
item.XLJXGZXH = filterRule.value;
|
||
|
||
// 3. 更新规则
|
||
const result = await new Promise((resolve, reject) => {
|
||
GThinking.Web.AjaxServiceProxy.invoke(
|
||
'InsertXLJXGZ',
|
||
false,
|
||
{
|
||
'-RefUmId': 102855005,
|
||
'item': item,
|
||
'IsCommon':'N'
|
||
},
|
||
(data) => resolve(data),
|
||
(error) => reject(error),
|
||
"InsertXLJXGZ",
|
||
50000
|
||
);
|
||
});
|
||
|
||
// 4. 处理结果
|
||
if (result && result.success) {
|
||
ElMessage.success('解析规则已保存');
|
||
ruleDialogVisible.value = false;
|
||
ExRule.value = '0';
|
||
filterRule.value = result.msg || filterRule.value;
|
||
|
||
// 5. 刷新表格数据
|
||
await loadTableData();
|
||
unmarkAll();
|
||
} else {
|
||
const errorMsg = result?.message || '未知错误';
|
||
ElMessage.error(`保存失败: ${errorMsg}`);
|
||
}
|
||
} catch (error) {
|
||
console.error('保存规则失败:', error);
|
||
const errorMsg = error.message || '服务异常';
|
||
ElMessage.error(`保存失败: ${errorMsg}`);
|
||
} finally {
|
||
// 6. 确保关闭对话框并刷新数据
|
||
EXRuleDialogVisible.value = false;
|
||
}
|
||
};
|
||
|
||
// ===== el-table-v2 相关方法 =====
|
||
|
||
// 处理行点击
|
||
// const handleRowClick = (params) => {
|
||
// const { rowData, rowIndex } = params;
|
||
|
||
// // 使用 map 创建新数组确保响应性
|
||
// tableData.value = tableData.value.map((row, idx) => ({
|
||
// ...row,
|
||
// current: idx === rowIndex
|
||
// }));
|
||
|
||
// // 设置选中的产品
|
||
// selectedProduct.value = rowData.product;
|
||
// currentRowModel.value = rowData.model || '';
|
||
// currentRowVoltage.value = rowData.voltage || '';
|
||
// currentRowStandard.value = rowData.standard || '';
|
||
// currentRowSpec.value = rowData.spec || '';
|
||
// };
|
||
|
||
const handleTableClick = (e) => {
|
||
const rowElement = e.target.closest('.el-table-v2__row');
|
||
if (!rowElement) return;
|
||
|
||
const rowIndex = Array.from(rowElement.parentNode.children).indexOf(rowElement);
|
||
const rowData = tableData.value[rowIndex];
|
||
|
||
if (rowData) {
|
||
// 清除所有行的选中状态
|
||
tableData.value = tableData.value.map(row => ({
|
||
...row,
|
||
current: false
|
||
}));
|
||
|
||
// 设置当前行选中
|
||
tableData.value[rowIndex] = {
|
||
...tableData.value[rowIndex],
|
||
current: true
|
||
};
|
||
|
||
// 设置选中的产品
|
||
selectedProduct.value = rowData.product;
|
||
currentRowModel.value = rowData.model || '';
|
||
currentRowVoltage.value = rowData.voltage || '';
|
||
currentRowStandard.value = rowData.standard || '';
|
||
currentRowSpec.value = rowData.spec || '';
|
||
currentRowXLJXGZXH.value = rowData.XLJXGZXH || '0';
|
||
}
|
||
};
|
||
|
||
|
||
const getRowClass = ({ rowData }) => {
|
||
return rowData.current ? 'current-row' : '';
|
||
};
|
||
|
||
// 处理窗口大小变化
|
||
const handleResize = () => {
|
||
tableWidth.value = window.innerWidth - 30;
|
||
tableHeight.value = window.innerHeight - 150;
|
||
};
|
||
const handleRowClick = (row)=>{
|
||
//console.log('选中的行ID:', row.id)
|
||
//根据选中行id获取rowdata
|
||
// 获取rowIndex
|
||
const rowIndex = row.rowIndex;
|
||
const rowData = tableData.value[rowIndex];
|
||
if (rowData) {
|
||
// 清除所有行的选中状态
|
||
tableData.value = tableData.value.map(row => ({
|
||
...row,
|
||
current: false
|
||
}));
|
||
|
||
// 设置当前行选中
|
||
tableData.value[rowIndex] = {
|
||
...tableData.value[rowIndex],
|
||
current: true
|
||
};
|
||
|
||
// 设置选中的产品
|
||
selectedProduct.value = rowData.product;
|
||
currentRowModel.value = rowData.model || '';
|
||
currentRowVoltage.value = rowData.voltage || '';
|
||
currentRowStandard.value = rowData.standard || '';
|
||
currentRowSpec.value = rowData.spec || '';
|
||
currentRowXLJXGZXH.value = rowData.XLJXGZXH || '0';
|
||
|
||
}
|
||
|
||
}
|
||
// 监听规则串变化
|
||
watch(ruleString, () => {
|
||
parseModelValue });
|
||
|
||
// 监听窗口大小变化
|
||
window.addEventListener('resize', handleResize);
|
||
|
||
// 页面加载时自动加载数据
|
||
onMounted(() => {
|
||
loadTableData();
|
||
loadStandardNameMap();
|
||
handleResize();
|
||
const tableElement = document.querySelector('.el-table-v2');
|
||
if (tableElement) {
|
||
//tableElement.addEventListener('click', handleTableClick);
|
||
}
|
||
});
|
||
const handleEnterKey = (e) => {
|
||
// 检查是否在查询条件输入框中
|
||
const isInQueryInput = e.target.matches('input[placeholder*="报价产品"], input[placeholder*="线缆型号"], input[placeholder*="线缆规格"], input[placeholder*="电压等级"], input[placeholder*="线缆标准"]');
|
||
|
||
if (isInQueryInput && e.key === 'Enter') {
|
||
e.preventDefault(); // 阻止默认行为
|
||
loadTableData(); // 执行查询
|
||
}
|
||
};
|
||
|
||
onMounted(() => {
|
||
// 添加全局键盘事件监听
|
||
document.addEventListener('keydown', handleEnterKey);
|
||
window.addEventListener('message', handleMessage);
|
||
});
|
||
|
||
onUnmounted(() => {
|
||
// 清理事件监听
|
||
document.removeEventListener('keydown', handleEnterKey);
|
||
window.removeEventListener('message', handleMessage);
|
||
stopColumnResize();
|
||
if (resizeGuideEl && resizeGuideEl.parentNode) {
|
||
resizeGuideEl.parentNode.removeChild(resizeGuideEl);
|
||
resizeGuideEl = null;
|
||
}
|
||
});
|
||
|
||
// 返回所有变量和方法
|
||
return {
|
||
// 状态变量
|
||
|
||
loading,
|
||
ruleDialogVisible,
|
||
EXRuleDialogVisible,
|
||
filterDialogVisible,
|
||
tableData,
|
||
// 批量调整相关变量
|
||
batchUpdateDialogVisible,
|
||
batchUpdateType,
|
||
batchUpdateValue,
|
||
hasSelectedRows,
|
||
selectedRowsCount,
|
||
batchUpdateTitle,
|
||
selectedProduct,
|
||
ruleEditor,
|
||
ruleString,
|
||
modelValue,
|
||
specValue,
|
||
voltageValue,
|
||
standardValue,
|
||
colorValue,
|
||
filterRule,
|
||
filterStatus,
|
||
ruleOptions,
|
||
modelActualValue,
|
||
specActualValue,
|
||
voltageActualValue,
|
||
standardActualValue,
|
||
// Excel导入相关
|
||
importDialogVisible,
|
||
fileInput,
|
||
excelFile,
|
||
excelColumns,
|
||
previewData,
|
||
columnMapping,
|
||
tableColumns,
|
||
importing,
|
||
importProgress,
|
||
totalRows,
|
||
importedCount,
|
||
importStatus,
|
||
errorMessage,
|
||
successMessage,
|
||
canImport,
|
||
// el-table-v2相关
|
||
tableColumnsV2,
|
||
tableWidth,
|
||
tableHeight,
|
||
// 方法
|
||
pasteData,
|
||
showRuleDialog,
|
||
closeRuleDialog,
|
||
saveRuleConfig,
|
||
showFilterDialog,
|
||
showEXRuleDialog,
|
||
closeFilterDialog,
|
||
applyFilter,
|
||
applyRule,
|
||
markPrefixCode,
|
||
markModelCode,
|
||
markSuffixCode,
|
||
markVoltagePhase,
|
||
markVoltageLine,
|
||
markVoltageUnit,
|
||
markVoltageLevel,
|
||
markWireCount,
|
||
markSection,
|
||
markWireGroup,
|
||
markWirePair,
|
||
markSpec,
|
||
markStandardName,
|
||
saveSelection,
|
||
parseData,
|
||
handleResize,
|
||
handleRowClick,
|
||
unmarkAll,
|
||
openSyntaxPage,
|
||
// Excel导入方法
|
||
showImportDialog,
|
||
closeImportDialog,
|
||
triggerFileInput,
|
||
handleFileChange,
|
||
startImport,
|
||
resetImport,
|
||
formatFileSize,
|
||
// el-table-v2方法
|
||
getRowClass,
|
||
InsertBJDMX,
|
||
closePage,
|
||
statusOptions,
|
||
closeEXRuleDialog,
|
||
ExRule,
|
||
showXlxhDialog,
|
||
showXlBZDialog,
|
||
showDYDJDialog,
|
||
showXLGGDialog,
|
||
YFGZDialogVisible,
|
||
iframeUrl,
|
||
loadRuleOptions,
|
||
loadTableData,
|
||
getRowKey,
|
||
deleteData,
|
||
exportExcel,
|
||
isLoading,
|
||
showCenterProgress,
|
||
centerProgressPercentage,
|
||
centerProgressStatus,
|
||
centerProgressText,
|
||
filterEquivalent,
|
||
handleManualPasteCancel,
|
||
handleManualPasteConfirm,
|
||
handleMappingConfirm,
|
||
handleMappingBack,
|
||
manualPasteText,
|
||
manualPasteDialogVisible,
|
||
pasteStep,
|
||
detectedColumnCount,
|
||
detectedPreviewRows,
|
||
columnFieldMapping,
|
||
pasteFieldOptions,
|
||
visibleColumns,
|
||
productQuery,
|
||
modelQuery,
|
||
specQuery,
|
||
voltageQuery,
|
||
standardQuery,
|
||
missingElementQuery,
|
||
missingElementOptions,
|
||
deleteRule,
|
||
// 新增通用解析规则相关
|
||
commonRuleOptions,
|
||
loadCommonRuleOptions,
|
||
deleteCommonRule,
|
||
// 批量调整相关方法
|
||
updateSelectedRows,
|
||
showBatchUpdateDialog,
|
||
closeBatchUpdateDialog,
|
||
confirmBatchUpdate,
|
||
batchUpdateOptions,
|
||
batchUpdateFilteredOptions,
|
||
filterBatchUpdateOptions,
|
||
loadBatchStandardOptions,
|
||
loadBatchVoltageOptions,
|
||
voltageOptions,
|
||
standardOptions,
|
||
standardNameMap,
|
||
loadStandardNameMap
|
||
};
|
||
}
|
||
});
|
||
|
||
app.use(ElementPlus);
|
||
|
||
// 全局注册所有图标组件
|
||
for (const [key, component] of Object.entries(ElementPlusIconsVue)) {
|
||
app.component(key, component);
|
||
}
|
||
|
||
app.mount('#app');
|