yudao-init/src/store/modules/home.js

import axios from "@/utils/request";
import { deepClone } from "../../utils";

/* 状态 */
const state = {
  copilot: {
    /* 产量驾驶舱 */
    yield: {
      ftoInvest: null,
      chipInvest: null,
      chipOutput: null,
      stdOutput: null,
      bipvOutput: null,
    },
    /* 能源驾驶舱 */
    energy: {
      stockDOData: [],
      waterList: {},
      gasList: [],
      elecList:{}
    },
    /* 效率驾驶舱 */
    efficiency: {
      chipOee: {
        current: [],
        previous: [],
        target:[]
      },
      transformRate: {
        current: [],
        previous: [],
        target:[]
      },
      chipRate: {
        target: [],
        current: [],
        previous: [],
        outputNumber:[],
      },
      stdRate: {
        target: [],
        current: [],
        previous: [],
        outputNumber:[]
      },
    },
  },
  home: {
    /** 主页状态 */
    ftoInvest: null,
    chipInvest: null,
    chipOutput: null,
    stdOutput: null,
    bipvOutput: null,
  },
};

const mutations = {
  SET_HOME_INFO: (state, payload) => {
    state.home.ftoInvest = payload.ftoInvest;
    state.home.chipInvest = payload.chipInvest;
    state.home.chipOutput = payload.chipOutput;
    state.home.stdOutput = payload.stdOutput;
    state.home.bipvOutput = payload.bipvOutput;
  },
  SET_COPILOT_INFO: (state, { type, payload }) => {
    switch (type) {
      case "yield":
        state.copilot.yield.ftoInvest = payload.ftoInvest;
        state.copilot.yield.chipInvest = payload.chipInvest;
        state.copilot.yield.chipOutput = payload.chipOutput;
        state.copilot.yield.stdOutput = payload.stdOutput;
        state.copilot.yield.bipvOutput = payload.bipvOutput;
        break;
      case "energy":
        state.copilot.energy.stockDOData = payload.stockDOData;
        state.copilot.energy.gasList = payload.gasList;
        state.copilot.energy.waterList = payload.waterList;
        state.copilot.energy.elecList = payload.elecList;
        break;
      case "efficiency":
        state.copilot.efficiency.chipOeeRate = payload.chipOeeRate;
        state.copilot.efficiency.transformRate = payload.transformRate;
        state.copilot.efficiency.chipRate = payload.chipRate;
        state.copilot.efficiency.stdRate = payload.stdRate;
        break;
    }
  },
};

const actions = {
  /** 初始化首页数据 */
  async initHome({ commit }) {
    const dataArr = await getHomeInfo();
    console.log('dataArr', dataArr);
      let preData = dataArr.previousProdOutputOutDO
      let preFtoData = dataArr.previousProdOutputFtoDO
    // const targetArr = await getHomeInfo();
    // factoryListResponse, targetListResponse, prodOutputFtoListRes,preData,preFtoData
    const payload = splitCurrentAndPrevious(dataArr.prodOutputOutDO, dataArr.prodTargetOutputDO,dataArr.prodOutputFtoDO,preData,preFtoData);
    commit("SET_HOME_INFO", payload);
  },
  /** 初始化驾驶舱数据 */
  async initCopilot({ commit }, { period,source,than}) {
    // if (source == "energy") return;

    const fetcher = {
      yield: getCopilotYield,
      energy: getCopilotEnergy,
      efficiency: getCopilotEfficiency,
    }[source];
    const handler = {
      yield: splitCurrentAndPrevious,
      energy: splitCurrentAndPreviousB,
      efficiency: splitCurrentAndPreviousA,
    }[source]
    // 获取产量数据
    let { data: factoryList, type } = await fetcher(period,than)
    // let targetList = null;
    // if (source === "yield" || source === "efficiency") {
    //   // 获取目标数据
    //   let { data } = await fetcher(period,than, true)
    //   targetList = data
    // }
    // if (source == "energy") {
    //   let factoryData = factoryList
    //   const payload = handler(factoryData)
    //   commit("SET_COPILOT_INFO", { type, payload });
    // } else {
      console.log('factoryList',factoryList)
      let factoryData = factoryList.prodOutputOutDO ? factoryList.prodOutputOutDO : factoryList.prodOutputRateDO
      let preData = factoryList.previousProdOutputOutDO ? factoryList.previousProdOutputOutDO : factoryList.previousProdOutputRateDO
      let preFtoData = factoryList.previousProdOutputFtoDO ? factoryList.previousProdOutputFtoDO : []
      let prodOutputFtoDO = factoryList.prodOutputFtoDO ? factoryList.prodOutputFtoDO : []
      let targetData = factoryList.prodTargetOutputDO ? factoryList.prodTargetOutputDO : factoryList.prodTargetRateDO
      const payload = handler(factoryData,targetData,prodOutputFtoDO,preData,preFtoData)
    commit("SET_COPILOT_INFO", { type, payload });

    // }

  },
};

