WorkloadWeb/src/pages/PurchaseAdmin/PurchaseList/Detail/CommitAuditModal.js

import React, { useEffect, useState, useRef, useMemo, useCallback } from 'react';
import '@ant-design/compatible/assets/index.css';
import {
  Modal,
  Input,
  Select,
  message,
  Cascader,
  Form,
  Tabs,
  Row,
  Col,
  Empty,
  Button,
  Steps,
  Popover,
} from 'antd';
import { PlusOutlined } from '@ant-design/icons';
import { connect } from 'dva';
import { isArray, result, set } from 'lodash';
import { useForm } from 'rc-field-form';
import { async } from '@antv/x6/lib/registry/marker/async';
import AuditDetailed from './AuditDetailed';
import AuditFlow from './AuditFlow';
import { queryDingSchema, queryProcessFlows } from '@/services/boom';
import { Form as Form3x } from '@ant-design/compatible';
import { getCurrentUser } from '@/utils/authority';
import DDCode from '@/components/DDComponents/DDCode';
import { uploadFile, queryUserListByRoleID } from '@/services/boom';
import ApprovalProcess from './ApprovalProcess';

const { TextArea } = Input;
const { Option } = Select;
const { TabPane } = Tabs;
const { Step } = Steps;

// 提交
function CommitAuditModal(props) {
  const {
    dispatch,
    visible,
    onClose,
    onOk,
    loading,
    version,
    versionList,
    flowDetail,
    currentUser,
    luckysheet,
    userList,
  } = props;
  const [auditId, setAuditId] = useState();
  const [data, setData] = useState([]);
  const [length, setLength] = useState(1);
  const [formData, setFromData] = useState({});
  const [auditList, setAuditList] = useState([]); //用于创建Tabs表单
  const [formComponentValues, setFormComponentValues] = useState({}); //用于创建Tabs表单
  const [form] = Form.useForm();
  const [approvalProcess, setApprovalProcess] = useState({});
  const [selectUserList, setSelectUserList] = useState([]);
  const [curNodeIdx, setCurNodeIdx] = useState(-1);

  useEffect(() => {
    if (!visible) return;
    const { edges, nodes } = flowDetail;
    let Id = version.template_node_id;
    const currentId = flowDetail.nodes.find?.(item => item.Id == Id)?.node_id;
    const data = treeData(currentId);
    if (data.length <= 0) setAuditId(currentId);
    setData(data);
  }, [auditId, version.template_node_id, visible]);

  useEffect(() => {
    form.resetFields();
    setAuditList([]);
  }, [visible]);

  const treeData = currentId => {
    const list = getNextNodes(currentId, 'custom-circle');
    const fun = nodes => {
      const re = nodes?.forEach((item, idx) => {
        const data = getNextNodes(item.Id, 'custom-circle');
        if (data || data.length > 0) list.push(...data);
        fun(data);
      });
    };
    fun(list);

    const fun2 = list => {
      const parents = list.filter(item => list.findIndex(node => node.Id == item.parentId) == -1);
      let translator = (parents, children) => {
        setLength(length + 1);
        parents.forEach(parent => {
          children.forEach((current, index) => {
            if (current.parentId === parent.Id) {
              let temp = JSON.parse(JSON.stringify(children));
              temp.splice(index, 1);
              translator([current], temp);
              if (!parent.children.find(item => item.Id == current.Id))
                parent.children.push(current);
            }
          });
        });
      };
      translator(parents, list);
      return parents;
    };
    return fun2(list);
  };

  const currentNodeId = useMemo(() => {
    let Id = version.template_node_id;
    setAuditId(currentNodeId);
    return flowDetail.nodes.find?.(item => item.Id == Id)?.node_id;
  }, [flowDetail, version]);
  /**
   *
   * @param {*} currentId 当前节点
   * @param {*} type 下一个节点的类型  custom-circle: 审批节点   custom-rect: 业务节点
   * @returns
   */
  const getNextNodes = (currentId, type) => {
    const { edges, nodes } = flowDetail;
    if (!currentId) return [];
    //删除虚线通向的节点
    // let targetIds = edges
    //   .filter(edge => {
    //     let line = edge.attrs?.line?.strokeDasharray?.split(' ');
    //     return edge.source.cell == currentId && line && line[0] == '0';
    //   })
    //   .map(item => item.target.cell);
    let targetIds = edges
      .filter(edge => edge.source.cell == currentId)
      .map(item => item.target.cell);

    edges.filter(edge => edge.source.cell == currentId);
    let auditNodes = nodes.filter(node => {
      if (type && node.name != type) {
        return false;
      }
      return targetIds.indexOf(node.id) != -1;
    });
    const result = auditNodes.map(item => {
      return {
        label: item.label,
        value: item.Id,
        Id: item.node_id,
        parentId: currentId,
        children: [],
      };
    });
    return result || [];
  };

  const changeAudit = id => {
    let node = flowDetail.nodes.find?.(item => item.Id == id);
    setAuditId(node.node_id);
  };

  const onChange = value => {
    changeAudit(value[value.length - 1]);
    setAuditListFun();
  };

  const getReComputeAudit = (items, changedValues) => {
    const id = Object.keys(changedValues)[0];
    const formItem = items?.find(item => item.props.id == id);
    if (formItem && formItem.props?.required) return true;
    return false;
  };

  //填写表单实时计算审批流程
  const advanceSubmit = async () => {
    console.log('重重新计算审批流程');
    var fieldsValue = await form.validateFields();
    let hasFlowId = true; //是否都绑定审批节点

    let result = Object.values(fieldsValue)
      .map(item => {
        if (item && Array.isArray(item)) return item;
      })
      .filter(item => item);
    const formList = await getFromData(result);
    let params = {
      desc: fieldsValue.desc,
      // 审核流程id
      flow_id: 0,
      node_level_id: 0,
      id: version.id,
      project_id: version.project_id,
      cur_template_node_id: version.template_node_id * 1, // 当前节点
      next_template_node_id: 0, // 审核完成后的业务节点
      template_node_id: null, // 将要流转的节点审批节点
      flow_path: null, //审批节点数组
      // 模板id.一致就行
      template_id: version.template_id,
      cur_template_id: version.template_id,
      next_template_id: version.template_id,
      form_list: formList,
    };

    const ddd = {
      '778': [
        { type: 'user', value: 448, origin: 0 },
        { type: 'role', value: 82, origin: 0 },
        { type: 'role', value: 61, origin: 0 },
      ],
      '791': [
        { type: 'user', value: 448, origin: 0 },
        { type: 'role', value: 82, origin: 0 },
        { type: 'role', value: 61, origin: 0 },
      ],
      '792': [
        { type: 'user', value: 448, origin: 0 },
        { type: 'role', value: 82, origin: 0 },
        { type: 'role', value: 29, origin: 0 },
      ],
    };

    dispatch({
      type: 'detail/advanceSubmitNextNode',
      payload: params, //values,
      callback: data => {
        if (data) {
          setApprovalProcess(data);
        }
        console.log('=======================================', data);
      },
    });
  };

  //处理tabs页
  const setAuditListFun = async () => {
    var fieldsValue = await form.validateFields();
    let addAuditList = [];
    let result = Object.values(fieldsValue)
      .map(item => {
        if (item && Array.isArray(item)) return item;
      })
      .filter(item => item)
      .flat(Infinity);
    let nodeList = [...new Set(result)]
      .map(Id => {
        return flowDetail.nodes.find?.(item => item.Id == Id);
      })
      .filter(item => item);
    let flowIds = [...new Set(nodeList.map(item => item.flow_id))].join(',');
    let data = await queryProcessFlows({ ids: flowIds });
    if (data && data?.length > 0) {
      let newlist = nodeList.map(node => {
        let curData = data.find(item => item.id == node.flow_id);
        let newItem = {
          name: curData?.name,
          nodeId: node.Id,
          items: JSON.parse(curData.form_json),
        };
        return newItem;
      });
      addAuditList = [...addAuditList, ...newlist];
    }
    addAuditList.forEach((item, index) => {
      let Components = Form3x.create({
        onValuesChange: (props, changedValues, allValues) => {
          const { items } = props;
          formComponentValues[item.nodeId] = items
            .map(item => {
              const itemProps = item.props;
              let val = allValues[itemProps.id];
              if (!itemProps.label || val === '') return;
              if (val instanceof Object) {
                return {
                  name: itemProps.label,
                  id: itemProps.id,
                  value: [...val],
                };
              } else if (allValues[itemProps.id]) {
                return {
                  name: itemProps.label,
                  id: itemProps.id,
                  value: [allValues[itemProps.id]] || undefined,
                };
              }
            })
            .filter(item => item);
          if (getReComputeAudit(items, changedValues)) advanceSubmit();
          console.log('==================================', { ...formComponentValues });
          setFormComponentValues({ ...formComponentValues });
        },
      })(AuditDetailed);
      item.FormComponents = <Components items={item.items} />;
    });
    setAuditList(addAuditList);
  };

  const getFromData = async idList => {
    const data = formComponentValues;
    const result = [];
    //获取流转节点的层级关系
    let len = 0;
    let list = [];
    idList.forEach(item => {
      if (len < item.length) len = item.length;
    });
    for (let i = 0; i < len; i++) {
      idList.forEach(item => {
        if (item && item[i]) list.push(item[i]);
      });
    }
    let firstList = [...new Set(list)];
    // let attachment = await upload();
    firstList.forEach(id => {
      let approvalNode = flowDetail.nodes.find?.(item => item.Id == id);
      let values = data[approvalNode.Id] || [];
      const audit_list = approvalProcess[approvalNode.Id]?.map(item => {
        if (item[0].type == 'role') return item[0].nowValue;
        return item[0].value;
      });
      const formItem = {
        flow_id: approvalNode.flow_id,
        template_node_id: approvalNode.Id,
        formComponentValues: [...values], //{ name: '附件', value: JSON.stringify(attachment) }
        audit_list: audit_list || [],
      };
      result.push(JSON.stringify(formItem));
    });
    return result;
  };

  const getFlowPath = node => {
    //[134, 135]
    let itemData = {};
    const Function = (curId, index) => {
      if (!curId) return;
      let data = {};
      let approvalNode = flowDetail.nodes.find?.(item => item.Id == curId);
      data.template_id = version.template_id;
      data.flow_id = approvalNode?.flow_id || 0;
      data.node_level_id = approvalNode?.flow_id ? 1 : 0;
      data.template_node_id = approvalNode?.Id;
      index++;
      if (approvalNode?.Id) {
        if (!approvalNode?.flow_id) {
          hasFlowId = false;
        }
      }
      const res = Function(node[index], index);
      if (res) {
        data.flow_path = [res];
      }
      return data;
    };
    itemData = Function(node[0], 0);
    return itemData;
  };

  const onFinish = async () => {
    console.log(approvalProcess);
    const isOk = Object.values(approvalProcess).every(item => {
      console.log(item);
      return item.every(cur => {
        if (cur[0].type == 'role') return cur[0].nowValue;
        return true;
      });
    });
    if (!isOk) {
      message.error('请选择审批人。');
      return;
    }
    var fieldsValue = await form.validateFields();
    let hasFlowId = true; //是否都绑定审批节点
    const getFlowPath = node => {
      //[134, 135]
      let itemData = {};
      const Function = (curId, index) => {
        if (!curId) return;
        let data = {};
        let approvalNode = flowDetail.nodes.find?.(item => item.Id == curId);
        data.template_id = version.template_id;
        data.flow_id = approvalNode?.flow_id || 0;
        data.node_level_id = approvalNode?.flow_id ? 1 : 0;
        data.template_node_id = approvalNode?.Id;
        index++;
        if (approvalNode?.Id) {
          if (!approvalNode?.flow_id) {
            hasFlowId = false;
          }
        }
        const res = Function(node[index], index);
        if (res) {
          data.flow_path = [res];
        }
        return data;
      };
      itemData = Function(node[0], 0);
      return itemData;
    };
    let result = Object.values(fieldsValue)
      .map(item => {
        if (item && Array.isArray(item)) return item;
      })
      .filter(item => item);
    let serviceNode = flowDetail.nodes.find?.(item => item.Id == fieldsValue.next_template_node_id);

    if (!serviceNode) {
      message.error('请选择需要流转的业务节点。');
      return;
    }

    const flowPath = result.map(item => getFlowPath(item));
    const formList = await getFromData(result);
    let params = {
      desc: fieldsValue.desc,
      // 审核流程id
      // flow_id: approvalNode?.flow_id || 0,
      // node_level_id: approvalNode?.flow_id ? 1 : 0,

      id: version.id,
      project_id: version.project_id,
      cur_template_node_id: version.template_node_id * 1, // 当前节点
      next_template_node_id: serviceNode.Id * 1, // 审核完成后的业务节点
      // template_node_id: result[0][0], // 将要流转的节点审批节点
      // flow_path:flow_path, //审批节点数组
      // 模板id.一致就行
      template_id: version.template_id,
      cur_template_id: version.template_id,
      next_template_id: version.template_id,
    };
    if (result.length <= 0) {
      //直接走业务节点
    } else if (result.length <= 1 && result[0]?.length <= 1) {
      //单个审批节点
      let approvalNode = flowDetail.nodes.find?.(item => item.Id == result[0][0]);
      params.flow_id = approvalNode?.flow_id || 0;
      params.node_level_id = approvalNode?.flow_id ? 1 : 0;
      params.template_node_id = result[0][0]; // 将要流转的节点审批节点
      params.form_list = formList; //创建钉钉表单所需数据
      if (approvalNode?.Id) {
        if (!approvalNode?.flow_id) {
          hasFlowId = false;
        }
      }
    } else {
      //多节点审批
      params.template_node_id = result[0][0]; // 将要流转的节点审批节点
      params.flow_path = flowPath;
      params.form_list = formList; //创建钉钉表单所需数据
    }
    if (!hasFlowId) {
      message.error('当前存在审批节点未绑定审批流程!请联系管理员。');
      return;
    }
    onOk(params);
  };
  const CascaderNode = index => {
    return (
      <Form.Item
        labelCol={{ span: 7 }}
        wrapperCol={{ span: 15 }}
        label={`审批节点${index + 1}`}
        name={`circle${index}`}
        key={`circle${index}`}
      >
        <Cascader style={{ width: '100%' }} options={data} onChange={onChange} />
      </Form.Item>
    );
  };
  const upload = async () => {
    let blob = await luckysheet.current.getExcelBolb();
    let formData = new FormData();
    formData.append('userid', currentUser.DingUserId);
    formData.append('file', new File([blob], `${version.version_name}_${version.version_no}.xlsx`));

    try {
      let res = await uploadFile(formData);
      let data = JSON.parse(res.dentry);
      return [
        {
          spaceId: String(data.spaceId),
          fileName: data.name,
          fileSize: String(data.spaceId),
          fileType: data.extension,
          fileId: data.id,
        },
      ];
    } catch (error) {
      message.error('附件上传失败');
    }
  };

  return (
    <Modal
      confirmLoading={loading}
      destroyOnClose
      title="提交流转目标"
      width={1000}
      visible={visible}
      onCancel={() => {
        setAuditId();
        onClose();
      }}
      onOk={onFinish}
    >
      <Form form={form}>
        {data.map((item, idx) => (data.length == 1 ? CascaderNode('') : CascaderNode(idx)))}
        <Form.Item
          labelCol={{ span: 7 }}
          wrapperCol={{ span: 15 }}
          label="业务节点"
          name="next_template_node_id"
        >
          <Select style={{ width: '100%' }}>
            {getNextNodes(data.length < 0 ? currentNodeId : auditId, 'custom-rect').map(item => (
              <Option key={item.value}>{item.label}</Option>
            ))}
          </Select>
        </Form.Item>
        <Form.Item labelCol={{ span: 7 }} wrapperCol={{ span: 15 }} label="备注信息" name="desc">
          <Input.TextArea />
        </Form.Item>
        {/* <Form.Item labelCol={{ span: 7 }} wrapperCol={{ span: 15 }} label="授权码" name="ddCode">
          <DDCode />
          <Button onClick={upload}>上传文件</Button>
        </Form.Item> */}
      </Form>
      <Tabs defaultActiveKey="1">
        {auditList.map((item, idx) => (
          <TabPane tab={item.name} key={`${idx}_${item.title}`}>
            <Row>
              <Col span={17}>{item.FormComponents}</Col>
              <Col offset={1} span={4}>
                {!formComponentValues[item.nodeId] || !approvalProcess[item.nodeId] ? (
                  <Empty description="请先填写表单" />
                ) : (
                  <ApprovalProcess
                    id={item.nodeId}
                    approvalProcess={approvalProcess}
                    onChange={setApprovalProcess}
                  />
                )
                // <AuditFlow
                //   processCode={item.formCode}
                //   formComponentValues={formComponentValues[item.nodeId]}
                //   direction={'vertical'}
                //   deptId={'14237557'}
                //   userId={currentUser.DingUserId || getCurrentUser()?.DingUserId}
                // />
                }
              </Col>
            </Row>
          </TabPane>
        ))}
      </Tabs>
    </Modal>
  );
}

export default connect(({ xflow, detail, user }) => ({
  flowDetail: xflow.flowDetail,
  versionList: detail.versionList,
  currentUser: user.currentUser,
  userList: user.list,
}))(CommitAuditModal);