conversion.js

import { selectActSuppliesHistorydataAcc } from "@/api/Actsupplies/cleaning_rule";
// import { Tangshan } from "@/conversion/TangshanMine";
import { Tangshan } from "@/conversion/TangshanMin";
import { Linxi } from "@/conversion/LinxiMine";
import { lvMine } from "@/conversion/lvMine";
import { fanMine } from "@/conversion/fanMine";
import { DongMine } from "@/conversion/DonghuantuoMine";
import { danMine } from "@/conversion/danhouMine";
import { hongMine } from "@/conversion/hongMine";
import { YunFei } from "@/conversion/YunFei";
import { MoneyMine } from "@/conversion/MoneyMine";
import { ZhongRun } from "@/conversion/ZhongRun";
import {
    getSuppliesTemplate,
    listSuppliesTemplate,
    roleList,
    materialListPZ,
    accountingcode,
    department,
    roleListid,
    code,
} from "@/api/ruoyi-myLuckyexcel/myluckyexcel";
import {
    addInsert,
    addInsertAccount1,
    addInsertAccount2,
    datahistoryContentCopy
} from "@/api/system/historydata";
/*import luckysheet from 'luckysheet'*/
import LuckyExcel from "luckyexcel";
//导入库export.js 这个文件是es6的，不能在普通的HTML文件直接引入js文件（虽然都是js文件，但是有区别，具体请百度es6与es5）！需要把es6转es5才可以直接引入使用！
/*import {materialList} from "@/api/ruoyi-myLuckyexcel/myluckyexcel";*/
import { exportExcel } from "../../public/exportExcel";
import { v4 as uuidv4 } from "uuid";
import { min } from "moment/moment";
import { setXRow, setXColumn } from '@/utils/tzc'

