mec-cloud_-intelligent-manufacturing_client/zkqy-ui/src/views/orderMange/financeApprove.vue

<template>
  <div class="app-container">
    <el-dialog
      :title="upload.title"
      :visible.sync="upload.open"
      width="400px"
      append-to-body
    >
      <el-upload
        ref="upload"
        :limit="1"
        accept=".xlsx, .xls"
        :headers="upload.headers"
        :action="
          upload.url +
          '?updateSupport=' +
          upload.updateSupport +
          '&tableName=' +
          tableName +
          '&sqlKey=' +
          tableKey
        "
        v-loading="upload.isUploading"
        :disabled="upload.isUploading"
        :on-progress="handleFileUploadProgress"
        :on-success="handleFileSuccess"
        :auto-upload="false"
        :onChange="handleChange"
        drag
      >
        <i class="el-icon-upload"></i>
        <div class="el-upload__text">将文件拖到此处，或<em>点击上传</em></div>
        <div class="el-upload__tip text-center" slot="tip">
          <!--          <div class="el-upload__tip" slot="tip">-->
          <!--            <el-checkbox v-model="upload.updateSupport"/>-->
          <!--            是否更新已经存在的用户数据-->
          <!--          </div>-->
          <span>仅允许导入xls、xlsx格式文件。</span>
          <el-link
            type="primary"
            :underline="false"
            style="font-size: 12px; vertical-align: baseline"
            @click="importTemplate"
            >下载模板
          </el-link>
        </div>
      </el-upload>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="submitFileForm">确 定</el-button>
        <el-button @click="upload.open = false">取 消</el-button>
      </div>
    </el-dialog>
    <Queryfrom
      :form-vals="templateInfo.where"
      :statisticList="statisticList"
      :showCount="showCount"
      :showSearch="showSearch"
      @getList="getList"
      ref="mychild"
    />
    <el-row :gutter="10" class="mb8">
      <el-col :span="1.5">
        <el-button
          type="primary"
          plain
          icon="el-icon-s-promotion"
          size="mini"
          :disabled="multiple"
          @click="myDeleteHandler"
          >审批
        </el-button>
      </el-col>

      <el-radio-group
        style="
          display: float;
          float: right;
          margin-right: 100px;
          margin-bottom: 10px;
        "
        v-model="queryParams.conditionMap.columnValue"
        size="mini"
        @change="approveTypeChange"
      >
        <el-radio-button label="8">未审批</el-radio-button>
        <el-radio-button label="3,4,5,6,7">已审批</el-radio-button>
        <el-radio-button label="7">已驳回</el-radio-button>
        <!-- <el-radio-button :label="2">生产</el-radio-button> -->
      </el-radio-group>
    </el-row>

    <el-table
      v-loading="loading"
      :data="tableList"
      @selection-change="handleSelectionChange"
      ref="tableRef"
      :cell-style="cellStyle"
      :reserve-selection="true"
      :row-key="getRowKey"
    >
      <el-table-column
        type="selection"
        width="55"
        reserve-selection
        align="center"
      >
      </el-table-column>
      <!-- <span v-for="(key, val) in columns" :key="key">
          <el-table-column :label="key" align="center" :prop="val" />
        </span> -->
      <el-table-column
        v-for="item in columns"
        :key="item.key"
        :label="item.value"
        align="center"
        :prop="item.key"
      >
        <template slot-scope="scope">
          <!-- 存在字段样式或字典样式 -->
          <template
            v-if="
              scope.row.styleFieldObj != undefined &&
              scope.row.styleFieldObj[item.key]
            "
          >
            <!-- 字段样式 -->
            <template v-if="scope.row.styleFieldObj[item.key].styleType == 1">
              <!-- 一般字体样式 -->
              <template
                v-if="scope.row.styleFieldObj[item.key].fieldStyleType == 0"
              >
                <span
                  :style="`color:${
                    scope.row.styleFieldObj[item.key].fontColor
                  }`"
                  >{{ scope.row[item.key] }}</span
                >
              </template>
              <!-- 标签字体样式 -->
              <template
                v-else-if="
                  scope.row.styleFieldObj[item.key].fieldStyleType == 1
                "
              >
                <el-tag
                  :type="scope.row.styleFieldObj[item.key].tagType"
                  :effect="
                    scope.row.styleFieldObj[item.key].isTagFullBg
                      ? 'dark'
                      : 'light'
                  "
                >
                  {{ scope.row[item.key] }}
                </el-tag>
              </template>
            </template>
            <!-- 字典样式 -->
            <template
              v-else-if="scope.row.styleFieldObj[item.key].styleType == 2"
            >
              <span
                v-if="
                  scope.row.styleFieldObj[item.key].listClass == '' ||
                  scope.row.styleFieldObj[item.key].listClass == 'default'
                "
                >{{ scope.row.styleFieldObj[item.key].dictLabel }}</span
              >
              <el-tag
                v-else
                :type="
                  scope.row.styleFieldObj[item.key].listClass == 'primary'
                    ? ''
                    : scope.row.styleFieldObj[item.key].listClass
                "
                >{{ scope.row.styleFieldObj[item.key].dictLabel }}</el-tag
              >
            </template>
          </template>
          <!-- 显示默认值 -->
          <template v-else>
            {{ scope.row[item.key] }}
          </template>
        </template>
      </el-table-column>
      <el-table-column
        label="操作"
        align="center"
        class-name="small-padding fixed-width"
      >
        <template slot-scope="scope">
          <!-- <el-button
              type="info"
              size="default"
              @click="handleEdit(scope.$index, scope.row)"
              >审批</el-button
            > -->
          <el-dropdown>
            <el-button type="warning" plain size="small">
              处理<i class="el-icon-arrow-down el-icon--right"></i>
            </el-button>
            <el-dropdown-menu slot="dropdown">
              <el-dropdown-item
                v-show="queryParams.conditionMap.columnValue == '8'"
              >
                <el-button
                  type="text"
                  size="mini"
                  @click="handleEdit(scope.$index, scope.row)"
                  >审批</el-button
                >
              </el-dropdown-item>
              <el-dropdown-item>
                <el-button
                  type="text"
                  size="mini"
                  @click="handleDetail(scope.$index, scope.row)"
                  >详情</el-button
                >
              </el-dropdown-item>
            </el-dropdown-menu>
          </el-dropdown>
          <Menu
            :row="scope.row"
            v-for="btnObj in excuteBtnArr"
            :key="btnObj.id"
            :listAll="btnObj"
            @excuteHandler="excuteHandler"
          ></Menu>
        </template>
      </el-table-column>
    </el-table>
    <pagination
      v-show="total > 0"
      :total="total"
      :page.sync="queryParams.pageNum"
      :limit.sync="queryParams.pageSize"
      @pagination="pageList"
    />
    <!-- 添加或修改销售出库单：- 过磅记录生成数据对话框 -->
    <el-dialog :title="title" :visible.sync="open" append-to-body>
      <el-row :gutter="20">
        <el-form
          :model="approveForm"
          ref="approveFormRef"
          :rules="approveRule"
          label-width="100px"
          :inline="false"
          size="normal"
        >
          <el-col :span="12">
            <el-form-item label="是否通过:" prop="status">
              <el-radio v-model="approveForm.status" label="3">通过</el-radio>
              <el-radio v-model="approveForm.status" label="7">不通过</el-radio>
            </el-form-item>
          </el-col>
        </el-form>
      </el-row>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="approveConfirm">确 定</el-button>
        <el-button @click="cancel">取 消</el-button>
      </div>
    </el-dialog>

    <!-- 绑定按钮dialog -->
    <el-dialog
      title="提示"
      :visible.sync="btnDialogVisible"
      :before-close="handleClose"
    >
      <DialogTemplate
        ref="dialogRef"
        :groupKey="groupKey"
        :rowobj="rowobj"
        :subCount="subCount"
        :tableCount="tableCount"
        :subTableName="subTableName"
        @addList="addListHandler"
      >
      </DialogTemplate>
      <span slot="footer" class="dialog-footer">
        <el-button @click="btnDialogVisible = false">取 消</el-button>
        <el-button type="primary" @click="btnComfirm">确 定</el-button>
      </span>
    </el-dialog>

    <!-- 自定义弹窗 -->
    <el-dialog
      title="提示"
      :visible.sync="btnDialogVisible"
      :before-close="handleClose"
    >
      <DialogTemplate
        ref="dialogRef"
        :groupKey="groupKey"
        :rowobj="rowobj"
        :subCount="subCount"
        :tableCount="tableCount"
        :subTableName="subTableName"
        @addList="addListHandler"
      >
      </DialogTemplate>
      <span slot="footer" class="dialog-footer">
        <el-button @click="btnDialogVisible = false">取 消</el-button>
        <el-button type="primary" @click="btnComfirm">确 定</el-button>
      </span>
    </el-dialog>
    <!-- 详情 -->
    <el-dialog title="详情" :visible.sync="detailShow" width="1300px">
      <div ref="detailTable" id="detail"></div>
      <span slot="footer" class="dialog-footer">
        <el-button @click="detailShow = false">取 消</el-button>
        <!-- <el-button type="primary" @click="detailPrintHandler">打 印</el-button> -->
      </span>
    </el-dialog>
  </div>
</template>
<script>
import {
  delTableData,
  dragTableInfo,
  listTable,
  unionListTableData,
  getInfoBySqlKey,
  btnCommonApi,
  addTableData,
  batchEdit,
  getStatisticList,
  // getTableList2,
  getTableList1,
  batchApproval,
} from "@/api/tablelist/commonTable";
import { listData } from "@/api/system/tenant/data";
import { getToken } from "@/utils/auth";
import Queryfrom from "@/views/tablelist/commonTable/queryfrom.vue";
import { camelCase, toUnderline } from "@/utils";
import { inputDisableComplete } from "@/utils/other";
import Menu from "@/views/tablelist/commonTable/BtnMenu.vue";
import { checkRole } from "@/utils/permission";
import DialogTemplate from "@/views/dialogTemplate/components/index.vue";
import { queryDropDownBoxData } from "@/api/dragform/form";
import { v4 as uuidv4 } from "uuid";
import { mapState } from "vuex";

export default {
  name: "listInfo",
  components: { Queryfrom, Menu, DialogTemplate },
  dicts: ["sales_order_type", "payment_method", "direction_of_twist"],
  data() {
    return {
      // 详情
      detailShow: false,
      // 审批相关数据
      approveType: "", //审批状态
      approveNo: "",
      approveForm: {
        status: "3",
        orderType: "",
        saleLeader: "", //业务主管
        finance: "", //财务部
        production: "", //生产部
        saleApprover: "", //批准人
      },
      approveRule: {
        orderType: [
          {
            required: true,
            message: "请选择订单类型",
            trigger: "change",
          },
        ],
      },
      // 新的自定义数据 start
      productIds: [], //货品Ids
      isEdit: false,
      formData: {
        //订单表数据
        saleNo: "", //合同号
        saleCustomNo: "", //客户编号
        saleDate: "", //销售单日期
        saleOrderEstimatedTime: "", //预计下单时间
        saleLeadTime: "", //交货周期
        deliveryDate: "",
        saleAmounts: "", //合计金额 小写
        saleAmountInWords: "", //合计金额 大写
        salePayType: "", //支付方式
        earnestMoney: "", //定金
        salesman: "", //业务员
        saleLeader: "", //业务主管
        finance: "", //财务部
        production: "", //生产部
        saleApprover: "", //批准人
        customAddress: "", //客户地址
        customCountryType: "", //国家类型
        contactPerson: "", //联系人
        // 货品明细表数据
        productNo: "", //货品号
        productName: "", //货品名称
        productNumber: "", //销售数量
        productWeight: "", //销售重量kg
        productUnitPrice: "", //单价
        productAmounts: "", //金额
        remark: "", //备注
        // 工艺表
        craftGrid: "", //网格
        craftOil: "", //油剂
        craftPackage: "", //卷装
        craftColorFastness: "", //色牢度
        directionOfTwist: "", //捻向
        craftOther: "", //其它工艺要求
        craftMark: "", //包装/贴唛
        shippingMethod: "", //运输方式
      },
      productionOptions: [],
      customerOptions: [],
      productionTableData: [
        // {
        //   productNo: "", //货品名称
        //   productNumber: 2, //销售数量
        //   productWeight: 1, //销售重量kg
        //   productUnitPrice: 20, //单价
        //   productAmounts: 20, //金额
        //   remark: "", //备注
        // },
      ],
      rules: {},

      // end
      // 绑定按钮dialog
      btnDialogVisible: false,
      // 绑定修改dialog
      groupKey: "",
      // 遮罩层
      loading: true,
      // 选中数组
      ids: [],
      // 非单个禁用
      single: true,
      // 非多个禁用
      multiple: true,
      // 显示统计
      showCount: true,
      // 显示搜索条件
      showSearch: true,
      // 总条数
      total: 0,
      // 用户表格数据
      tableList: [],
      // 弹出层标题
      title: "",
      // 日期范围
      dateRange: [],
      // 表单参数
      form: {},
      rules: {},
      // cru 弹窗
      open: false,
      // excel共通导入数据
      upload: {
        // 是否显示弹出层
        open: false,
        // 弹出层标题（
        title: "",
        // 是否禁用上传
        isUploading: false,
        // 是否更新已经存在的数据
        updateSupport: 0,
        // 设置上传的请求头部
        headers: { Authorization: "Bearer " + getToken() },
        // 上传的地址
        url: process.env.VUE_APP_BASE_API3 + "common/uploadData",
      },
      // 排序方式 默认降序
      sortOrder: true,
      // 共通查询参数接受子组件的参数
      queryParams: {
        pageNum: 1, // 第几页
        pageSize: 10, // 每页大小
        orderByColumn: "", // 根据某列排序
        isAsc: "", // desc（降序）或 asc（升序）
        // 基本查询参数
        basicMap: {
          tableName: "drag_form",
        },
        // 当前表字段筛选参数
        queryMap: {
          // 当前查询基本参数
          // ... key : value         当前页面的筛选条件
          // 超级查询的唯一值
          queryCriteriaValue: "",
        },
        conditionMap: {
          columnName: "status",
          columnValue: "8",
        },
      },
      // 列信息
      columns: {},
      // 当前模版信息
      templateInfo: {},
      // 查询条件
      queryFromWhere: {},
      // 当前table唯一标识
      tableKey: null,
      // 当前表名称
      tableName: null,
      //存放html代码块
      iframeUrl: "",
      //存放表单渲染数据
      jsonData: {},
      // 回显表格数据,
      defaultValue: {},
      // 统计card
      statisticList: [],
      // 样式表
      styleList: [],
      // 字典样式对象
      dictStyleObj: {},
      // 操作列 按钮数据
      excuteBtnArr: [],
      // 下拉框动态数据
      dynamicData: {},
      // 当前点击按钮的数据
      currentBtnData: {},
      // 修改选中行
      rowobj: {},
      // 该行的统计信息
      subCount: [],
      tableCount: [],
      // 弹窗新增数据
      addLists: [],
      subTableName: "",
      // 当前点击行的数据
      currentRow: {},
      // 订单类型list
      orderTypeOptions: [],

      colourNumberOptions: [], //色号选项
      sliceTypeOptions: [], //切片选项
    };
  },

  created() {
    // 得到当前展示的table的唯一标识
    this.tableKey = this.$route.query.tableKey;
    console.log(this.user);
  },
  watch: {
    open(newQuestion, oldQuestion) {
      if (newQuestion == false) {
        (this.ids = []), this.$refs.tableRef.clearSelection();
      }
    },
  },
  computed: {
    isShowExcuteCol() {
      return !this.excuteBtnArr?.every((arr) => arr.children.length == 0);
    },
    ...mapState({
      nickName: (state) => state.user.nickName,
      user: (state) => state.user,
    }),
  },
  methods: {
    // 查看详情回调
    async handleDetail(index, row) {
      this.printDomData = await this.getDetailTableString(row);
      this.detailShow = true;
      this.$nextTick(() => {
        this.$refs.detailTable.innerHTML = this.printDomData;
      });
    },
    // getDictLabel(value, dictLsit = []) {
    //   return dictLsit.find((item) => {
    //     return item.value == value;
    //   })?.label;
    // },
    getDictLabel(value, dict) {
      return (
        this.dict.type[dict].find((item) => {
          return item.value === value;
        })?.label || ""
      );
    },
    // 获取详情html字符串
    async getDetailTableString(row) {
      let { saleOrderSaleNo } = row;
      let payLoad = [
        {
          basicMap: {
            tableName: "sale_order",
          },
          conditionMap: {
            sale_no: [saleOrderSaleNo],
          },
        },
        {
          basicMap: {
            tableName: "sale_products",
          },
          conditionMap: {
            sale_order_no: [saleOrderSaleNo],
          },
        },
        {
          basicMap: {
            tableName: "sale_craft",
          },
          conditionMap: {
            sale_order_no: [saleOrderSaleNo],
          },
        },
      ];
      let res = await queryDropDownBoxData(payLoad);
      await this.getDropDownData();
      if (res.code == 200) {
        console.log(res);
        let { sale_craft, sale_order, sale_products } = res.data.resultMap;
        let {
          //订单表数据
          saleNo, //合同号
          lotNumber, //批号
          saleCustomNo, //客户编号
          saleDate, //销售单日期
          saleOrderEstimatedTime, //预计下单时间
          saleLeadTime, //交货周期
          deliveryDate,
          saleAmounts, //合计金额 小写
          saleAmountInWords, //合计金额 大写
          salePayType, //支付方式
          earnestMoney,
          salesman, //业务员
          saleLeader, //业务主管
          finance, //财务部
          production, //生产部
          saleApprover, //批准人
          // customAddress, //客户地址
          // customCountryType, //国家类型
          // contactPerson, //联系人
          // 货品明细表数据
          // productNo, //货品号
          // productName, //货品名称
          // productNumber: "", //销售数量
          // productWeight: "", //销售重量kg
          // productUnitPrice: "", //单价
          // productAmounts: "", //金额
          // remark: "", //备注
          // 工艺表
          craftGrid, //网络
          craftOil, //油剂
          craftPackage, //卷装
          craftColorFastness, //色牢度
          directionOfTwist,
          craftOther, //其它工艺要求
          craftMark, //包装/贴唛
          shippingMethod, //运输方式
        } = { ...sale_craft[0], ...sale_order[0] };
        let customData = this.customerOptions.find(
          (item) => item.customNo == saleCustomNo
        );
        let payType = this.getDictLabel(salePayType, "payment_method"); //付款方式
        let customerName = customData ? customData.customName : "";
        let customAddress = customData?.customAddress || "无";
        let customCountryType = customData?.customCountryType || "";
        let contactPerson = customData?.contactPerson || "无";
        let directionOfTwistDescription = directionOfTwist
          ? this.getDictLabel(directionOfTwist, "direction_of_twist")
          : "";
        let printStr = `
        <table style="width:1200px; border-collapse:collapse;" border="1" cellpadding="10" align="center">
            <div style="text-align:center;font-size: 20px;">诸暨市新丝维纤维有限公司</div>
            <div style="text-align:center;">销售合同审计单</div>
            <tbody>
                <tr>
                    <td width="600px" colspan="4">合同号：${saleNo}</td>
                    <td width="600px" colspan="4">日期：${saleDate.replace(
                      "T",
                      " "
                    )}</td>
                </tr>
                <tr align="center">
                    <td width="300px" colspan="2">客户名称：</td>
                    <td width="300px" colspan="2">${customerName}</td>
                    <td width="300px" colspan="2">联系人：</td>
                    <td width="150px" colspan="1">${contactPerson}</td>
                </tr>
                <tr align="center">
                    <td width="300px" colspan="2">客户地址：</td>
                    <td width="300px" colspan="2">${customAddress}</td>
                    <td width="300px" colspan="2">客户国别：</td>
                    <td width="300px" colspan="2">${customCountryType}</td>
                </tr>
                <tr align="center">
                    <td width="300px" colspan="2">预计下单时间：</td>
                    <td  colspan="1">${saleOrderEstimatedTime.replace(
                      "T",
                      " "
                    )}</td>
                    <td  colspan="1">交货周期：</td>
                    <td >${saleLeadTime}</td>
                    <td  colspan="2">交货日期：</td>
                    <td >${deliveryDate.replace("T", " ")}</td>
                </tr>
                <tr align="center">
                    <td colspan="8">货品明细</td>
                </tr>
                <tr align="center">
                    <td width="150px">品名</td>
                    <td width="150px">类型</td>
                    <td width="150px">数量/kg</td>
                    <td width="150px">单价</td>
                    <td width="150px">金额</td>
                    <td width="150px">切片型号</td>
                    <td width="150px">色号</td>
                    <td width="150px">备注</td>
                </tr>`;
        let amountTotal = 0,
          singlTotal = 0,
          moneyTotal = 0;
        for (let i = 0; i < sale_products.length; i++) {
          let item = sale_products[i];
          amountTotal += Number(item.productNumber);
          singlTotal += Number(item.productUnitPrice);
          moneyTotal += Number(item.productAmounts);
          let productData = this.productionOptions.find(
            (pro) => pro.productNo == item.productNo
          );
          console.log("item", item);
          item.sliceTypeLabel =
            this.sliceTypeOptions.find((k) => k.materielCode == item.sliceType)
              ?.materielName || "";
          item.colourNumberLabel = this.colourNumberOptions.find(
            (k) => k.materielCode == item.colourNumber
          )?.materieColorNumber;
          let productName = productData ? productData.productName : "";
          let productType = productData ? productData.productType : "";
          printStr += `<tr align="center">
                    <td>${productName}</td>
                    <td>${productType}</td>
                    <td>${item.productNumber}</td>
                    <td>${item.productUnitPrice}</td>
                    <td>${item.productAmounts}</td>
                    <td>${item.sliceTypeLabel}</td>
                    <td>${item.colourNumberLabel}</td>
                    <td>${item.remark}</td>
                </tr>`;
        }
        // 计算小计
        printStr += `
        <tr align="center">
          <td>小计：</td>
           <td></td>
          <td>${amountTotal}</td>
          <td>${singlTotal}</td>
          <td>${moneyTotal}</td>
          <td></td>
          <td></td>
          <td></td>
        </tr>
                <tr>
                    <td colspan="8">合计金额（大写）：${saleAmountInWords}</td>
                </tr>
                `;

        if (salePayType == "1") {
          //定金
          printStr += `
          <tr>
            <td colspan="4">付款方式：${payType}</td>
            <td colspan="4">定金：${earnestMoney}</td>
          </tr>`;
        } else {
          printStr += `
         <tr>
              <td colspan="8">付款方式：${payType}</td>
          </tr>`;
        }
        printStr += `<tr align="center">
                    <td colspan="8">工艺要求</td>
                </tr>
                <tr align="center">
                    <td width="150px">网络</td>
                    <td width="150px">油剂</td>
                    <td width="150px">卷装</td>
                    <td width="150px">色牢度</td>
                    <td width="150px">捻向</td>
                    <td width="150px">其他</td>
                    <td width="150px"></td>
                    <td width="150px"></td>
                </tr>
                <tr align="center">
                    <td >${craftGrid}</td>
                    <td>${craftOil}</td>
                    <td>${craftPackage}</td>
                    <td>${craftColorFastness}</td>
                    <td>${directionOfTwistDescription}</td>
                    <td>${craftOther}</td>
                    <td width="150px"></td>
                    <td width="150px"></td>
                </tr>
                <tr>
                    <td colspan="8">包装/贴唛：${craftMark}</td>
                </tr>
                <tr>
                    <td colspan="8">装运方式：${shippingMethod}</td>
                </tr>
                <tr align="center">
                    <td colspan="2">业务员：</td>
                    <td colspan="2">${salesman}</td>
                    <td colspan="2">财务部：</td>
                    <td colspan="2">${finance}</td>
                </tr>
                
                <tr align="center">
                    <td colspan="2">批准人：</td>
                    <td colspan="2">${saleApprover}</td>
                    <td></td>
                    <td></td>
                    <td></td>
                    <td></td>
                </tr>
            </tbody>
        </table>
        `;
        return printStr;
        //         <tr align="center">
        //             <td colspan="2"> 2</td>
        //             <td> </td>
        //             <td> </td>
        //             <td> </td>
        //             <td> </td>
        //         </tr>
        //         <tr>
        //             <td colspan="2">小计：</td>
        //             <td></td>
        //             <td></td>
        //             <td></td>
        //             <td></td>
        //         </tr>
      }
    },
    // 自定义删除按钮
    myDeleteHandler(row) {
      this.open = true;
    },
    // 审批状态改变回调
    approveTypeChange(status) {
      this.getList(false, status);
    },
    // 审批  开始回调
    approveHandler(index, row) {
      console.log(row);
    },
    // 审批 确认回调
    approveConfirm() {
      // console.log(this.ids);
      // return;
      // console.log(this.dict.type.sales_order_type);
      // console.log(this.approveForm,'approveForm');
      // return
      this.$refs["approveFormRef"].validate(async (valid) => {
        if (valid) {
          let payload = {
            idList: this.ids,
            status: this.approveForm.orderType == "1" ? "5" : "3",
            finance: this.nickName,
          };
          let res = await batchApproval(payload);
          if (res.code === 200) {
            this.$message.success("审批成功");
            this.ids = [];
            this.open = false;
            this.getList();
          } else {
            this.$message.error("审批失败");
          }
        } else {
          return false;
        }
      });
    },
    // 初始化审批表单数据
    initApproveFormData() {
      Object.assign(this.approveForm, {
        status: "3",
        orderType: "",
      });
    },
    // 重置审计表单数据
    resetFormData() {
      Object.assign(this.formData, {
        //订单表数据
        saleNo: "", //合同号
        saleCustomNo: "", //客户编号
        saleDate: "", //销售单日期
        saleOrderEstimatedTime: "", //预计下单时间
        saleLeadTime: "", //交货周期
        deliveryDate: "",
        saleAmounts: "", //合计金额 小写
        saleAmountInWords: "", //合计金额 大写
        salePayType: "", //支付方式
        earnestMoney: "",
        salesman: "", //业务员
        saleLeader: "", //业务主管
        finance: "", //财务部
        production: "", //生产部
        saleApprover: "", //批准人
        customAddress: "", //客户地址
        customCountryType: "", //国家类型
        contactPerson: "", //联系人
        // 货品明细表数据
        productNo: "", //货品号
        productName: "", //货品名称
        productNumber: "", //销售数量
        productWeight: "", //销售重量kg
        productUnitPrice: "", //单价
        productAmounts: "", //金额
        remark: "", //备注
        // 工艺表
        craftGrid: "", //网格
        craftOil: "", //油剂
        craftPackage: "", //卷装
        craftColorFastness: "", //色牢度
        directionOfTwist: "",
        craftOther: "", //其它工艺要求
        craftMark: "", //包装/贴唛
        shippingMethod: "", //运输方式
      });
      this.productionTableData = [];
    },
    // 自定义的小计计算方法
    getSummaries(param) {
      const { columns, data } = param;
      console.log(columns, data);
      const sums = [];
      columns.forEach((column, index) => {
        if (index === 0) {
          sums[index] = "小计";
          return;
        }
        const values = data.map((item) => Number(item[column.property]));
        if (index === 4 || index === 5 || index === 6 || index === 7) {
          sums[index] = "";
        } else if (!values.every((value) => isNaN(value))) {
          sums[index] = values.reduce((prev, curr) => {
            const value = Number(curr);
            if (!isNaN(value)) {
              return prev + curr;
            } else {
              return prev;
            }
          }, 0);
          sums[index];
        } else {
          sums[index] = "N/A";
        }
      });

      return sums;
    },
    // 货品表格数据删除回调
    deleteProduct(index) {
      this.productionTableData.splice(index, 1);
    },
    // 货品表格数据新增回调
    addProduct() {
      this.productionTableData.push({
        saleProductNo: uuidv4(),
        productNo: "", //货品编号
        productName: "", //货品名称
        productNumber: "", //销售数量
        productWeight: "", //销售重量kg
        productUnitPrice: "", //单价
        productAmounts: "", //金额
        remark: "", //备注
      });
    },
    // 客户名称改变回调
    customChangeHandler(val) {
      // if (!val) return;
      let customData = this.customerOptions.find(
        (item) => item.customNo == val
      );
      this.formData.customAddress = customData?.customAddress || "无";
      this.formData.customCountryType = customData?.customCountryType || "无";
      this.formData.contactPerson = customData?.contactPerson || "无";
    },
    //审计新增
    async addHandler() {
      this.isEdit = false;
      await this.getDropDownData();
      this.resetFormData();
      this.title = "新增审计单";
      this.open = true;
    },
    // 获取下拉框数据
    async getDropDownData() {
      try {
        let payLoad = [
          {
            basicMap: {
              tableName: "production",
            },
          },
          {
            basicMap: {
              tableName: "customer",
            },
          },
        ];
        let res = await queryDropDownBoxData(payLoad);
        if (res.code == 200) {
          let { production, customer } = res.data.resultMap;
          this.productionOptions = production || [];
          this.customerOptions = customer || [];
        } else {
          throw Error("获取下拉框数据失败");
        }
      } catch (error) {
        console.log(error);
      }
      // 色号数据
      try {
        let payLoad = [
          {
            basicMap: {
              tableName: "materiel",
            },
            conditionMap: {
              materiel_species: ["1"],
            },
          },
        ];
        let res = await queryDropDownBoxData(payLoad);
        if (res.code == 200) {
          console.log(res.data.resultMap);
          let { materiel } = res.data.resultMap;
          this.colourNumberOptions = materiel || [];
        } else {
          throw Error("获取下拉框数据失败");
        }
      } catch (error) {
        console.log(error);
      }
      // 切片型号
      try {
        let payLoad = [
          {
            basicMap: {
              tableName: "materiel",
            },
            conditionMap: {
              materiel_species: ["6"],
            },
          },
        ];
        let res = await queryDropDownBoxData(payLoad);
        if (res.code == 200) {
          console.log(res.data.resultMap);
          let { materiel } = res.data.resultMap;
          this.sliceTypeOptions = materiel || [];
        } else {
          throw Error("获取下拉框数据失败");
        }
      } catch (error) {
        console.log(error);
      }
    },
    // 获取row-key
    getRowKey(row) {
      return row[
        camelCase(this.tableName + "_" + this.templateInfo.template?.primaryKey)
      ];
    },
    /** 查询列表 */
    getList(queryParams, orderStatus = "") {
      this.loading = true;
      // 序列化当前查询参数列表
      queryParams && (this.queryParams.queryMap = queryParams.queryMap);
      // 获取当前表单结构信息
      dragTableInfo({ queryMap: { tableKey: this.tableKey } })
        .then((res) => {
          // 得到当前模版信息 --- sql columns queryWhere
          this.templateInfo = res.data.resultMap;
          this.styleList = res.data.resultMap.style?.map((item) => {
            item.styleField = camelCase(
              item.styleField.replace(".", "_") || ""
            );
            return item;
          });
          // 获取操作列的按钮数据
          this.excuteBtnArr = res.data.resultMap.button;
          this.queryParams.orderByColumn =
            res.data.resultMap.querySql.orderByColumn;
          this.sortOrder = JSON.parse(res.data.resultMap.querySql.sortOrder);
          // 根据拖拽时设置当前列表排列顺序
          this.queryParams.isAsc = this.sortOrder ? "DESC" : "ASC";
          this.tableName = this.templateInfo.template.dtTableName;
          // 得到查询条件
          this.queryFromWhere = res.data.resultMap.where;
          //  得到当前列表信息
          this.columns = this.columnsHandler(
            JSON.parse(this.templateInfo.template.dtColumnName)
          );
        })
        .finally((fes) => {
          if (this.templateInfo == {}) return;
          // 调用查询需要携带当前table的唯一标识
          this.queryParams.queryMap.sqlkey = this.templateInfo.template.sqlKey;
          this.queryParams.orderByColumn = camelCase(
            this.queryParams.orderByColumn || ""
          );

          // let getListFun = orderStatus ? getTableList2 : unionListTableData;
          // if(){}
          // 根据sql语句查询当前表数据
          let tempQueryParams = JSON.parse(JSON.stringify(this.queryParams));
          console.log(orderStatus);
          if (orderStatus == "3,4,5,6,7" || orderStatus == "7") {
            tempQueryParams.conditionMap.columnName1 = "finance";
            tempQueryParams.conditionMap.columnValue1 =
              "IS NOT NULL and finance != ''";
          }
          getTableList1(tempQueryParams).then(async (res) => {
            this.tableList = [];
            res.rows.forEach((item) => {
              this.tableList.push(item.resultMap);
            });
            // 驼峰转换
            let tempTableList = [];
            tempTableList = this.tableList.map((item) => {
              let kv = {};
              for (let itemKey in item) {
                kv[camelCase(itemKey)] = item[itemKey];
              }
              return kv;
            });
            // this.setDictStyleData().then(() => {
            //   this.tableList = this.setFieldStyleData(this.tableList);
            // });
            this.tableList = await this.setFieldStyleData(tempTableList);
            this.total = res.total;
            // this.$nextTick(() => {
            //   this.$refs.tableRef?.clearSelection();
            // });
            this.loading = false;
          });

          // 查询统计信息
          getStatisticList({
            queryMap: {
              tableKey: this.templateInfo.template.tableKey,
              queryCriteriaValue: this.queryParams.queryMap.queryCriteriaValue,
            },
          }).then((res) => {
            this.statisticList = res.data;
          });
        });
    },
    // 审计   提交编辑结果按钮回调
    async editConfirm() {
      this.$refs.formDataRef.validate(async (valid) => {
        if (valid) {
          let {
            //订单表数据
            saleCustomNo,
            saleDate,
            saleOrderEstimatedTime,
            saleLeadTime,
            deliveryDate,
            saleAmounts,
            saleAmountInWords,
            salePayType,
            earnestMoney,
            salesman,
            saleLeader,
            finance,
            production,
            saleApprover,

            // 工艺表数据
            craftGrid,
            craftOil,
            craftPackage,
            craftColorFastness,
            directionOfTwist,
            craftOther,
            craftMark,
            shippingMethod,
          } = this.formData;
          let saleCraftNo = this.isEdit ? this.formData.saleCraftNo : uuidv4(),
            saleNo = this.isEdit ? this.formData.saleNo : uuidv4();
          let saleProductsNo = this.productionTableData
            .map((item) => item.saleProductNo)
            .join(","); //销售单表sale_products_no字段存货品表的sale_product_no，逗号分割
          let saleValue = {
            status: 1, //新增销售单时  默认为1
            saleNo,
            saleProductsNo,
            saleOrderTechnologyNo: saleCraftNo,
            saleCustomNo,
            saleDate,
            saleOrderEstimatedTime,
            saleLeadTime,
            deliveryDate,
            // saleAmounts, //合计金额  小写
            saleAmountInWords,
            salePayType,
            earnestMoney,
            salesman,
            saleLeader,
            finance,
            production,
            saleApprover,
          };
          let craftValue = {
            saleOrderNo: saleNo,
            saleCraftNo,
            craftGrid,
            craftOil,
            craftPackage,
            craftColorFastness,
            directionOfTwist,
            craftOther,
            craftMark,
            shippingMethod,
          };

          let saleData = {
            //订单表新增数据
            basicMap: {
              tableName: "sale_order",
            },
            // addListMap: [saleValue],
            conditionMap: {},
            commMap: {},
            btnParametersMap: {},
          };
          let craftData = {
            //工艺表新增数据
            basicMap: {
              tableName: "sale_craft",
            },
            // addListMap: [craftValue],
            conditionMap: {},
            commMap: {},
            btnParametersMap: {},
          };
          this.productionTableData.forEach((item) => {
            item.saleOrderNo = saleNo;
          });
          let productData = {
            //货品表新增数据
            basicMap: {
              tableName: "sale_products",
            },
            addListMap: [...this.productionTableData],
            conditionMap: {},
            commMap: {},
            btnParametersMap: {},
          };
          if (this.isEdit) {
            //修改
            Object.keys(saleValue).map((k) => {
              saleData.commMap[k] = saleValue[k];
            });
            Object.keys(craftValue).map((k) => {
              craftData.commMap[k] = craftValue[k];
            });
            saleData.conditionMap.saleNo = saleValue.saleNo;
            craftData.conditionMap.saleCraftNo = craftValue.saleCraftNo;
            // for(let i = 0;i<this.)
            let deletPayload = {
              //删除货品数据的接口
              basicMap: {
                tableName: "sale_products",
              },
              conditionMap: {
                saleProductNo: this.productIds,
              },
            };
            let delRes = { code: 200 };
            if (this.productIds.length) {
              delRes = await delTableData(deletPayload); //删除旧数据
            }

            let updateSaleRes = await batchEdit(saleData);
            let updateCraftRes = await batchEdit(craftData);
            let addProductRes = { code: 200 };
            if (productData.addListMap.length) {
              addProductRes = await addTableData(productData);
            }
            console.log(delRes, updateSaleRes, updateCraftRes, addProductRes);
            if (
              delRes?.code === 200 &&
              updateSaleRes?.code === 200 &&
              updateCraftRes?.code === 200 &&
              addProductRes?.code === 200
            ) {
              this.$message.success("修改成功");
              this.open = false;
              this.getList();
            } else {
              this.$message.error("修改失败");
            }
          } else {
            //新增
            saleData.addListMap = [saleValue];
            craftData.addListMap = [craftValue];
            let saleRes = await addTableData(saleData);
            let craftRes = await addTableData(craftData);
            let productRes = await addTableData(productData);
            if (
              saleRes.code === 200 &&
              craftRes.code === 200 &&
              productRes.code === 200
            ) {
              this.$message.success("添加成功");
              this.open = false;
              this.getList();
            } else {
              this.$message.error("添加失败");
            }
          }
          // Object.keys(saleValue).map((k) => {
          //   saleData.commMap[k] = saleValue[k];
          // });
        }
      });
    },
    // 审计   编辑回调
    async handleEdit(index, row) {
      console.log(11111);
      console.log(this.ids);
      console.log(this.dict.type.sales_order_type);
      console.log(row);
      let orderTypeRes = await listData({
        isEnablePaging: false,
        dictType: "sales_order_type",
      });
      if (orderTypeRes.code == 200) {
        this.orderTypeOptions = orderTypeRes.rows?.map((item) => {
          return {
            label: item.dictLabel,
            value: item.dictValue,
          };
        });
      }
      let { saleOrderSaleNo, saleOrderId, saleOrderOrderType } = row;
      this.ids.push(saleOrderId);
      this.approveForm.orderType = saleOrderOrderType;
      this.approveNo = saleOrderSaleNo;
      try {
        let payLoad = [
          {
            basicMap: {
              tableName: "sale_order",
            },
            conditionMap: {
              sale_no: [saleOrderSaleNo],
            },
          },
          {
            basicMap: {
              tableName: "sale_products",
            },
            conditionMap: {
              sale_order_no: [saleOrderSaleNo],
            },
          },
          {
            basicMap: {
              tableName: "sale_craft",
            },
            conditionMap: {
              sale_order_no: [saleOrderSaleNo],
            },
          },
        ];
        let res = await queryDropDownBoxData(payLoad);
        if (res.code == 200) {
          this.isEdit = true;
          let { sale_craft, sale_order, sale_products } = res.data.resultMap;

          Object.assign(this.formData, {
            ...sale_craft[0],
            ...sale_order[0],
          });
          let { saleDate, saleOrderEstimatedTime } = sale_order[0];
          saleDate && (this.formData.saleDate = new Date(saleDate));
          saleOrderEstimatedTime &&
            (this.formData.saleOrderEstimatedTime = saleOrderEstimatedTime);
          this.productionTableData = sale_products;
          this.productIds = sale_products.map((item) => item.saleProductNo);
          await this.getDropDownData();
          this.title = "编辑审计单";
          this.open = true;
        }
      } catch (error) {
        console.log(error);
      }
    },
    // 审计   批量删除回调
    async batchDelete() {
      if (!this.ids.length) return;
      try {
        await this.$confirm("是否确认删除选中的数据？", "警告", {
          confirmButtonText: "确定",
          cancelButtonText: "取消",
          type: "warning",
        });
        let orderPayload = {
          basicMap: {
            tableName: "sale_order",
          },
          conditionMap: {
            saleNo: this.ids,
          },
        };
        let productsPayload = {
          basicMap: {
            tableName: "sale_products",
          },
          conditionMap: {
            saleOrderNo: this.ids,
          },
        };
        let craftPayload = {
          basicMap: {
            tableName: "sale_craft",
          },
          conditionMap: {
            saleOrderNo: this.ids,
          },
        };
        let orderRes = await delTableData(orderPayload);
        let productRes = await delTableData(productsPayload);
        let craftRes = await delTableData(craftPayload);
        if (
          orderRes.code == 200 &&
          productRes.code == 200 &&
          craftRes.code == 200
        ) {
          this.$message.success("删除成功");
          this.getList();
        } else {
          this.$message.error("删除失败");
          throw Error("删除失败");
        }
      } catch (error) {
        console.log(error);
      }
    },
    isUpperCase(char) {
      return char === char.toUpperCase();
    },
    // 下划线命名转驼峰命名
    toUnderScoreCase(str) {
      if (str === null) {
        return null;
      }
      let sb = "";
      // 前置字符是否大写
      let preCharIsUpperCase = true;
      // 当前字符是否大写
      let curreCharIsUpperCase = true;
      // 下一字符是否大写
      let nexteCharIsUpperCase = true;
      for (let i = 0; i < str.length; i++) {
        let c = str.charAt(i);
        if (i > 0) {
          preCharIsUpperCase = isUpperCase(str.charAt(i - 1));
        } else {
          preCharIsUpperCase = false;
        }

        curreCharIsUpperCase = isUpperCase(c);

        if (i < str.length - 1) {
          nexteCharIsUpperCase = isUpperCase(str.charAt(i + 1));
        }

        if (
          preCharIsUpperCase &&
          curreCharIsUpperCase &&
          !nexteCharIsUpperCase
        ) {
          sb += SEPARATOR;
        } else if (i !== 0 && !preCharIsUpperCase && curreCharIsUpperCase) {
          sb += SEPARATOR;
        }
        sb += c.toLowerCase();
      }

      return sb;
    },
    // 处理列表信息
    columnsHandler(columns) {
      let resArr = [];
      columns.forEach((item) => {
        for (const key in item) {
          let tempObj = {};
          tempObj.key = camelCase(key);
          tempObj.value = item[key];
          resArr.push(tempObj);
        }
      });
      return resArr;
    },
    // 取消按钮
    cancel() {
      this.open = false;
      // this.reset();
    },
    // 分页查询
    pageList(row) {
      // 调用子组件-》携带子组件参数请求后台
      this.$refs.mychild.pageList(
        row == undefined
          ? {
              limit: this.queryParams.pageSize,
              page: this.queryParams.pageNum,
            }
          : row
      );
    },
    // 多选框选中数据
    handleSelectionChange(selection) {
      // this.ids = selection.map(
      //   (item) =>
      //     item[
      //       camelCase(
      //         this.tableName + "_" + this.templateInfo.template?.primaryKey
      //       )
      //     ]
      // );
      this.ids = selection.map((item) => item.saleOrderId);
      this.single = selection.length != 1;
      this.multiple = !selection.length;
    },

    // 更多操作触发
    handleCommand(command, row) {
      switch (command) {
        case "handleResetPwd":
          this.handleResetPwd(row);
          break;
        case "handleAuthRole":
          this.handleAuthRole(row);
          break;
        default:
          break;
      }
    },
    /** 新增按钮操作 */
    handleAdd(row) {
      // this.reset();
      this.defaultValue = {};
      getInfoBySqlKey(this.templateInfo.template.sqlKey).then(({ data }) => {
        if (!data || !data.dfVueTemplate) {
          this.jsonData = false;
          this.$message.error("当前表格未绑定表单!");
          return;
        }
        if (data.dfFormSql) {
          let dynamicData = JSON.parse(data.dfFormSql);
          Object.assign(this.dynamicData, dynamicData);
        }
        this.jsonData = JSON.parse(data.dfVueTemplate);
        this.open = true;
        this.title = "添加信息";
        this.form.password = this.initPassword;
        this.$nextTick(() => {
          this.$refs.addFromRef.reset();
          inputDisableComplete();
        });
      });
    },
    longestCommonSubstring(strs) {
      if (!strs || strs.includes("")) return "";
      let str1_Length = strs[0].length;
      let str_Nums = strs.length;
      let flag = 0;
      for (let i = 0; i < str1_Length && flag == 0; i++) {
        let char = strs[0][i];
        for (var j = 1; j < str_Nums; j++) {
          if (char !== strs[j][i] || i == strs[j].length) {
            return strs[1].substring(0, i);
          }
        }
      }
      return strs[0];
    },
    // 绑定dialog对话框关闭
    handleClose() {
      this.btnDialogVisible = false;
    },
    getLastUppercaseWord(text) {
      const pattern = /\b[A-Z][a-z]*\b/g;
      const matches = [...text.matchAll(pattern)];
      if (matches.length > 0) {
        const lastMatch = matches[matches.length - 1][0];
        return lastMatch;
      } else {
        return null;
      }
    },
    /** 修改按钮操作 */
    async handleUpdate(row, btnData) {
      let nameTable = this.templateInfo.template.dtTableName;
      this.rowobj = {};
      let obj = {};
      for (let key in row) {
        let modifiedTable = key
          .replace(/[A-Z]/g, (match) => `_${match}`)
          .toLowerCase();

        this.rowobj[modifiedTable] = row[key];

        let str = modifiedTable.substring(nameTable.length + 1);
        obj[str] = row[key];
      }
      // getInfoBySqlKey(this.templateInfo.template.sqlKey).then(({ data }) => {
      //   if (!data || !data.dfVueTemplate) {
      //     this.$message.error("当前表格未绑定表单!");
      //     return;
      //   }});

      // 新的修改请求
      try {
        let payLoad = {
          basicMap: {
            btnType: this.currentBtnData.btnType,
            btnKey: this.currentBtnData.btnKey,
            visible: "false",
            sqlKey: this.templateInfo.template.sqlKey,
            tableName: this.tableName,
          },
          conditionMap: {},
        };
        let primary = camelCase(
          this.tableName + "_" + this.templateInfo.template?.primaryKey
        );
        payLoad.conditionMap[this.templateInfo.template?.primaryKey] =
          row[primary];
        let res = await btnCommonApi(payLoad);
        // 判断是否绑定dialog弹窗
        if (!this.currentBtnData.btnTableFormGroupKey) {
          if (!res.data || !res.data.template) {
            this.$message.error("当前按钮未绑定表单!");
            return;
          }

          res.data.template.dfFormSql &&
            (this.dynamicData = JSON.parse(res.data.template.dfFormSql));
          this.addRealFieldName(res.data.result.resultMap);
          let resultMap = res.data.result.resultMap;

          Object.assign(this.defaultValue, resultMap);
          this.jsonData = JSON.parse(res.data.template.dfVueTemplate);
          this.open = true;
          this.title = "修改信息";
          this.form.password = this.initPassword;
          this.$nextTick(() => {
            this.$refs.addFromRef.setData(res.data.result.resultMap);
          });
        } else {
          this.subTableName = res.data.result.dragTables[1].dtTableName;
          this.btnDialogVisible = true;
          this.groupKey = this.currentBtnData.btnTableFormGroupKey;
          this.$nextTick(() => {
            let refChild = this.$refs.dialogRef;
            refChild.getLists(this.groupKey);
          });

          let tablesubKey = res.data.result.dragTables[1].tableKey;

          // 查询统计信息
          getStatisticList({
            queryMap: {
              tableKey: tablesubKey,
            },
          }).then((res) => {
            this.subCount = res.data;
          });

          let prmKey = this.templateInfo.template.primaryKey;
          let pkey = prmKey.replace(/_([a-z])/g, (match, p1) =>
            p1.toUpperCase()
          );

          let data = {
            queryMap: {
              tableKey: res.data.result.dragTables[2].tableKey,
            },
          };

          let key =
            "#{" +
            this.templateInfo.template.dtTableName +
            "." +
            this.templateInfo.template.primaryKey;

          data.queryMap[key] =
            "'" + obj[this.templateInfo.template.primaryKey] + "'";

          getStatisticList(data).then((res) => {
            this.tableCount = res.data;
          });
        }

        // let fieldList = Object.keys(resultMap);
        // let tableName = this.longestCommonSubstring(fieldList);
        // fieldList.forEach((field) => {
        //   let realField = field.replace(tableName, "");
        //   realField = realField[0].toLocaleLowerCase() + realField.substring(1);
        //   resultMap[realField] = resultMap[field];
        // });
      } catch (error) {
        this.$message.error("网络异常,请稍后再试");
        console.log(error);
      }
      return;
      // getInfoBySqlKey(this.templateInfo.template.sqlKey).then(({ data }) => {
      //   if (!data || !data.dfVueTemplate) {
      //     this.$message.error("当前表格未绑定表单!");
      //     return;
      //   }
      //   // let fieldList = Object.keys(row);
      //   // let tableName = this.longestCommonSubstring(fieldList);
      //   // fieldList.forEach((field) => {
      //   //   let realField = field.replace(tableName, "");
      //   //   realField = realField[0].toLocaleLowerCase() + realField.substring(1);
      //   //   row[realField] = row[field];
      //   // });
      //   this.addRealFieldName(row);
      //   Object.assign(this.defaultValue, row);
      //   this.jsonData = JSON.parse(data.dfVueTemplate);
      //   this.open = true;
      //   this.title = "修改信息";
      //   this.form.password = this.initPassword;
      //   this.$nextTick(() => {
      //     this.$refs.addFromRef.setData(row);
      //   });
      // });
      // return;
      this.reset();
      const userId = row.userId || this.ids;
      getUser(userId).then((response) => {
        this.form = response.data;
        this.postOptions = response.posts;
        this.roleOptions = response.roles;
        this.$set(this.form, "postIds", response.postIds);
        this.$set(this.form, "roleIds", response.roleIds);
        this.open = true;
        this.title = "修改当前信息";
        this.form.password = "";
      });
    },
    // 添加真正的字段名
    addRealFieldName(row) {
      let fieldList = Object.keys(row);
      // let tableName = this.longestCommonSubstring(fieldList);
      let tableName = camelCase(this.tableName);
      fieldList.forEach((field) => {
        let realField = field.replace(tableName, "");
        realField = realField[0].toLocaleLowerCase() + realField.substring(1);
        row[realField] = row[field];
      });
    },

    /** 提交按钮 */
    submitForm: function () {
      this.$refs["form"].validate((valid) => {
        if (valid) {
          if (this.form.userId != undefined) {
            updateUser(this.form).then((response) => {
              this.$modal.msgSuccess("修改成功");
              this.open = false;
              this.getList();
            });
          } else {
            addUser(this.form).then((response) => {
              this.$modal.msgSuccess("新增成功");
              this.open = false;
              this.getList();
            });
          }
        }
      });
    },
    /** 删除按钮操作
     *
     * 删除提示信息语句（标识）
     * */
    handleDelete(row, btnData) {
      let delIds = this.ids;
      let primary = camelCase(this.templateInfo.template?.primaryKey);
      // let realyKey=
      this.addRealFieldName(row);
      if (row[primary] != undefined && row[primary] != null) {
        delIds = [];
        delIds.push(row[primary]);
      }
      let data = {
        basicMap: {
          btnType: btnData.btnType,
          btnKey: btnData.btnKey,
          tableName: this.tableName,
        },
        conditionMap: {
          // id: delIds,
        },
        btnParametersMap: {},
      };
      if (this.currentBtnData.btnParams) {
        let btnParams =
          JSON.parse(this.currentBtnData.btnParams)?.commonFieldData || [];
        let conditionData =
          JSON.parse(this.currentBtnData.btnParams).conditionData || [];
        conditionData.forEach((item) => {
          data.conditionMap[item.fieldName.split(".")[1]] = item.fieldValue
            ? item.fieldValue
            : this.currentRow[camelCase(item.fieldName.replace(".", "_"))];
        });
        btnParams.forEach((item) => {
          data.btnParametersMap[item.fieldName.split(".")[1]] = item.fieldValue
            ? item.fieldValue
            : this.currentRow[camelCase(item.fieldName.replace(".", "_"))];
        });
      }
      // data.conditionMap[this.templateInfo.template?.primaryKey] = delIds;
      this.$modal
        .confirm('是否确认删除"' + delIds + '"的数据项？')
        .then(function () {
          // return delTableData(data);
          return btnCommonApi(data);
        })
        .then(() => {
          // 调用子组件查询方法 目的是携带上子组件中的查询参数
          this.$refs.mychild.pageList();
          this.$modal.msgSuccess("删除成功");
        })
        .catch(() => {});
    },
    // 批量删除接口
    handleBatchDelete() {
      let delIds = this.ids;
      let primary = camelCase(this.templateInfo.template?.primaryKey);
      // if (row && row[primary] != undefined && row[primary] != null) {
      //   delIds = [];
      //   delIds.push(row[primary]);
      // }
      let data = {
        basicMap: {
          tableName: this.tableName,
        },
        conditionMap: {
          // id: delIds,
        },
      };
      // if (this.currentBtnData.btnParams) {
      //   let btnParams = JSON.parse(this.currentBtnData.btnParams);
      //   btnParams.forEach((item) => {
      //     data.btnParametersMap[
      //       this.formatField(item.fieldName, camelCase(this.tableName))
      //     ] = item.fieldValue
      //       ? item.fieldValue
      //       : this.currentRow[item.fieldName];
      //   });
      // }
      data.conditionMap[this.templateInfo.template?.primaryKey] = delIds;
      this.$modal
        .confirm('是否确认删除"' + delIds + '"的数据项？')
        .then(function () {
          return delTableData(data);
          // return btnCommonApi(data);
        })
        .then(() => {
          // 调用子组件查询方法 目的是携带上子组件中的查询参数
          this.$refs.mychild.pageList();
          this.$modal.msgSuccess("删除成功");
        })
        .catch(() => {});
    },
    /** 导出按钮操作 */
    handleExport() {
      let primary = camelCase(this.templateInfo.template?.primaryKey);
      let realyKey = camelCase(this.tableName + "_" + primary);
      if (this.ids.length > 0) {
        this.queryParams["execlMap"] = [];
        this.ids.forEach((item) => {
          this.queryParams.execlMap.push(
            this.tableList.find((ttem) => {
              return ttem[realyKey] === item;
            })
          );
        });
      } else {
        this.$message.warning("请至少勾选一条导出数据");
        return;
      }
      this.queryParams.execlMap = JSON.stringify(this.queryParams.execlMap);
      this.download(
        process.env.VUE_APP_BASE_API3 + "common/export",
        {
          ...this.queryParams,
        },
        `文件名称_${new Date().getTime()}.xlsx`
      );
    },
    /** 导入按钮操作 */
    handleImport() {
      this.upload.title = "当前导入";
      this.upload.open = true;
    },
    /** 下载模板操作 */
    importTemplate() {
      this.download(
        process.env.VUE_APP_BASE_API3 +
          `common/exportTemplate?tableName=${this.tableName}&sqlkey=${this.templateInfo.template.sqlKey}`,
        {},
        `下载模版名称${new Date().getTime()}.xlsx`
      );
    },
    // 文件上传中处理
    handleFileUploadProgress(event, file, fileList) {
      this.upload.isUploading = true;
    },
    // 文件上传成功处理
    handleFileSuccess(response, file, fileList) {
      this.upload.open = false;
      this.upload.isUploading = false;
      this.$refs.upload.clearFiles();
      this.$alert(
        "<div style='overflow: auto;overflow-x: hidden;max-height: 70vh;padding: 10px 20px 0;'>" +
          response.msg +
          "</div>",
        "导入结果",
        { dangerouslyUseHTMLString: true }
      );
      this.$refs.mychild.pageList({
        limit: this.queryParams.pageSize,
        page: this.queryParams.pageNum,
      });
    },
    //重点在这里
    handleChange(file, fileList) {
      file.name = this.tableName + "." + file.name.split(".")[1];
      fileList.forEach((item) => {
        item.name = this.tableName + "." + file.name.split(".")[1];
      });
      let newFile = new File(
        [file],
        this.tableName + "." + file.name.split(".")[1]
      ); //创建出来也是不可编辑的file对象
    },
    // 提交上传文件
    submitFileForm() {
      this.$refs.upload.submit();
    },
    // 弹窗新增的数
    addListHandler(val) {
      this.addLists.push(...val);
    },
    // 绑定弹窗Dialog确定按钮
    btnComfirm() {
      // let data = {
      //   addListMap:[],
      //   basicMap:{
      //     btnType: 10,
      //     tableName: this.subTableName,
      //     visible: true,
      //   },
      //   commMap: {},
      //   conditionMap: {},
      // }
      // // data.addListMap =
      // btnCommonApi(data).then(res => {
      //   console.log('弹窗确定', res);
      // })
    },
    // 去掉表名 开头字母小写
    formatField(field = "", tableName) {
      let temp = field.replace(tableName, "");
      return toUnderline(temp[0].toLowerCase() + temp.slice(1));
    },
    //提交编辑结果按钮回调
    async editConfirmHandler() {
      if (this.$refs.addFromRef) {
        this.$refs.addFromRef
          .getData()
          .then(async (values) => {
            let data = {
              basicMap: {
                tableName: this.tableName,
                // btnKey: btnData.btnKey,
                btnKey: this.currentBtnData.btnKey,
              },
              addListMap: [values],
              conditionMap: {},
              commMap: {},
              btnParametersMap: {},
            };
            if (this.currentBtnData.btnParams) {
              let btnParams =
                JSON.parse(this.currentBtnData.btnParams)?.commonFieldData ||
                [];
              let conditionData =
                JSON.parse(this.currentBtnData.btnParams).conditionData || [];
              // let
              btnParams.forEach((item) => {
                data.btnParametersMap[item.fieldName.split(".")[1]] =
                  item.fieldValue
                    ? item.fieldValue
                    : this.currentRow[
                        camelCase(item.fieldName.replace(".", "_"))
                      ];
              });
              conditionData.forEach((item) => {
                data.conditionMap[item.fieldName.split(".")[1]] =
                  item.fieldValue
                    ? item.fieldValue
                    : this.currentRow[
                        camelCase(item.fieldName.replace(".", "_"))
                      ];
              });
            }
            if (Object.keys(this.defaultValue).length) {
              // data.conditionMap[this.templateInfo.template?.primaryKey] =
              //   this.defaultValue[this.templateInfo.template?.primaryKey];
              Object.keys(values).map((k) => {
                data.commMap[k] = values[k];
              });
              data.basicMap.btnType = this.currentBtnData.btnType;
              data.basicMap.visible = true;
            } else {
              data.basicMap.btnType = "INSERT";
              data.basicMap.visible = true;
            }
            try {
              let res = await btnCommonApi(data);
              if (res.code == 200) {
                this.$message.success("操作成功");
              } else {
                this.$message.error("网络异常,请稍后再试");
              }
            } catch (error) {
              console.log(error);
              this.$message.error("网络异常,请稍后再试");
            }
            this.getList();
            this.defaultValue = {};
            this.open = false;
          })
          .catch((res) => {
            console.log(res);
            this.$modal.msgError("表单校验失败,请规范填写数据");
          });
      } else {
        // 没有绑定表单
        let data = {
          basicMap: {
            tableName: this.tableName,
            // btnKey: btnData.btnKey,
            btnKey: this.currentBtnData.btnKey,
            btnType: this.currentBtnData.btnType,
            visible: true,
          },
          addListMap: [],
          conditionMap: {},
          commMap: {},
          btnParametersMap: {},
        };
        if (this.currentBtnData.btnParams) {
          let btnParams =
            JSON.parse(this.currentBtnData.btnParams)?.commonFieldData || [];
          let conditionData =
            JSON.parse(this.currentBtnData.btnParams).conditionData || [];
          conditionData.forEach((item) => {
            data.conditionMap[item.fieldName.split(".")[1]] = item.fieldValue
              ? item.fieldValue
              : this.currentRow[camelCase(item.fieldName.replace(".", "_"))];
          });
          btnParams.forEach((item) => {
            data.btnParametersMap[item.fieldName.split(".")[1]] =
              item.fieldValue
                ? item.fieldValue
                : this.currentRow[camelCase(item.fieldName.replace(".", "_"))];
          });
        }
        // data.basicMap.btnType = this.currentBtnData.btnType;
        // data.basicMap.visible = true;
        try {
          let res = await btnCommonApi(data);
          if (res.code == 200) {
            this.$message.success("操作成功");
          } else {
            this.$message.error("网络异常,请稍后再试");
          }
        } catch (error) {
          console.log(error);
          this.$message.error("网络异常,请稍后再试");
        }
        this.getList();
        this.defaultValue = {};
        this.open = false;
      }
    },
    // 使用提交数据类型的按钮获取数据
    tempSubBtn(getData) {
      getData()
        .then((values) => {
          console.log("验证通过", values);
        })
        .catch(() => {
          console.log("验证未通过，获取失败");
        });
    },
    // 判断是否生效行样式
    cellStyle({ row, column, rowIndex, columnIndex }) {
      let rowStyleList = this.styleList.filter((item) => item.styleType == 0);
      if (!rowStyleList.length) return "";
      let mainTableName = this.templateInfo.querySql.tableAlias; //主表名
      for (let i = 0; i < rowStyleList.length; i++) {
        let item = rowStyleList[i];
        let judgeRes = this.determineCondition(item.styleCondtion, row);
        if (judgeRes) {
          let styleCode = JSON.parse(item.styleCode);
          return `background-color:${styleCode.rowBgColor};`;
        }
      }
    },

    // 获取生效条件组结果
    determineCondition(conditionStr, row) {
      let conditionList = JSON.parse(conditionStr);
      if (!conditionList.length) return false;
      return conditionList.every((item) => this.judgeOneCondition(item, row));
    },

    // 获取单个判断条件结果
    judgeOneCondition(item, row) {
      let fullField = camelCase(item.tableName + "_" + item.fieldName);
      switch (item.condition) {
        case 1:
          return row[fullField] > item.flagValue;
        case 2:
          return row[fullField] < item.flagValue;
        case 3:
          return row[fullField] == item.flagValue;
        case 4:
          return row[fullField] >= item.flagValue;
        case 5:
          return row[fullField] <= item.flagValue;
        default:
          return true; //默认为true
      }
    },

    // 设置表格字段样式
    async setFieldStyleData(tableList) {
      console.log(JSON.parse(JSON.stringify(tableList)));
      let fieldConditionList = this.styleList.filter(
        (item) => item.styleType == 1 || item.styleType == 2
      );
      if (!fieldConditionList.length) return tableList;
      let res = await this.setDictStyleData();

      this.dictStyleObj = res.reduce((pre, item) => {
        return {
          ...pre,
          ...item,
        };
      }, {});
      // console.log("this.dictStyleObj", this.dictStyleObj);
      tableList.forEach((row) => {
        // if (!row.styleFieldObj) row.styleFieldObj = {};
        for (let i = 0; i < fieldConditionList.length; i++) {
          let item = fieldConditionList[i];
          if (item.styleType == 1) {
            //字段样式
            let judgeRes = this.determineCondition(item.styleCondtion, row);
            if (judgeRes) {
              let styleCode = JSON.parse(item.styleCode);
              if (!row.styleFieldObj) row.styleFieldObj = {};
              row.styleFieldObj[item.styleField] = {
                styleType: item.styleType,
                fieldStyleType: styleCode.fieldStyleType,
                fontColor: styleCode.fontColor,
                isTagFullBg: styleCode.isTagFullBg,
                tagType: styleCode.tagType,
              };
              // row.styleField = item.styleField; //样式生效字段
              // row.styleType = item.styleType; //0:行样式 1:字段样式 2:字典样式
              // row.fieldStyleType = styleCode.fieldStyleType; //0:文本  1:标签
              // row.fontColor = styleCode.fontColor;
              // row.isTagFullBg = styleCode.isTagFullBg; //true/false
              // row.tagType = styleCode.tagType; //string
            }
          } else {
            //字典样式
            let dicStyle = this.dictStyleObj[item.styleField]?.find((dict) => {
              return dict.dictValue == row[item.styleField];
            });
            if (dicStyle) {
              if (!row.styleFieldObj) row.styleFieldObj = {};
              row.styleFieldObj[item.styleField] = dicStyle; //设置该字段应该显示的字典样式
              row.styleFieldObj[item.styleField].styleType = 2;
            }
          }
        }
      });
      return tableList;
    },

    //设置表格字典相关数据
    setDictStyleData() {
      let fieldConditionList = this.styleList.filter(
        (item) => item.styleType == 2
      );
      if (!fieldConditionList.length) return;
      let PromiseList = fieldConditionList.map((item) => {
        return new Promise((resolve, reject) => {
          let temp = {};
          try {
            listData({
              isEnablePaging: false,
              dictType: item.styleCondtion,
            }).then((res) => {
              temp[item.styleField] = res.rows;
              resolve(temp);
            });
          } catch (error) {
            reject(error);
          }
        });
      });
      return Promise.all(PromiseList);
    },

    // 内链页面跳转
    routerHandler(btnData, type) {
      let { url, commonFieldData } = JSON.parse(btnData.btnParams);
      let tempArr = [];
      if (commonFieldData) {
        let queryArr = JSON.parse(commonFieldData);

        tempArr = queryArr.map((item) => {
          let key = this.formatField(item.fieldName, camelCase(this.tableName));
          let value = item.fieldValue
            ? item.fieldValue
            : this.currentRow[item.fieldName];
          return key + "=" + value;
        });
      }
      if (tempArr.length) {
        url += "?" + tempArr.join("&");
      }
      // let link = btnData.btnParams;
      if (type == "INNERLINK") {
        this.$router.push(url);
      } else {
        window.open("http://" + url, "_blank");
      }
    },

    // 操作列回调
    excuteHandler(btnData, row) {
      console.log("btnData", btnData, row);
      let { btnType, btnParams, btnFormType } = btnData;
      this.currentBtnData = btnData;
      this.currentRow = JSON.parse(JSON.stringify(row));
      // 无表单
      if (btnFormType == "noNeed") {
        this.noNeedHandler(btnData, row);
        return;
      }
      switch (btnType) {
        case "INNERLINK":
          this.routerHandler(btnData, btnType);
          break;
        case "OUTLINK":
          this.routerHandler(btnData, btnType);
          break;
        case "UPDATE":
          this.handleUpdate(row, btnData);
          break;
        case "EXECUTE":
          this.handleUpdate(row, btnData);
          break;
        case "INITIATED":
          this.handleUpdate(row, btnData);
          break;
        case "DELETE":
          this.handleDelete(row, btnData);
          break;
        default:
          break;
      }
    },
    noNeedHandler(btnData, row) {
      this.$modal
        .confirm("是否确认执行该操作？")
        .then(async () => {
          // 获取默认参数
          let data = {
            basicMap: {
              tableName: this.tableName,
              // btnKey: btnData.btnKey,
              btnKey: this.currentBtnData.btnKey,
            },
            conditionMap: {},
            commMap: {},
            btnParametersMap: {},
          };
          console.log(this.currentBtnData, this.currentRow);
          if (this.currentBtnData.btnParams) {
            let conditionData =
              JSON.parse(this.currentBtnData.btnParams).conditionData || [];
            // let
            let commonData =
              JSON.parse(this.currentBtnData.btnParams).commonFieldData || [];

            conditionData.forEach((item) => {
              data.conditionMap[item.fieldName.split(".")[1]] = item.fieldValue
                ? item.fieldValue
                : this.currentRow[camelCase(item.fieldName.replace(".", "_"))];
            });
            commonData.forEach((item) => {
              data.btnParametersMap[item.fieldName.split(".")[1]] =
                item.fieldValue
                  ? item.fieldValue
                  : this.currentRow[
                      camelCase(item.fieldName.replace(".", "_"))
                    ];
            });
          }
          data.basicMap.btnType = this.currentBtnData.btnType;
          data.basicMap.visible = true;
          try {
            let res = await btnCommonApi(data);
            if (res.code == 200) {
              this.$message.success(res.msg);
            } else {
              this.$message.error("网络异常,请稍后再试");
            }
          } catch (error) {
            console.log(error);
            this.$message.error("网络异常,请稍后再试");
          }
        })
        .then(() => {
          // 调用子组件查询方法 目的是携带上子组件中的查询参数
          this.$refs.mychild.pageList();
          // this.$modal.msgSuccess("操作成功");
        })
        .catch(() => {});
    },

    // k-form-build表单变化回调
    formChangeHandler(value, label) {
      // console.log(value, label);
    },
  },
};
</script>

<style scoped lang="scss">
::v-deep .el-dialog:not(.is-fullscreen) {
  min-width: 610px !important;
}
</style>