export default {
  namespaced: true,
  state,
  mutations,
  actions,
};

function splitCurrentAndPreviousB(factoryListResponse) {
 let  factoryArr = [
        {
          id: 0,
          name: '瑞昌中建材光电材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 1,
          name: '邯郸中建材光电材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 2,
          name: '中建材株洲光电材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 3,
          name: '佳木斯中建材光电材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 4,
          name: '成都中建材光电材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 5,
          name: '凯盛光伏材料有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
        {
          id: 6,
          name: '蚌埠兴科玻璃有限公司',
          stockData: [],
          waterData: [],
          elsData: [],
          gasData: [],
        },
      ]
  if (factoryListResponse) {
       for (let i in factoryListResponse.stockDO) {
        const index = factoryArr.findIndex(item => item.id == factoryListResponse.stockDO[i].factory)
        if (index != -1) {
          factoryListResponse.stockDO[i].stockInfo.forEach(ele => {
            factoryArr[index].stockData.push(ele)
          });
        }

       }
      let stockDOData = []
    factoryArr.forEach((ele, index) => [
      stockDOData[index] = [],
      ele.stockData.forEach((item) => {
        let obj = {}
        obj.name = item.glassType == 0 ? '玻璃芯片' : item.glassType == 1 ? '标准组件' : item.glassType == 2 ? 'BIPV' : '定制组件'
        obj.value = item.stockNumber
        stockDOData[index].push(obj)
      }),
    ])
     let gasList = []
    // if (factoryListResponse.gasDO) {
       factoryListResponse.gasDO.forEach((ele) => {
      gasList[ele.factory] = ele.totalEnergyValue
    })
    // }

    // console.log(factoryListResponse.gasDO);
    let waterObj = Object.groupBy(factoryListResponse.waterDO, ({ groupName }) => groupName)
    let waterList = {
      times: [],
      0: [],
      1: [],
      2: [],
      3: [],
      4: [],
      5: [],
      6: [],
    }
    for (let i in waterObj) {
      waterList.times.push(i)
      waterObj[i].forEach((ele, index) => {
        waterList[ele.factory].push(ele.totalEnergyValue)
      })
    }
     let elecObj = Object.groupBy(factoryListResponse.elecDO, ({ groupName }) => groupName)
    let elecList = {
      times: [],
      0: [],
      1: [],
      2: [],
      3: [],
      4: [],
      5: [],
      6: [],
    }
    for (let i in elecObj) {
      elecList.times.push(i)
      elecObj[i].forEach((ele, index) => {
        elecList[ele.factory].push(ele.totalEnergyValue)
      })
    }

    return {
      stockDOData,
      waterList,
      gasList,
      elecList,
    };
  } else {
    let stockDOData = Array[7].fill([])
    let waterList = {}
    return {
      stockDOData,
      waterList,
      gasList,
      elecList
    };
  }
}

function splitCurrentAndPreviousA(factoryListResponse, targetListResponse, prodOutputFtoListRes,preData,preFtoData) {
  console.log('工厂',targetListResponse);

  // 初始数据
  const { chipOeeRate, transformRate, chipRate, stdRate } = initA();
  // factoryListResponse = [
  //   {
  //     factory: 0,
  //     oee: 0.8,
  //     previousYearOee: 0.7,
  //     componentConversionEfficiency: 0.8,
  //     previousYearComponentConversionEfficiency: 0.7,
  //     glassType: 0,
  //     yieldRate: 0.8,
  //     previousYearYieldRate: 0.7,
  //     chipYieldRate: 0.38,
  //     componentYieldRate: 0.73,
  //   },
  //   {
  //     factory: 1,
  //     oee: 0.8,
  //     previousYearOee: 0.7,
  //     componentConversionEfficiency: 0.8,
  //     previousYearComponentConversionEfficiency: 0.7,
  //     glassType: 1,
  //     yieldRate: 0.8,
  //     previousYearYieldRate: 0.7,
  //     chipYieldRate: 0.38,
  //     componentYieldRate: 0.73,
  //   },
  //   {
  //     factory: 2,
  //     oee: 0.8,
  //     previousYearOee: 0.7,
  //     componentConversionEfficiency: 0.8,
  //     previousYearComponentConversionEfficiency: 0.7,
  //     glassType: 1,
  //     yieldRate: 0.8,
  //     previousYearYieldRate: 0.7,
  //     chipYieldRate: 0.38,
  //     componentYieldRate: 0.73,
  //   },
  //   {
  //     factory: 3,
  //     oee: 0.8,
  //     previousYearOee: 0.7,
  //     componentConversionEfficiency: 0.8,
  //     previousYearComponentConversionEfficiency: 0.7,
  //     glassType: 0,
  //     yieldRate: 0.8,
  //     previousYearYieldRate: 0.7,
  //     chipYieldRate: 0.38,
  //     componentYieldRate: 0.73,
  //   },
  // ];
  if (preData && preData[0] != null) {
    for (const factory of preData) {
      const fId = getPreFactoryId(factory);
        //  chipInvest.previous[fId] = factory.previousYearInputNumber;
      // chipOeeRate.current[fId] = factory.oee;
      chipOeeRate.previous[fId] = factory.previousYearOee;
      // 转化效率
      transformRate.previous[fId] =factory.previousYearComponentConversionEfficiency ;
      // 芯片良率 与 标准组件良率
      if (![0, 1].includes(factory.glassType)) continue;
      const _t = [chipRate, stdRate][factory.glassType]
      // _t.current[fId] = factory.yieldRate ;
      _t.previous[fId] = factory.previousYearYieldRate ;
      // }
      // debugger;
    }
  }
  if (factoryListResponse) {
    for (const factory of factoryListResponse) {
      const fId = getFactoryId(factory);
      // 获取目标值
      if (targetListResponse) {
        const {
          chipYieldRate,
          componentYieldRate,
          chipOee,
          componentConversionEfficiency,
          componentYield
        } = getFactoryTargetValueA(targetListResponse, fId)
        stdRate.target[fId] =  componentYieldRate
        chipRate.target[fId] = chipYieldRate
        chipOeeRate.target[fId] = chipOee
        transformRate.target[fId] = componentConversionEfficiency
      }
      // 芯片OEE
      chipOeeRate.current[fId] = factory.oee;
      // chipOeeRate.previous[fId] = factory.previousYearOee;
      // 转化效率
      transformRate.current[fId] = factory.componentConversionEfficiency;
      // transformRate.previous[fId] = factory.previousYearComponentConversionEfficiency ;
      // 芯片良率 与 标准组件良率
      if (![0, 1].includes(factory.glassType)) continue;
      const _t = [chipRate, stdRate][factory.glassType]
      _t.current[fId] = factory.yieldRate ;
      // _t.previous[fId] = factory.previousYearYieldRate ;
    }
    // console.log('chipOeeRate',chipOeeRate);
    return {
      chipOeeRate,
      transformRate,
      chipRate,
      stdRate,
    };
  }
}

function splitCurrentAndPrevious(factoryListResponse, targetListResponse, prodOutputFtoListRes,preData,preFtoData) {
  console.log('prodOutputFtoListRes',preFtoData);
  // 初始数据
  const { chipInvest, ftoInvest, chipOutput, stdOutput, bipvOutput } = init()
   if (prodOutputFtoListRes) {
    for (const factory of prodOutputFtoListRes) {
      console.log(factory);
      const fId = getFactoryId(factory);
      // const preFId = getPreFactoryId(factory);
      // if (fId) {
      ftoInvest.current[fId] = factory.chipInput;
      // }
      // if (preFId) {
      // ftoInvest.previous[fId] = factory.previousYearChipInput;
      // }
    }
   }
   if (preFtoData) {
    for (const factory of preFtoData) {
      console.log(factory);
      const fId = getPreFactoryId(factory);
      // const preFId = getPreFactoryId(factory);
      // if (fId) {
      ftoInvest.previous[fId] = factory.previousYearChipInput;
      // }
      // if (preFId) {
      // ftoInvest.previous[fId] = factory.previousYearChipInput;
      // }
    }
   }
    if (preData && preData[0] != null) {
    for (const factory of preData) {
      const fId = getPreFactoryId(factory);
         chipInvest.previous[fId] = factory.previousYearInputNumber;
      if (![0, 1, 2].includes(factory.previousGlassType)) continue;
      const _t = [chipOutput, stdOutput, bipvOutput][factory.previousGlassType];
      // if (fId) {
        // _t.current[fId] = factory.outputNumber;
      // }
      // if (preFId) {
          _t.previous[fId] = factory.previousYearOutputNumber
      // }
      // debugger;
    }
  }
    // console.log('ftoInvest',ftoInvest)
  if (factoryListResponse && factoryListResponse[0] != null) {
    for (const factory of factoryListResponse) {
      const fId = getFactoryId(factory);
      // const preFId = getPreFactoryId(factory);

      // 获取目标值
      if (targetListResponse) {
        const { chipYield, componentYield, bipvProductOutput } =
          getFactoryTargetValue(targetListResponse, fId);
        chipOutput.target[fId] = chipYield;
        stdOutput.target[fId] = componentYield;
        bipvOutput.target[fId] = bipvProductOutput;
      }
      // 芯片投入
          chipInvest.current[fId] = factory.inputNumber;

      // 产出数据, 0 - （玻璃）芯片产出， 1 - 标准组件产出， 2 - BIPV产出
      // 因为后端写的垃圾数据，所以这里要做一下判断
      if (![0, 1, 2].includes(factory.glassType)) continue;
      const _t = [chipOutput, stdOutput, bipvOutput][factory.glassType];
        _t.current[fId] = factory.outputNumber;
    }
    return {
      chipInvest,
      // ftoInvest,
      ftoInvest,
      chipOutput,
      stdOutput,
      bipvOutput,
    };
  }else{
      return {
      chipInvest,
      // ftoInvest,
      ftoInvest,
      chipOutput,
      stdOutput,
      bipvOutput,
    }
  }
}

function getFactoryId(factory) {
  return factory.factory;
}
function getPreFactoryId(factory) {
  return factory.previousFactory;
}

function getFactoryTargetValue(targetList, factoryId) {
  const target = targetList.find((item) => item.factory === factoryId);
  if (target) {
    return {
      // 自带模拟数据了.... random_default
      chipYield: target.chipYield ?? 0,
      componentYield: target.componentYield ?? 0,
      bipvProductOutput: target.bipvProductOutput ?? 0,
    };
  }
  return {
    chipYield: 0,
    componentYield: 0,
    bipvProductOutput: 0,
  };
}

/**
 * 获取 芯片良率目标值 和 标准组件良率目标值
 * @param {*} targetList 目标值列表
 * @param {*} factoryId 工厂ID
 * @returns
 */
function getFactoryTargetValueA(targetList, factoryId) {
  const target = targetList.find((item) => item.factory === factoryId)
  if (target) {
    return {
      chipYieldRate: target.chipYieldRate ?? 0,
      componentYieldRate: target.componentYieldRate ?? 0,
      componentYield: target.componentYield ?? 0,
      // componentYield: target.componentYield ?? 0,
      chipOee: target.chipOee ?? 0,
    };
  }
  return {
    chipYieldRate:0,
    componentYieldRate:0,
    componentYield: 0,
    chipOee:0,
  };
}

/**
 *
 * @returns 初始化 效率模块里 初始状态值
 */
function initA() {
  const t_ = {
    current: Array(7).fill(0),
    previous: Array(7).fill(0),
  };
  // 芯片OEE
  // 转化效率
  // 标准组件良率
  const stdRate = {
    ...deepClone(t_),
    target: Array(7).fill(0),
  };
  // 芯片良率
  const transformRate = deepClone(stdRate);
  const chipRate = deepClone(stdRate);
  const chipOeeRate = deepClone(stdRate);
  return {
    chipOeeRate,
    transformRate,
    chipRate,
    stdRate,
  };
}

/**
 *
 * @returns 初始化 产量模块里 初始状态值
 */
function init() {
  const t_ = {
    current: Array(7).fill(0),
    previous: Array(7).fill(0),
  };
  // 芯片投入
  const chipInvest = deepClone(t_);
  // FTO投入
  const ftoInvest = deepClone(t_);
  // 芯片产出
  const chipOutput = {
    ...deepClone(t_),
    target: Array(7).fill(0),
  };
  // 标准组件产出
  const stdOutput = deepClone(chipOutput);
  // BIPV产出
  const bipvOutput = deepClone(chipOutput);

  return {
    chipInvest, // 芯片投入
    ftoInvest, // FTO投入
    chipOutput, // 芯片产出
    stdOutput, // 标准组件产出
    bipvOutput, // BIPV产出
  };
}

function random_default(min = 0, max = 1) {
  // return 0;
  let a = Math.floor(Math.random() * max);
  while (a < min) {
    a = Math.floor(Math.random() * max);
  }
  return a;
}

/* 接口 */
async function getHomeInfo() {
  const { code, data } = await axios.post("ip/prod-output/cockpitData", {
    factorys: [],
    date: 4,
    mode:0
  });
  if (code == 0) {
    return data;
  }
  console.warn("getHomeInfo failed, code: ", code);
  return null;
}

async function getHomeTarget() {
  const { code, data } = await axios.post("/ip/prod-target/query-by-date", {
    factorys: [],
    date: 4,
  });
  if (code == 0) {
    return data;
  }
  console.warn("getHomeTarget failed, code: ", code);
  return null;
}

function getUrl(copilot_module) {
  let url = {
    // 对比数据的 URL
    comparison: "",
    // 目标数据的 URL
    // target: "",
  };
  switch (copilot_module) {
    case "yield":
      url.comparison = "ip/prod-output/cockpitData";
      // url.target = "/ip/prod-target/query-by-date";
      break;
    case "energy":
       url.comparison = "ip/prod-output/cockpitComprehensiveDataMonitor";
      break;
    case "efficiency":
      url.comparison = "ip/prod-output/cockpitDataRate";
      // url.target = "/ip/prod-target/query-rate-target";
      break;
  }

  return url;
}

async function doFetch(copilot_module = "yield", fetch_target, params) {
  const url = getUrl(copilot_module);
  const { code, data } = await axios.post(
    url.comparison,
    {
      ...params,
    }
  );
  if (code == 0) {
    return data;
  }
  console.warn("[doFetch] failed, code: ", code);
  return null;
}

/**
 *
 * @param {*} period 日周月年1,2,3,4
 * @param {*} target 是否获取目标数据
 * @returns
 */
function getCopilotYield(period,than,target = false) {
  return getCopilotData("yield", period,than, target);
}

function getCopilotEnergy(period, target = false) {
  return getCopilotData("energy", period,than, target);
}

function getCopilotEfficiency(period,than, target = false) {
  return getCopilotData("efficiency", period,than, target);
}

/**
 *
 * @param {*} period 周期： 日周月年
 * @param {*} target 是否获取目标数据：默认 否
 * @returns
 */
async function getCopilotData(copilot_module, period,than, target = false) {
  if (!copilot_module) copilot_module = "yield";
  // 请求参数，直接一次性获取所有工厂
  let queryParams = {
    factorys: [],
    date: 4,
    mode:0
  };

  switch (period) {
    case "日":
      queryParams.date = 1;
      break;
    case "周":
      queryParams.date = 2;
      break;
    case "月":
      queryParams.date = 3;
      break;
    case "年":
      queryParams.date = 4;
      break;
    default:
      queryParams.date = 1;
      break;
  }
 switch (than) {
    case "同比":
      queryParams.mode = 0;
      break;
    case "环比":
      queryParams.mode = 1;
      break;
  }
  return {
    data: await doFetch(copilot_module, target ? true : false, queryParams),
    type: copilot_module,
  };
}