var fileName = "新建XLSX工作表"; //定义表名
var rule = [];
var tempId;
var roleId;
var uuid1;
var trueORfalse = false;
var modify = false;
export default {
    name: "Mymodule",
    data() {
        return {
            research: [],
            result: '',
            dialogTableVisible: false,
            //清洗规则名字
            selectname: "",
            //kuang
            mine: "",
            //传入后台清洗规则
            historyContent: [],
            num: 1,
            nums: 1,
            value: "",
            VoucherForm: "",
            miningValue: "",
            Cleaningrole: "",
            phone: "",
            classify: "",
            //选择的矿区
            select: "",
            //转换完成成本材料的所有数据
            middle: "",
            //未导入成本材料表模板所有数据
            jsondata: "",
            //编码数据
            codess: "",
            luckyrule: [],
            showMask: false,
            //选中的表的数据
            selected: "",
            uuid: "",
            //弹出页面的表名
            from_name: "",
            //单侯煤矿的成本表
            newArray: "",
            //宏丰的成本表
            newArrayhong: "",
            //往后台穿的导入表的东西
            ImportTables: {},
            //往后台传生成表的数据
            generate: {},
            cleaning: "",
            // 是否显示弹出层
            dialogVisible: false,
            selectedOption: "",
            selectedRule: "",
            luckysheetData: "",
            fileList: [],
            disableNextButton: true,
            depss: [],
            // 表单参数
            from: {},
            date: "",
            mining: "",
            duplicateData: [],
            froms: {
                hId: "",
                projectId: "",
                projectName: "",
                departmentName: "",
                number: "",
                nuitPrice: "",
                money: "",
                createBy: "",
                hDate: null,
            },
            synthesis: "",
            historyRole: [],
            dfrom: {},
            imp: {},
            ssd: {},
            // 查询参数
            queryParams: {
                status: 0,
            },
        };
    },
    created() {
        //刷新页面时进行的操作
        this.delect();
        this.getList();
    },
    mounted() {
        this.init();
        fileName = "新建XLSX工作表";
        // this.list()
    },
    methods: {

        delect() {
            this.mine = "";
            this.selectname = "";
        },
        //查询材料编码
        list(excelid) {
            getSuppliesTemplate(1248).then((response) => {
                const sysSupplies = response.rows;
                this.luckysheetData = sysSupplies[0].templateContent;
                let VoucherForm = JSON.parse(sysSupplies[0].templateContent);
                this.VoucherForm = JSON.stringify(VoucherForm);
            });
            getSuppliesTemplate(excelid).then((response) => {
                this.generate.historyName =
                    response.rows[0].templateName + "(生成文件)";
                const sysSupplies = response.rows;
                this.luckysheetData = sysSupplies[0].templateContent;
                //将接收到的json存到json_data中
                //const json_data = response.data;
                this.jsondata = JSON.parse(sysSupplies[0].templateContent);
            });

        },
        //手机号
        open(evt) {
            this.$prompt("请输入用友系统的用户名", "提示", {
                confirmButtonText: "确定",
                cancelButtonText: "取消",
                inputPattern: /^(?:\+?86)?1[3-9]\d{9}$/,
                inputErrorMessage: "手机号格式不正确",
            })
                .then(({ value }) => {
                    this.$message({
                        type: "success",
                        message: "你的用户名是: " + value,
                    });
                    this.phone = value;
                    this.zhuan(evt);
                })
                .catch(() => {
                    this.$message({
                        type: "info",
                        message: "取消输入",
                    });
                    this.showMask = false;
                });
        },
        /** 判断是否选择时间*/
        rulesdate() {
            this.handleminingChange(this.mining);
            code(this.mining).then((response) => {
                this.codess = response.data;
            });
            if (this.date == "" || this.date == null) {
                this.disableNextButton = true;
                this.$message.error("请选择时间日期！");
            } else if (this.cleaning == "") {
                this.disableNextButton = true;
                this.$message.error("请选择清洗规则！");
            } else if (!this.selectname.includes(this.mine)) {
                this.disableNextButton = true;
                this.$message.error("清洗规则和所属矿区必须一致！");
            }
        },
        handledateChange(value) {
            const date = new Date(value);
            // 获取年份和月份
            const year = date.getFullYear(); // 获取年份
            const month = (date.getMonth() + 1).toString().padStart(2, "0"); // 获取月份并补零处理

            // 将年份和月份拼接成 "YYYY-MM" 的格式
            const formattedDate = year + "-" + month;

            this.date = formattedDate;
            if (
                this.date == "" ||
                this.date == null ||
                this.date == undefined
            ) {
                this.disableNextButton = true;
            } else {
                this.disableNextButton = false;
            }
        },
        handleminingChange(value) {
            department(value).then((response) => {
                this.classify = response;
            });
            const selectedItem = this.miningValue;
            if (selectedItem) {
                this.mine = selectedItem.name;
            }
            this.select = value;
            if (
                this.date == "" ||
                this.date == null ||
                this.date == undefined
            ) {
                this.disableNextButton = true;
            } else {
                this.disableNextButton = false;
            }
        },
        /** 页面刷新时展示的数据*/
        getList() {
            listSuppliesTemplate(this.queryParams).then((response) => {
                response.rows.forEach((row) => {
                    if (row.templateName.includes("六矿")) {
                        row.disabled = true;
                    }
                });
                this.depss = response.rows;
            });
        },
        /** 下拉选和页面luckysheet绑定 */
        handleOptionChange(value, miningValue, mining, excelid) {
            this.list(excelid);
            this.miningValue = miningValue;
            this.mining = mining;
            this.date = "";
            this.ImportTables.templateId = value;
            this.generate.templateId = value;
            this.selectedRule = "";
            this.disableNextButton = this.selectedRule === "";
            //根据选中的下拉选项值获取相应的信息
            getSuppliesTemplate(this.selectedOption)
                .then((response) => {
                    //如果为六矿汇总表,导出时隐藏前两列
                    if (
                        this.selectedOption === 7 ||
                        this.selectedOption === 10
                    ) {
                        trueORfalse = true;
                    } else {
                        trueORfalse = false;
                    }
                    modify = false;
                    tempId = this.selectedOption;
                    uuid1 = this.uuid = uuidv4().substring(0, 8);
                    const sysSupplies = response.rows;
                    this.luckysheetData = sysSupplies[0].templateContent;
                    //将接收到的json存到json_data中
                    //const json_data = response.data;
                    var json_data = JSON.parse(sysSupplies[0].templateContent);
                    roleList(value).then((response) => {
                        this.luckyrule = response.rows;
                    });
                    let suffixArr = sysSupplies[0].templateName.split(".");
                    fileName = suffixArr[0];
                    //luckysheet.destroy()
                    luckysheet.create({
                        container: "luckysheet", // Luckysheet 的容器元素 ID
                        title: fileName, // Excel 文件名
                        data: json_data, // Excel 数据
                        showinfobar: false,
                        allowEdit: false, //是否显示顶部名称栏
                        lang: "zh",
                    });
                    this.value = fileName;
                })
                .catch(() => {
                    // 处理错误逻辑，这里是一个空的错误处理函数
                    this.$message.error("查询失败,发生未知错误!");
                });
        },
        open4() {
            this.$message.error("请仔细检查所导入表");
        },
        /** 规则下拉选 调佣后端的方法*/
        handleRuleChange(value) {
            const selectedItem = this.luckyrule.find(
                (item) => item.id === value
            );
            if (selectedItem) {
                this.selectname = selectedItem.roleName;
            }

            if (this.selectedOption === "") {
                this.selectedRule = "";
                this.$message.warning("选择规则前请先选择模板!");
                return; // 如果按钮被禁用，提前返回，避免执行下一步操作
            }

            this.disableNextButton = this.selectedRule === "";
            roleListid(this.selectedRule).then((response) => {
                roleId = this.selectedRule;
                rule = response.rows;
                //清洗规则
                this.cleaning = JSON.parse(response.rows[0].detailContent);
                this.ImportTables.convenRole = response.rows[0].detailContent;
            });
            if (tempId === 7 || tempId === 10) {
                getSuppliesTemplate(tempId)
                    .then((response) => {
                        uuid1 = this.uuid = uuidv4().substring(0, 8);
                        // 通过遍历this.luckyrule找到对应的iem.roleName
                        for (let i = 0; i < this.luckyrule.length; i++) {
                            if (this.luckyrule[i].id === this.selectedRule) {
                                let name = this.luckyrule[i].roleName;
                                fileName = name.slice(0, -2);
                                break;
                            }
                        }
                        modify = false;
                        const sysSupplies = response.rows;
                        this.luckysheetData = sysSupplies[0].templateContent;
                        let json_data = JSON.parse(
                            sysSupplies[0].templateContent
                        );
                        luckysheet.create({
                            container: "luckysheet", // Luckysheet 的容器元素 ID
                            title: fileName, // Excel 文件名
                            data: json_data, // Excel 数据
                            showinfobar: false, //是否显示顶部名称栏
                            lang: "zh",
                        });
                    })
                    .catch(() => {
                        // 处理错误逻辑，这里是一个空的错误处理函数
                        this.$message.error("查询失败,发生未知错误!");
                    });
            }
        },
        /** 重置按钮操作 */
        resetQuery() {
            //刷新下拉选框内容
            fileName = "新建XLSX工作表";
            this.selectedOption = "";
            this.disableNextButton = "";
            this.luckyrule = [];

            this.selectedRule = "";
            trueORfalse = false;
            modify = false;
            uuid1 = "";
            //刷新luckysheet表格
            this.init();
        },
        /** Luckyexcel文档 */
        init() {
            let options = {
                container: "luckysheet", //luckysheet为容器id
                title: "",
                lang: "zh",
                showinfobar: false,
                data: [
                    {
                        name: "sheet1", //工作表名称
                        color: "", //工作表颜色
                        index: 0, //工作表索引
                        status: 1, //激活状态
                        order: 0, //工作表的下标
                        hide: 0, //是否隐藏
                        row: 50, //行数
                        column: 20, //列数
                        defaultRowHeight: 19, //自定义行高
                        defaultColWidth: 73, //自定义列宽
                        celldata: [], //初始化使用的单元格数据
                        config: {
                            merge: {}, //合并单元格
                            rowlen: {}, //表格行高
                            columnlen: {}, //表格列宽
                            rowhidden: {}, //隐藏行
                            colhidden: {}, //隐藏列
                            borderInfo: {}, //边框
                            authority: {}, //工作表保护
                        },
                    },
                ],
            };
            luckysheet.create(options);
        },
        async handleFileChange(evt) {
            if (modify) {
                this.$confirm(
                    "再次导入将会清空表内数据,是否继续操作？",
                    "注意!!!",
                    {
                        confirmButtonText: "确定",
                        cancelButtonText: "取消",
                        type: "warning",
                    }
                )
                    .then(async () => {
                        // 确认继续后刷新页面返回模板
                        getSuppliesTemplate(this.selectedOption)
                            .then((response) => {
                                const sysSupplies = response.rows;
                                this.luckysheetData =
                                    sysSupplies[0].templateContent;
                                let json_data = JSON.parse(
                                    sysSupplies[0].templateContent
                                );
                                luckysheet.destroy();
                                luckysheet.create({
                                    container: "luckysheet", // Luckysheet 的容器元素 ID
                                    title: fileName, // Excel 文件名
                                    data: json_data, // Excel 数据
                                    allowEdit: false, //作用：是否允许前台编辑
                                    showinfobar: false, //是否显示顶部名称栏
                                    lang: "zh",
                                });
                                modify = false;
                                this.open(evt);
                            })
                            .then(async () => { })
                            .catch(() => { });
                    })
                    .catch(() => {
                        // 用户点击了取消按钮
                        this.$message({ type: "info", message: "操作已取消" });
                    });
            } else {
                this.open(evt);
                this.showMask = true;
                LuckyExcel(evt, (exportJson) => {
                    //获取导入表格所有数据exportJson
                    this.open(exportJson)
                        // this.summary(exportJson)
                        .then(async () => {
                            // this.submit(exportJson);
                        })
                        .catch((error) => {
                            this.$message({
                                message: error.message,
                                type: "error",
                            });
                        })
                        .finally(() => {
                            // 导入完成后关闭遮罩层
                            this.showMask = false;
                        });
                });
            }
        },
        //转换方法
        transformPromises() {

            // try {
            let result = this.result
            this.dialogTableVisible = false
            let cc = result;
            let resultJSON = JSON.stringify(result.sheets)
            this.ImportTables.historyName =
                result.info.name + "(导入表名)";
            let codess = this.codess;
            let CompositeTable = this.jsondata;
            let classify = {};
            this.classify.forEach((item) => {
                if (item.nameType) {
                    if (classify[item.nameType]) {
                        classify[item.nameType] += `, ${item.name}`;
                    } else {
                        classify[item.nameType] = item.name;
                    }
                }
            });


            let c = cc.sheets[0].celldata;
            let cjson = JSON.stringify(c);
            let config = cc.sheets[0].config;
            //表头所在行
            let headRow = this.cleaning[0].HeaderRow - 2;
            let headROWs = c.flat().filter(obj => obj.c && obj.r == headRow)
            //部门所在列及所有部门的数据
            let DepartmentColumns =
                this.cleaning[0].DepartmentColumn - 1;
            let Department = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c &&
                        obj.c === DepartmentColumns &&
                        obj.r > headRow
                );
            //编码所在列
            let codecolumn = this.cleaning[0].CodeColumn - 1;
            let code = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c === codecolumn && obj.r > headRow
                );
            //金额列
            let moneyColumn = this.cleaning[0].money - 1;
            let money = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c &&
                        obj.c === moneyColumn &&
                        obj.r > headRow
                );
            //数量
            let quantitys = this.cleaning[0].NumberColumn - 1;
            let quantity = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c && obj.c === quantitys && obj.r > headRow
                );
            //单价
            let Unitprices = this.cleaning[0].MoneyColumn - 1;
            let Unitprice = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c && obj.c === Unitprices && obj.r > headRow
                );
            //型号
            let models = this.cleaning[0].model - 1;
            let model = c
                .flat()
                .filter(
                    (obj) => obj.c && obj.c == models && obj.r > headRow
                );
            //类别名称
            let names = this.cleaning[0].sourceColoumn
                ? this.cleaning[0].sourceColoumn - 1
                : null;

            let name = names
                ? c
                    .flat()
                    .filter(
                        (obj) =>
                            obj.c &&
                            obj.c === names &&
                            obj.r > headRow
                    )
                : null;

            //材料名称所在列
            let materias = this.cleaning[0].NameColumn - 1;
            let materianame = c
                .flat()
                .filter(
                    (obj) =>
                        obj.c && obj.c === materias && obj.r > headRow
                );
            //单位
            let unit = this.cleaning[0].unit - 1;
            let units = c
                .flat()
                .filter(
                    (obj) => obj.c && obj.c === unit && obj.r > headRow
                );

            // 唐山矿转换方法
            //没任何规则
            let duplicateData = [];
            if (this.mining == "010101") {
                const duplicateDatas = Tangshan(
                    money,
                    c,
                    name,
                    CompositeTable,
                    headRow
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //林西
            if (this.mining == "011704") {
                const duplicateDatas = Linxi(
                    names,
                    Department,
                    money,
                    code,
                    duplicateData,
                    CompositeTable,
                    codess,
                    classify,
                    DepartmentColumns,
                    codecolumn
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //东欢坨
            if (this.mining == "010102") {
                const duplicateDatas = DongMine(
                    money,
                    code,
                    codess,
                    CompositeTable,
                    Department,
                    classify,
                    duplicateData
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //单侯
            if (this.mining == "011204") {
                const duplicateDatas = danMine(
                    CompositeTable,
                    c,
                    Department,
                    money,
                    code,
                    classify,
                    codess,
                    name,
                    headRow
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //吕矿
            if (this.mining == "011702") {
                const duplicateDatas = lvMine(
                    CompositeTable,
                    cjson,
                    codess,
                    code
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //范矿
            if (this.mining == "011701") {
                const duplicateDatas = fanMine(
                    money,
                    codess,
                    code,
                    CompositeTable,
                    name
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //宏丰
            if (this.mining == "011502") {
                const duplicateDatas = hongMine(
                    money,
                    Department,
                    code,
                    name,
                    codess,
                    CompositeTable
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //钱矿
            if (this.mining == "010105") {
                const duplicateDatas = MoneyMine(
                    money,
                    DepartmentColumns,
                    name,
                    materianame,
                    c,
                    CompositeTable,
                    headRow
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //云飞
            if (this.mining == '011504') {
                const duplicateDatas = YunFei(
                    money,
                    Department,
                    code,
                    name,
                    codess,
                    CompositeTable
                );
                duplicateData = duplicateDatas.duplicateData;
                CompositeTable = duplicateDatas.CompositeTable;
            }
            //中润
            if (this.mining == "011706") {
                const duplicateDatas = ZhongRun(
                    Department,
                    money,
                    materianame,
                    name,
                    CompositeTable,
                    quantity,
                    model,
                    Unitprice,
                    code,
                    units
                );
                CompositeTable = duplicateDatas.CompositeTable;
            }
            CompositeTable[0].calcChain = [];
            let as = CompositeTable[0].celldata.filter(
                (item) => item.v.f
            );
            as.forEach((item) => {
                let sum = {
                    index: "1",
                    r: item.r,
                    c: item.c,
                };
                CompositeTable[0].calcChain.push(sum);
            });
            // celldata => data 生成表格所需二维数组
            CompositeTable[0].data = luckysheet.transToData(
                CompositeTable[0]["celldata"]
            );
            this.ImportTables.historyContent = resultJSON;
            //往后台传科目编码相关的东西
            let matchedItems = CompositeTable[0]["celldata"].filter(
                (item) =>
                    item.v &&
                    ((typeof item.v.v === "string" &&
                        item.v.v.includes("其他材料")) ||
                        (typeof item.v.v === "string" &&
                        item.v.v.includes("生产材料")))
            )[0].r;
            let material = CompositeTable[0]["celldata"]
                .flat()
                .filter((obj) => obj.r && obj.r === matchedItems);
            console.log(material)
            duplicateData.forEach((obj) => {
                obj.v.material=''
                material.forEach((cell) => {
                    if (obj.c === cell.c) {
                        obj.v.material = cell.v.v;
                    }
                });
            });
            console.log(duplicateData,'2222222222')
            var cellList = [];
            var newHistoryContent = JSON.parse(
                this.ImportTables.historyContent
            );
            let maxC = headROWs.length - 1
            duplicateData.forEach((item) => {
                //新加字段内容拼接
                var newName = item.v.name + "-" + item.v.material;
                item.index.forEach((i) => {
                    var cell26 = {
                        r: i,
                        c: maxC + 1,
                        v: {
                            ct: {
                                fa: "General",
                                t: "n",
                            },
                            fs: 9,
                            ff: "宋体",
                            ht: 2,
                            vt: 0,
                            tb: 2,
                            v: newName,
                            m: newName,
                        },
                    };
                    cellList.push(cell26);
                });
            });

            newHistoryContent[0].celldata.push(...cellList);
            newHistoryContent[0].data = luckysheet.transToData(
                newHistoryContent[0]["celldata"]
            );
            if (!this.value.includes("凭证") || this.mining == "011706") {
                luckysheet.create({
                    container: "luckysheet", // Luckysheet 的容器元素 ID
                    title: fileName, // Excel 文件名
                    data: CompositeTable, // Excel 数据
                    showinfobar: false, //是否显示顶部名称栏
                    lang: "zh",
                });
                luckysheet.refreshFormula(); //渲染公式
                modify = true;
                this.showMask = false;
            }
            if (this.mining == '011706') {
                duplicateData = workbookCreateAfter(CompositeTable, this.mining)
            }
            this.ImportTables.historyContent = JSON.stringify(newHistoryContent)
            this.generate.historyContent =
                JSON.stringify(CompositeTable);
            this.middle = CompositeTable;
            this.duplicateData.push(...duplicateData);
            this.Vouchers(this.duplicateData);
            // } catch (error) {
            //     this.open4();
            //     this.showMask = false;
            // }
        },
        zhuan(file) {
            let cc = '';
            const transformPromise = new Promise((resolve, reject) => {
                LuckyExcel.transformExcelToLucky(file, (lucksheetfile) => {
                    resolve(lucksheetfile);
                });
            });
            transformPromise.then((result) => {
                this.result = result
                cc = result;
                let c = cc.sheets[0].celldata
                //表头所在行
                let headRow = this.cleaning[0].HeaderRow - 2
                //类别名称
                let names = this.cleaning[0].sourceColoumn ? this.cleaning[0].sourceColoumn - 1 : null;
                let name = names ? c.flat().filter(obj => obj.c && obj.c === names && obj.r > headRow) : null;

                this.transformPromises()
            });
        },
        //成本表往凭证但转
        Vouchers(duplicateData) {
            let sum = [
                {
                    code: "2241005",
                    material: "其他材料",
                    v: 0,
                },
                {
                    code: "1403002",
                    material: "火工品",
                    v: 0,
                },
            ];

            for (let i = 0; i < duplicateData.length; i++) {
                if (duplicateData[i].v.material === "火工品") {
                    sum[1].v += Number(duplicateData[i].v.v);
                } else {
                    sum[0].v += Number(duplicateData[i].v.v);
                }
            }

            sum.forEach((item) => {
                item.v = Number(item.v).toFixed(2);
            });
            sum = sum.filter((item) => item.v !== "0.00");
            const VoucherForm = JSON.parse(this.VoucherForm);
            const filteredData = VoucherForm[0].celldata.filter(
                (obj) => obj.r === 5
            );
            const needKeys = [
                "*手工码",
                "*会计主体",
                "*核算账簿",
                "*单据日期",
                "*凭证类型",
                "*制单人",
                "*分录摘要",
                "*币种",
                "本币汇率类型",
                "*本币汇率",
                "*业务日期",
                "凭证单摘要",
            ];

            // 根据需要的关键词获取对应的单元格
            const need = needKeys.map(
                (key) => filteredData.find((obj) => obj.v.v === key).c
            );
            const loan = filteredData.filter(
                (obj) => obj.v.v === "原币贷方金额"
            )[0].c;
            const loan1 = filteredData.filter(
                (obj) => obj.v.v === "本币贷方金额"
            )[0].c;
            const money = filteredData.filter(
                (obj) => obj.v.v === "原币借方金额"
            )[0].c;
            const money1 = filteredData.filter(
                (obj) => obj.v.v === "本币借方金额"
            )[0].c;
            // 根据特定条件筛选单元格
            const foundObjects = filteredData.filter(
                (obj) => obj.v.v === "物料基本分类"
            );
            let Classification;
            let oldClassification;
            if (foundObjects.length >= 2) {
                oldClassification = foundObjects[0].c;
                Classification = foundObjects[1].c;
            } else {
                // 处理找不到两个满足条件的对象的情况
            }

            // 遍历duplicateData数组，为每个对象添加mining属性并赋值为this.select
            duplicateData.forEach((obj) => {
                obj.mining = this.select;
            });

            // 生成标准模板
            const Fusion = {
                r: "",
                c: "",
                v: {
                    ct: {
                        fa: "@",
                        t: "s",
                    },
                    fs: 8,
                    ff: "微软雅黑",
                    tb: 2,
                    v: "",
                    qp: 1,
                    m: "",
                },
            };

            // 获取当前日期并格式化为 YYYY-MM-DD 的字符串
            const currentDate = new Date();
            const year = currentDate.getFullYear(); // 获取当前年份
            const month = (currentDate.getMonth() + 1)
                .toString()
                .padStart(2, "0"); // 获取当前月份，记得要加 1
            const day = currentDate.getDate(); // 获取当前日期
            const formattedDate = `${year}-${month}-${day}`;
            // 生成唯一标识符uuid
            function generateUniqueShortUuid() {
                return uuidv4().replace(/-/g, "").substring(0, 12);
            }
            const uuid = generateUniqueShortUuid();

            // 创建data1数组
            const data1 = [
                uuid,
                this.select,
                this.select,
                this.date,
                "转",
                this.phone,
                "转本月材料分配",
                "CNY",
                "E001",
                "1.00000000",
                formattedDate,
                uuid,
            ];
            const newData = duplicateData.map((obj) => {
                const [name, department] = obj.v.name.split("-");
                return {
                    r: obj.r,
                    c: obj.c,
                    //金额
                    money: obj.v.v,
                    name,
                    indexRow: obj.index,
                    indexcoloumn: obj.coloumn,
                    department,
                    material: obj.v.material,
                    mining: obj.mining,
                    //uuid
                    accountuuid: data1[0],
                    accountdate: this.date,
                };
            });
            this.ImportTables.exportUuid = data1[0];
            this.generate.exportUuid = data1[0];
            this.ImportTables.identifyingCode = 0;
            this.ImportTables.date = this.date;
            this.ImportTables.mining = this.select;
            this.ImportTables.tylkStatus = 3;
            this.generate.tylkStatus = 3;
            this.generate.identifyingCode = 1;
            this.generate.date = this.date;
            this.generate.mining = this.select;
            // , this.generate
            let list = [this.ImportTables];
            let filteredArr;
            accountingcode(newData).then((response) => {
                // 合并起来的每行的值转换成一行一个编码 知道哪行合并了起来
                filteredArr = response.rows.map((obj) =>
                    Object.entries(obj)
                        .filter(([key, value]) => value !== null)
                        .reduce(
                            (acc, [key, value]) => ({ ...acc, [key]: value }),
                            {}
                        )
                );
                if (sum.length == 1 ) {
                    filteredArr.pop();
                }
                this.ImportTables.historyRole = filteredArr.map((item) => {
                    let extractedItem = {};
                    if (item.accountingCode) {
                        extractedItem.accountingCode = item.accountingCode;
                    }
                    if (item.indexcoloumn) {
                        extractedItem.indexcoloumn = item.indexcoloumn;
                    }
                    if (Array.isArray(item.indexRow)) {
                        extractedItem.indexRow = item.indexRow.join(", ");
                    }
                    if (item.name) {
                        extractedItem.name = item.name;
                    }
                    return extractedItem;
                });
                let historyContent = [];
                for (let i = 0; i < this.ImportTables.historyRole.length; i++) {
                    // && this.ImportTables.historyRole[i].accountingCode
                    if (this.ImportTables.historyRole[i].indexRow) {
                        const indexRowArray =
                            this.ImportTables.historyRole[i].indexRow.split(
                                ", "
                            );
                        const indexcoloumn =
                            this.ImportTables.historyRole[i].indexcoloumn;
                        for (let j = 0; j < indexRowArray.length; j++) {
                            let historyRole = {
                                value: `${this.ImportTables.historyRole[i].accountingCode},${this.ImportTables.historyRole[i].name}`,
                                key: String(indexRowArray[j]),
                                coloumn: String(indexcoloumn),
                            };
                            historyContent.push(historyRole);
                        }
                    }
                }
                //     //范矿重复数据
                // 使用 filter 方法对 historyContent 数组进行过滤
                historyContent = historyContent.filter((itemA) => {
                    return !this.historyContent.some(
                        (itemB) =>
                            itemA.key === itemB.key &&
                            itemA.value === itemB.value
                    );
                });
                this.historyContent.push(...historyContent);
                this.ImportTables.historyRole = JSON.stringify(historyContent);
                for (let i = 0; i < sum.length; i++) {
                    for (let j = 0; j < filteredArr.length; j++) {
                        if (sum[i].code === filteredArr[j].accountingCode) {
                            sum[i].index = j;
                            break;
                        }
                    }
                }

                let isArray = [];
                for (let i = 0; i < filteredArr.length; i++) {
                    let newRow1 = {
                        r: 8 + i,
                        c: money,
                        v: {
                            ct: Fusion.v.ct,
                            bg: Fusion.v.bg,
                            fs: Fusion.v.fs,
                            ff: Fusion.v.ff,
                            ht: Fusion.v.ht,
                            vt: Fusion.v.vt,
                            tb: Fusion.v.tb,
                            v: duplicateData[i]?.v.v,
                            qp: Fusion.v.qp,
                            m: duplicateData[i]?.v.m,
                        },
                    };
                    let newRow2 = {
                        r: 8 + i,
                        c: money1,
                        v: {
                            ct: Fusion.v.ct,
                            bg: Fusion.v.bg,
                            fs: Fusion.v.fs,
                            ff: Fusion.v.ff,
                            ht: Fusion.v.ht,
                            vt: Fusion.v.vt,
                            tb: Fusion.v.tb,
                            v: duplicateData[i]?.v.v,
                            qp: Fusion.v.qp,
                            m: duplicateData[i]?.v.m,
                        },
                    };

                    for (let l = 0; l < need.length; l++) {
                        let needIndex = l % need.length;
                        let newRow3 = {
                            r: 8 + i,
                            c: need[l],
                            v: {
                                ct: Fusion.v.ct,
                                bg: Fusion.v.bg,
                                fs: Fusion.v.fs,
                                ff: Fusion.v.ff,
                                ht: Fusion.v.ht,
                                vt: Fusion.v.vt,
                                tb: Fusion.v.tb,
                                v: data1[l],
                                qp: Fusion.v.qp,
                                m: Fusion.v.m,
                            },
                        };

                        isArray.push(newRow3);
                    }
                    isArray.push(newRow1, newRow2);
                }

                for (let i = 0; i < filteredArr.length; i++) {
                    const codeValue = filteredArr[i]?.accountingCode;
                    if (codeValue) {
                        const newRow = {
                            r: 8 + i,
                            c: 12,
                            v: {
                                ct: Fusion.v.ct,
                                bg: Fusion.v.bg,
                                fs: Fusion.v.fs,
                                ff: Fusion.v.ff,
                                ht: Fusion.v.ht,
                                vt: Fusion.v.vt,
                                tb: Fusion.v.tb,
                                v: codeValue,
                                qp: Fusion.v.qp,
                                m: Fusion.v.m,
                            },
                        };
                        isArray.push(newRow);
                    }
                }
                const result = [];
                filteredArr.forEach((obj, index) => {
                    Object.keys(obj).forEach((key) => {
                        if (
                            typeof obj[key] == "string" &&
                            obj[key] &&
                            obj[key].includes(",")
                        ) {
                            const [prop, val] = obj[key].split(",");
                            const propName = prop.trim().replace("*", ""); // 去除属性名中的星号(*)
                            result.push({ [propName]: val.trim(), row: index });
                        }
                    });
                });
                let cleanedData = result.filter((entry) => {
                    return Object.values(entry).every(
                        (value) => value !== "null" && value !== null
                    );
                });
                let name = [];
                for (let i = 0; i < cleanedData.length; i++) {
                    for (let key in cleanedData[i]) {
                        let columns = filteredData.filter(
                            (obj) => obj.v.v === key
                        )[0]?.c;
                        if (columns && columns !== oldClassification) {
                            name.push(columns);
                        }
                        if (columns === oldClassification) {
                            name.push(Classification);
                        }
                    }
                }
                cleanedData = cleanedData.filter(
                    (obj) => Object.keys(obj)[0] !== ""
                );
                for (let i = 0; i < name.length; i++) {
                    const newRow = {
                        r: 8 + cleanedData[i].row,
                        c: name[i],
                        v: {
                            ct: Fusion.v.ct,
                            bg: Fusion.v.bg,
                            fs: Fusion.v.fs,
                            ff: Fusion.v.ff,
                            ht: Fusion.v.ht,
                            vt: Fusion.v.vt,
                            tb: Fusion.v.tb,
                            v: Object.values(cleanedData[i])[0],
                            qp: Fusion.v.qp,
                            m: Object.values(cleanedData[i])[0],
                        },
                    };
                    isArray.push(newRow);
                }
                for (let i = 0; i < sum.length; i++) {
                    const newRow = {
                        r: 8 + sum[i].index,
                        c: loan,
                        v: {
                            ct: Fusion.v.ct,
                            bg: Fusion.v.bg,
                            fs: Fusion.v.fs,
                            ff: Fusion.v.ff,
                            ht: Fusion.v.ht,
                            vt: Fusion.v.vt,
                            tb: Fusion.v.tb,
                            v: sum[i].v,
                            qp: Fusion.v.qp,
                            m: sum[i].v,
                        },
                    };
                    const newRow1 = {
                        r: 8 + sum[i].index,
                        c: loan1,
                        v: {
                            ct: Fusion.v.ct,
                            bg: Fusion.v.bg,
                            fs: Fusion.v.fs,
                            ff: Fusion.v.ff,
                            ht: Fusion.v.ht,
                            vt: Fusion.v.vt,
                            tb: Fusion.v.tb,
                            v: sum[i].v,
                            qp: Fusion.v.qp,
                            m: sum[i].v,
                        },
                    };
                    isArray.push(newRow, newRow1);
                }


                VoucherForm[0].celldata.push(...isArray);

                if (this.value.includes("凭证")) {
                    luckysheet.create({
                        container: "luckysheet", // Luckysheet 的容器元素 ID
                        title: fileName, // Excel 文件名
                        allowEdit: false, //作用：是否允许前台编辑
                        data: VoucherForm, // Excel 数据
                        showinfobar: false, //是否显示顶部名称栏
                        lang: "zh",
                    });

                    modify = true;
                    this.showMask = false;
                }
                console.log(list,'11111111111')
                addInsert(list).then((response) => {
                    if (response.code == 200) {
                        this.$message({
                            message: "保存成功",
                            type: "success",
                        });
                    }
                });
                if (this.mining !== "011701") {

                    this.historyContent = [];
                    this.duplicateData = [];
                }
                VoucherForm[0].celldata = [];
            });
        },
        handleExport: debounce(function () {
            // handleExport
            let mineId = JSON.stringify(this.mining)

            datahistoryContentCopy({ mineId }).then(res => {
            })
            exportExcel(luckysheet.getAllSheets(), fileName);
        }, 500),
    },
};
// 配置项111

function getss(data) {
    let setXColumnObj = setXColumn(data, 2, '', 0, 9)
    let arrkses = Object.keys(setXColumnObj)
    let arr = []
    for (let rowIndex = 3; rowIndex < 34; rowIndex++) {
        let obj = {}
        arrkses.forEach(item => {
            let cell = data[rowIndex][setXColumnObj[item]];
            if (!item.includes('分配金额') && ['安全费用'] && ['内投工程材料'] && ['研发支出']) {
                // 去除
                if (!['分配金额', '安全费用', '内投工程材料', '研发支出'].find((key) => item.includes(key))) {
                    obj[item] = cell && cell.v || ''
                }
            }
        })

        if (!/^\d/.test(obj['费用列支'])) {
            arr.push(obj)
        }
    }
    return arr
}
function workbookCreateAfter(operate, mining) {
    let gets = getss(operate[0].data)
    let neearray = []
    gets.forEach(item => {
        let value = Object.values(item)
        // 找到括号内的内容
        let start = value[0].indexOf('(');
        let end = value[0].indexOf(')');
        let obj = ''
        let contentBeforeParentheses = ''
        if (start !== -1 && end !== -1) {
            let contentWithinParentheses = value[0].substring(start + 1, end);
            obj = contentWithinParentheses.split(',');
            obj = obj.map(newitem => newitem.trim());
        }
        let parenthesesIndex = value[0].indexOf('(');
        if (parenthesesIndex !== -1) {
            contentBeforeParentheses = value[0].substring(0, parenthesesIndex).trim();
        }
        let key = Object.keys(item)
        value.forEach((items, index) => {
            if (items && index != 0) {
                let funs = {
                    v: {
                        v: items,
                        name: key[index] + '-',
                        material: contentBeforeParentheses,
                    },
                    mining: mining,
                    r: ''
                }
                funs.v.material = funs.v.material.includes('净化车间') ? '净化车间' : funs.v.material
                if (index == 1) {
                    funs.r = obj[0]
                } else {
                    funs.r = obj[1] ? obj[1] : obj[0]
                }
                neearray.push(funs)
            }
        })
    })
    return neearray
}

// debounce函数定义

function debounce(func, delay) {
    let timer;
    return function () {
        const context = this;
        const args = arguments;
        clearTimeout(timer);
        timer = setTimeout(function () {
            func.apply(context, args);
        }, delay);
    };
}
function getKeyByValue(map, value) {
    for (let [key, val] of map) {
        if (val === value) {
            return key;
        }
        if (Array.isArray(val) && val.includes(value)) {
            return key;
        }
    }
}
function generateUUID() {
    let array = new Uint32Array(4);
    window.crypto.getRandomValues(array);
    return array.join("-");
}