TALL-MUI-4/hooks/project/useGetTasks.js

import { computed, nextTick, watch } from 'vue';

import dayjs from 'dayjs';
import { flatten } from 'lodash';
import { useStore } from 'vuex';

export default function useGetTasks() {
  const store = useStore();
  const tasks = computed(() => store.state.task.tasks); // 当前角色显示任务
  const timeLineType = computed(() => store.state.task.timeLineType); // 时间轴模式
  const realTasks = computed(() => store.state.task.realTasks); // 当前角色真实任务
  const downNextPage = computed(() => store.state.task.downNextPage); // 当前角色下一页 - 向下
  const upNextPage = computed(() => store.state.task.upNextPage); // 当前角色下一页 - 向下
  // const currUpTimeNode = computed(() => store.state.task.currUpTimeNode); // 当前查询的时间
  // const currDownTimeNode = computed(() => store.state.task.currDownTimeNode); // 当前查询的时间
  const roleId = computed(() => store.state.role.roleId); // 当前角色id
  const timeNode = computed(() => store.state.task.timeNode); // 当前时间节点
  const timeUnit = computed(() => store.state.task.timeUnit); // 当前时间单位
  const visibleRoles = computed(() => store.state.role.visibleRoles); // 角色列表
  const allTasks = computed(() => store.state.task.allTasks); // 所有任务
  const roleIndex = computed(() => store.state.role.roleIndex); // 当前角色位置

  const projectId = computed(() => store.getters['project/projectId']);
  const timeGranularity = computed(() => store.getters['task/timeGranularity']);

  const remindData = computed(() => store.state.socket.remindData); // 小红点

  // const currRoleRealTasks = computed(() => store.state.task.currRoleRealTasks); // 当前角色的真实任务数据
  // const currRoleShowTasks = computed(() => store.state.task.currRoleShowTasks); // 当前角色的展示任务数据
  const currLocationTaskId = computed(() => store.state.socket.currLocationTaskId); // 当前定位的任务id

  const businessCode = computed(() => store.state.task.businessCode); // 服务名

  const scaleTasksStartTime = computed(() => store.state.task.scaleTasksStartTime); // 空时间刻度开始时间
  const scaleTasksEndTime = computed(() => store.state.task.scaleTasksEndTime); // 空时间刻度结束时间

  // 初始化 定期任务
  async function initPlanTasks(params) {
    // uni.$ui.showLoading();

    if (timeLineType.value === 1) setNextPlaceholderTasks();
    await getTasks(params); // 获取初始数据
  }

  /**
   * 生成getTasks所用的参数
   * @param {object} query getTasks传递的参数
   */
  function generateGetTaskParam(query) {
    return {
      roleId: roleId.value,
      timeNode: query.timeNode || timeNode.value,
      timeUnit: query.timeUnit || timeUnit.value,
      queryType: query.queryType === 0 ? 0 : 1,
      pageNum: query.pageNum || 1,
      pageSize: query.pageSize || uni.$taskConfig.pageCount,
      taskId: query.taskId || currLocationTaskId.value,
      businessCode: query.businessCode || businessCode.value,
      triggerType: query.triggerType || 1
    };
  }

  /**
   * 根据时间基准点和角色查找定期任务
   * @param {object} query
   * @param {string} query.roleId 角色id
   * @param {string} query.timeNode 时间基准点 默认当前
   * @param {string} query.timeUnit 时间颗粒度 默认天
   * @param {string} query.queryNum 查找颗粒度数量 默认3个
   * @param {number} query.queryType 0向上查找 1向下查找(默认) 下查包含自己，上查不包含
   */
  function getTasks(query) {
    uni.$ui.showLoading();
    store.commit('task/setShowSkeleton', false);

    if (businessCode.value === 'ZERO' && realTasks.value.length > 0) {
      let needTask = query.queryType === 0 ? realTasks.value[0] : realTasks.value[realTasks.value.length - 1];
      query.taskId = needTask.id;
      query.timeNode = needTask.planStart;
      query.businessCode = needTask.businessCode;
    }

    const params = generateGetTaskParam(query);
    uni.$catchReq.getTaskByNum(params, (err, data) => {
      store.commit('task/setShowSkeleton', false);
      if (err) {
        // TODO: 提示错误
        console.error('err: ', err);
      } else {
        store.commit('task/setShowScrollTo', true);

        // 存储当前查询的真实任务
        params.queryType === 0 ? store.commit('task/setUpRealTasks', data.list) : store.commit('task/setDownRealTasks', data.list);

        // 下一页
        if (data.list.length < params.pageSize) {
          params.queryType === 0 ? store.commit('task/setUpNextPage', 0) : store.commit('task/setDownNextPage', 0); // 下一页
        } else {
          params.queryType === 0 ? store.commit('task/setUpNextPage', 1) : store.commit('task/setDownNextPage', 1); // 下一页
        }

        // 将真实任务存储到allTasks中对应的角色下
        const arr = [...allTasks.value];
        arr[roleIndex.value].realTasks = [...realTasks.value];
        arr[roleIndex.value].upNextPage = upNextPage.value; // 存储下一页（向上）
        arr[roleIndex.value].downNextPage = downNextPage.value; // 存储下一页（向下）
        store.commit('task/setAllTasks', arr);

        // 数据处理
        dataRender(params);
      }
    });
  }

  function dataRender(params) {
    timeLineType.value === 1 ? renderScaleTask(params) : renderConTask(params);
  }

  // 刻度模式数据处理
  async function renderScaleTask(query) {
    const params = generateGetTaskParam(query);
    let centerData = await showTaskTime(params, tasks.value, realTasks.value) || [];
    await handleTasksData(params, centerData);
  }

  // 当前需要处理的真实任务
  async function showTaskTime(params, showTasks, realTasks) {
    /**
     * 1、初始时显示15个真实任务
     * 2、再次取值获取显示任务最后一条真实任务的id，从下一条开始查找15条，不够15条全部查询
     */

    // 初始值
    // 显示任务中没有真实任务数据
    let centerData = [];
    if (realTasks.length > params.pageSize && params.queryType === 0) {
      centerData = realTasks.slice(realTasks.length - params.pageSize); // 上且数据>15 -- 从最后取15个数据
    } else {
      centerData = realTasks.slice(0, params.pageSize); // 上且数据<15，下 -- 从开始取15个数据
    }

    const arr = showTasks.filter(item => item.detailId); // 所有的真实数据

    // 显示任务中有真实任务数据
    if (arr.length > 0) {
      realTasks.forEach((item, index) => {
        if (params.queryType === 1 && item.id === arr[arr.length - 1].id) {
          centerData = realTasks.slice(index + 1, index + 1 + params.pageSize);
        } else if (params.queryType === 0 && item.id === arr[0].id) {
          centerData = index >= params.pageSize ? realTasks.slice(index - params.pageSize, index) : realTasks.slice(0, index);
        }
      })
    }

    return centerData;
  }

  async function handleTasksData(params, centerData) {
    let oldTasks = tasks.value;

    // 符合条件的数据
    const newTasks = centerData.filter(item => dayjs(+scaleTasksStartTime.value).isBefore(+item.planStart, timeGranularity.value) && dayjs(+scaleTasksEndTime.value).isAfter(+item.planStart, timeGranularity.value))

    // 查找下一页 -- 全部数据符合条件，数据量<15，有下一页
    const isNextPage = params.queryType === 1 && downNextPage.value === 1 || params.queryType === 0 && upNextPage.value === 1;
    if (newTasks.length === centerData.length && centerData.length < params.pageSize && isNextPage) {
      if (centerData.length > 0) {
        const taskId = params.queryType === 1 ? centerData[centerData.length - 1].id : centerData[0].id;
        getTasks({taskId: taskId, queryType: params.queryType});
      } else {
        getTasks({queryType: params.queryType});
      }
    } else {
      // 用真实任务数据替换空刻度，不需要继续查找下一页
      // 1、一部分数据符合
      // 2、全部数据符合条件，
      //    2-1、数据量15 -- 需要删除多余的空数据
      //    2-2、数据量<15，但是没有下一页
      oldTasks.forEach((task, index) => {
        let arr = centerData.filter(item => dayjs(+item.planStart).isSame(+task.planStart, timeGranularity.value));
        if (arr && arr.length > 0) {
          if (task.detailId) {
            params.queryType === 1 ? [...oldTasks, ...arr] : [...arr, ...oldTasks];
          } else {
            oldTasks.splice(index, 1, [...arr]);
          }
        }
      })

      // 全部数据符合条件，数据量15，删除多余的空数据
      if (newTasks.length === centerData.length && centerData.length === params.pageSize) {
        const lastIndex = oldTasks.findIndex(item => item.id === centerData[centerData.length - 1].id);
        oldTasks.slice(0, lastIndex);
      }

      oldTasks = flatten(oldTasks); // 1维拍平

      store.commit('task/clearTasks');
      params.queryType === 0 ? store.commit('task/setUpTasks', oldTasks) : store.commit('task/setDownTasks', oldTasks);
    }

    uni.$ui.hideLoading();
  }

  // 任务模式
  async function renderConTask(params) {
    let nextPage = params.queryType === 0 ? upNextPage.value : downNextPage.value; // 下一页的值
    let showTasks = tasks.value;
    let centerData = await showTaskTime(params, showTasks, realTasks.value) || [];

    if (centerData.length < 15 && nextPage > 0) {
      getTasks({pageNum: nextPage, queryType: params.queryType});
    } else {
      if (params.queryType === 0) {
        showTasks = [...centerData, ...showTasks];
      } else {
        showTasks = [...showTasks, ...centerData];
      }
    }

    if (showTasks.length < 15 && nextPage === 0 && params.queryType === 1) {
      getTasks({pageNum: 1, queryType: 0});
    }

    // if (showTasks.length > 80) {
    //   showTasks = params.queryType === 0 ? showTasks.slice(0, 80) : showTasks.slice(showTasks.length - 80);
    // }

    store.commit('task/clearTasks');
    params.queryType === 0 ? store.commit('task/setUpTasks', showTasks) : store.commit('task/setDownTasks', showTasks);
  }

  // 设置时间轴向上的空数据
  function setPrevPlaceholderTasks() {
    // store.commit('task/setTopEnd', true);
    let startTime = '';
    if (!tasks.value || !tasks.value.length) {
      startTime = Date.now(); // 没有任务就应该是时间基准点
    } else {
      startTime = tasks.value[0].planStart - 0; // 有任务就是第一个任务的计划开始时间
    }
    const placeholderTasks = uni.$task.setPlaceholderTasks(startTime, true, timeGranularity.value);
    store.commit('task/setScaleTasksStartTime', placeholderTasks[0].planStart);
    store.commit('task/setScaleTasksEndTime', placeholderTasks[placeholderTasks.length - 1].planStart);
    // store.commit('task/setCurrUpTimeNode', startTime);
    store.commit('task/setUpTasks', placeholderTasks);
  }

  // 设置时间轴向下的空数据
  function setNextPlaceholderTasks() {
    let startTime = '';
    if (!tasks.value || !tasks.value.length) {
      startTime = Date.now();
    } else {
      startTime = dayjs(+tasks.value[tasks.value.length - 1].planStart).add(1, timeGranularity.value).valueOf();
    }

    const initData = uni.$task.setPlaceholderTasks(startTime, false, timeGranularity.value);

    store.commit('task/setScaleTasksStartTime', initData[0].planStart);
    store.commit('task/setScaleTasksEndTime', initData[initData.length - 1].planStart);
    // store.commit('task/setCurrDownTimeNode', startTime);
    store.commit('task/setDownTasks', initData);
  }

  /**
   * 当日常任务发生变化时
   * 将新获取到的日常任务放在allTasks里
   */
  watch(tasks, () => {
    // 添加到allTasks里
    const index = visibleRoles.value.findIndex(role => role.id === roleId.value);
    const arr = [...allTasks.value];
    if (arr.length && index > -1) {
      if (remindData.value) {
        tasks.value.forEach(task => {
          task.remindNum = 0;
          task.msgId = '';

          if (task.plugins && task.plugins.length) {
            task.plugins.forEach(pluginArr => {
              pluginArr.forEach(plugin => {
                plugin.remindNum = 0;
                remindData.value.forEach(remind => {
                  const remind_data = JSON.parse(remind.data);

                  if (projectId.value === remind_data.data.projectId && roleId.value === remind_data.data.roleId) {
                    if (remind_data.data.taskId === task.id) {
                      task.remindNum++;
                      task.msgId = remind.id;
                    }

                    if (remind_data.data.taskId === task.id && remind_data.data.pluginId === plugin.pluginTaskId) {
                      plugin.remindNum++;
                    }
                  }
                });
              });
            });
          }
        })
      }

      arr[index].task = [...tasks.value];
      // store.commit('task/setCurrRoleShowTasks', arr[index].task); // 设置当前角色的展示任务数据
    }
    store.commit('task/setAllTasks', arr);
  });

  return {
    initPlanTasks,
    getTasks,
    dataRender,
    setPrevPlaceholderTasks,
    setNextPlaceholderTasks
  }
}