w-vue-middle/jobDiffComparison/jobComparison/components/config.js

统一公共服务组件

/**
 * @Author: y_zp
 * @description: 获取配置的jsonDetail内容
 */
export function getConfigureData(job) {
  if (job.graph) {
    return {
      ver: "2.02",
      //节点内容
      steps: job.graph.getNodes().map((node) => {
        let info = node.toJSON();
        info.component = undefined;
        info.ports.groups = undefined;
        info.data.data = undefined;
        return info;
      }),
      //连线关系
      hops: job.graph.getEdges().map((edge) => {
        let info = edge.toJSON();
        return info;
      }),
    };
  }
}

/**
 * @Author: y_zp
 * @description: 对比检测
 */
export function getCheckList(resultJob, referJob) {

  let checkList = [];
  let idList = [];

  //对比所有的转换
  resultJob.nodeList.forEach(item => {
    let itemVal = referJob.nodeList.find(v => {
      return v.id == item.id;
    });
    if(itemVal) {
      let checkData = transformNodeCheck(item, itemVal);
      checkList.push({
        resultTransform: { ...item },
        referTransform: { ...itemVal },
        checkData: checkData
      })
      idList.push(item.id);
    } else {
      let checkData = transformNodeCheck(item, {});
      checkList.push({
        resultTransform: { ...item },
        referTransform: {},
        checkData: checkData
      })
    }
  });

  referJob.nodeList.forEach(item => {
    let index = idList.findIndex(v => { return v == item.id });
    if(index == -1) {
      checkList.push({
        resultTransform: {},
        referTransform: { ...item },
        checkData: {}
      })
    }
  })
  console.log("checkList", checkList)
  // 对比作业，如果转换节点不一致，也标记
  jobNodeCheck(resultJob, referJob, checkList);

  return checkList;
}

/**
 * @Author: y_zp
 * @description: 作业节点对比
 */

export function jobNodeCheck(resultData, referData, checkList) {
  let { resultJsonDetail, referJsonDetail, sameNodeList } = getSameNode(resultData, referData);
  resultJsonDetail.steps.forEach(item => {
    let coll = resultData.graph.getCellById(item.id);
    if(coll) {
      let diffData = checkList.find(v => {
        return v.resultTransform.data && v.resultTransform.data.id == (item.data.jobId || item.data.srefId)
      });
      coll.updateData({
        ...item.data,
        status: (diffData && diffData.checkData.allNum > 0) || sameNodeList.indexOf(item.id) == -1 ? "diffMore" : ""
      });
    }
  });
  referJsonDetail.steps.forEach(item => {
    let coll = referData.graph.getCellById(item.id);
    if(coll) {
      let diffData = checkList.find(v => {
        return v.referTransform.data && v.referTransform.data.id == (item.data.jobId || item.data.srefId)
      });
      coll.updateData({
        ...item.data,
        status: (diffData && diffData.checkData.allNum > 0) || sameNodeList.indexOf(item.id) == -1 ? "diffLess" : ""
      });
    }
  });
}

/**
 * @Author: y_zp
 * @description: 转换节点对比
 */
export function transformNodeCheck(resultData, referData) {
  // 如果没有对应的转换
  if(!referData.id) {
    let resultJsonDetail = getConfigureData(resultData);
    resultJsonDetail.steps.forEach(item => {
      let coll = resultData.graph.getCellById(item.id);
      coll.updateData({
        ...item.data,
        status: "diffLess"
      });
    })
    return {};
  }
  let { resultJsonDetail, referJsonDetail, sameNodeList } = getSameNode(resultData, referData);
  let metaRecord = {
    num: 0,
    list: [],
    referList: [],
  };
  let whereRecord = {
    num: 0,
    list: [],
    referList: [],
  };
  let mapRecord = {
    num: 0,
    list: [],
    referList: []
  };
  let joinRecord = {
    num: 0,
    list: [],
    referList: []
  };
  let scriptRecord = {
    num: 0,
    list: [],
    referList: []
  };
  resultJsonDetail.steps.forEach(item => {
    let index = sameNodeList.indexOf(item.id);
    if(index == -1) {
      if(item.data.type == "TableInput") {
        metaRecord.num++;
        metaRecord.list.push({ ...item });

        whereRecord.num++;
        whereRecord.list.push({ ...item });
      } else if (item.data.type == "TableOutput"){
        metaRecord.num++;
        metaRecord.list.push({ ...item });

        mapRecord.num = item.data.mapping.length;
        mapRecord.list.push({ ...item });
      } else if(item.data.type == "TableJoin") {
        joinRecord.num = item.data.joins.length;
        joinRecord.list.push({ ...item })
      } else if(item.data.type == "SqlInput") {
        scriptRecord.num++;
        scriptRecord.list.push({ ...item })
      }

      let coll = resultData.graph.getCellById(item.id);
      coll.updateData({
        ...item.data,
        status: "diffLess"
      });
    } else {
      // 对比数据源、where条件、映射、关联
      let isDiff = false;
      let referNodeData = referJsonDetail.steps.find(v => { return v.data.id == item.data.id });

      //对比数据源, 字段对比
      const testDB = (data1, data2) => {
        let dbTest = data1.dbId == data2.dbId
        && data1.schemaId == data2.schemaId
        && data1.tableCode == data2.tableCode
        && data1.asName == data2.asName;

        let num = 0;
        let columnTest = true;
        if(data1.columns.length != data2.columns.length) {
          columnTest = false;
        } else {
          data1.columns.forEach(itemA => {
            let index = data2.columns.findIndex(itemB => {
              return columnDataTest(itemA, itemB)
            })
            if(index > -1) {
              num++;
            }
          })
          if(num != data1.columns.length) {
            columnTest = false;
          }
        }
        if(dbTest && columnTest) {
          return true;
        }
        return false;
      }
      //对比where条件
      const testWhere = (data1, data2) => {
        if(data1.whereString && data2.whereString && data1.whereString == data2.whereString) {
          return true;
        } else if (!data1.whereString && !data2.whereString) {
          return true;
        } else {
          return false;
        }
      }
      //对比映射
      const testMapping = (data1, data2) => {
        let num = 0;
        data1.mapping.forEach(itemA => {
          let index = data2.mapping.findIndex(itemB => {
            return mappingDataTest(itemA, itemB)
          })
          if(index > -1) {
            num++;
          }
        });
        return Math.max(data1.mapping.length - num, data2.mapping.length - num);
      }
      //对比关联条件
      const testJoin = (data1, data2) => {
        let num = 0;
        data1.joins.forEach(itemA => {
          let index = data2.joins.findIndex(itemB => {
            return joinDataTest(itemA, itemB);
          })
          if(index > -1) {
            num++;
          }
        });
        return Math.max(data1.joins.length - num,  data2.joins.length - num);
      }
      // sql脚本对比
      const testScript = (data1, data2) => {
        if(data1.script && data2.script && data1.script == data2.script) {
          return true;
        } else if (!data1.script && !data2.script) {
          return true;
        } else {
          return false;
        }
      }
      
      if(item.data.type == "TableInput") {
        let val = testDB(item.data, referNodeData.data);
        if(!val) {
          metaRecord.num++;
          metaRecord.list.push({ ...item });
          metaRecord.referList.push({ ...referNodeData });
        }
        let wVal = testWhere(item.data, referNodeData.data);
        if(!wVal) {
          whereRecord.num++;
          whereRecord.list.push({ ...item });
          whereRecord.referList.push({ ...referNodeData });
        }
        isDiff = !val || !wVal;
      } else if(item.data.type == "TableJoin") {
        joinRecord.num = testJoin(item.data, referNodeData.data);
        if(joinRecord.num > 0) {
          joinRecord.list.push({ ...item });
          joinRecord.referList.push({ ...referNodeData });
          isDiff = true;
        }
      } else if(item.data.type == "TableOutput") {
        mapRecord.num = testMapping(item.data, referNodeData.data);
        if (mapRecord.num > 0) {
          mapRecord.list.push({ ...item });
          mapRecord.referList.push({ ...referNodeData });
        }
        let val = testDB(item.data, referNodeData.data);
        if(!val) {
          metaRecord.num++;
          metaRecord.list.push({ ...item });
          metaRecord.referList.push({ ...referNodeData });
        }
        isDiff = mapRecord.num > 0 || !val;
      } else if(item.data.type == "SqlInput") {
        let sVal = testScript(item.data, referNodeData.data);
        if(!sVal) {
          scriptRecord.num++;
          scriptRecord.list.push({ ...item });
          scriptRecord.referList.push({ ...referNodeData });
        }
        isDiff = !sVal;
      }
      
      let coll = resultData.graph.getCellById(item.id);
      coll.updateData({
        ...item.data,
        status: isDiff ? "diffLess" : ""
      });
    }
  })

  return {
    allNum: metaRecord.num + whereRecord.num + mapRecord.num + joinRecord.num + scriptRecord.num,
    metaRecord,
    whereRecord,
    mapRecord,
    joinRecord,
    scriptRecord
  }
}

function columnDataTest(itemA, itemB) {
  let val = itemA.columnName.toLocaleLowerCase() == itemB.columnName.toLocaleLowerCase()
    && itemA.pk == itemB.pk
    && itemA.columnType == itemB.columnType
    && itemA.columnSize == itemB.columnSize
  return val;
}

function mappingDataTest(itemA, itemB) {
  let val = itemA.target.columnName.toLocaleLowerCase() == itemB.target.columnName.toLocaleLowerCase()
    && itemA.target.pk == itemB.target.pk
    && itemA.target.columnType == itemB.target.columnType
    && itemA.target.columnSize == itemB.target.columnSize
    && itemA.source.columnName == itemB.source.columnName
    && itemA.source.columnType == itemB.source.columnType
    && itemA.source.columnSize == itemB.source.columnSize
  return val;
}

function joinDataTest(itemA, itemB) {
  const getStrJoin = (item) => {
    let conditionList = item.conditions.map(v => {
      if(v.type == "sql") {
        return {
          type: v.type,
          script: v.script,
        }
      } else if(v.type == "where") {
        return {
          type: v.type,
          right: {
            column: {
              columnName: right.column.columnName
            }
          }
        }
      } else {
        return {
          leftmap: v.leftmap,
          rightmap: v.rightmap,
          relation: v.relation,
        }
      }
    })
    return JSON.stringify({
      joinType: item.joinType,
      right: {
        asName: item.right.asName,
        tableCode: item.right.tableCode,
      },
      conditions: conditionList
    })
  }
  return getStrJoin(itemA) == getStrJoin(itemB);
}

/**
 * @Author: y_zp
 * @description: 获取相同的节点
 */
function getSameNode(resultData, referData) {
  //获取画布上最新的节点信息
  let resultJsonDetail = getConfigureData(resultData);
  let referJsonDetail = JSON.parse(referData.data.jsonDetail);
  // 对比节点的name，id，jobId(转换的id)
  let sameNodeList = resultJsonDetail.steps.filter(item => {
    let index = referJsonDetail.steps.findIndex(v => {
      return v.data.id == item.data.id && v.data.name == item.data.name && v.data.jobId == item.data.jobId
    })
    return index > -1
  });
  return {
    resultJsonDetail,
    referJsonDetail,
    sameNodeList: sameNodeList.map(v => { return v.data.id })
  }
}