sl-sfy-safety/src/views/dashboard/monitor/use-method.ts

import { ref } from 'vue';
import {
  sceneListType,
  getListWorkshop,
  workspaceAddDatas,
  labelModuleListType,
} from '@/api/scene/sceneOperate';
import { workShopTempleteType } from '@/api/scene/secene-templet';

export const colomns = [
  { label: '场景名称', prop: 'name', width: 300 },
  { label: '场景标签', prop: 'labelName', width: 300 },
  { label: '代码', prop: 'code' },
];

interface DataSourceUser
  extends sceneListType<
    getListWorkshop<workspaceAddDatas, workShopTempleteType>,
    labelModuleListType
  > {
  parent?: sceneListType<
    getListWorkshop<workspaceAddDatas, workShopTempleteType>,
    labelModuleListType
  > | null;
}

export const dataSourceWithParent = (d: DataSourceUser[], parent: DataSourceUser | null) => {
  d.forEach((item, _index) => {
    item.parent = parent;

    if (item.children && item.children?.length > 0) {
      dataSourceWithParent(item.children, item);
    }
  });

  return d;
};

export function removeParent(data) {
  return data.map((item) => {
    // 删除 tag 属性
    delete item.parent;

    // 递归处理子项
    if (item.children && item.children.length > 0) {
      item.children = removeParent(item.children);
    }

    return item;
  });
}

//找到各个层级
export function findIndexByItem(data, targetItem, path = []) {
  for (let i = 0; i < data.length; i++) {
    const currentPath = path.concat(i);
    if (data[i].id === targetItem.id && data[i].name === targetItem.name) {
      return currentPath;
    }
    if (data[i].children && data[i].children.length > 0) {
      const childResult = findIndexByItem(data[i].children, targetItem, currentPath);
      if (childResult.length > 0) {
        return childResult;
      }
    }
  }
  return [];
}

//用于重新修改serial
export const updateSerials = (data) => {
  for (let i = 0; i < data.length; i++) {
    data[i].serial = i;

    // if (currentItem.id === targetId) {
    //   if (!currentItem.children) {
    //     currentItem.children = [];
    //   }
    //   currentItem.children.push(newAdd);
    //   return true; // 表示已经找到并修改
    // }

    // 如果有子项，递归查找
    if (data[i].children && data[i].children.length > 0) {
      updateSerials(data[i].children);

      // if (found) {
      //   return true; // 如果在子项中找到目标项，停止继续查找
      // }
    }
  }
  return data;
  // return false; // 表示未找到目标项
};

//用于新增数据
export const updateData = (data, targetId, newAdd) => {
  for (let i = 0; i < data.length; i++) {
    const currentItem = data[i];

    if (currentItem.id === targetId) {
      if (!currentItem.children) {
        currentItem.children = [];
      }
      currentItem.children.push(newAdd);
      return true; // 表示已经找到并修改
    }

    // 如果有子项，递归查找
    if (currentItem.children && currentItem.children.length > 0) {
      const found = updateData(currentItem.children, targetId, newAdd);

      if (found) {
        return true; // 如果在子项中找到目标项，停止继续查找
      }
    }
  }

  return false; // 表示未找到目标项
};

//判断该条数据的层级
export const findItemLevel = (data, targetId, targetName, currentLevel = 0) => {
  for (let i = 0; i < data.length; i++) {
    const item = data[i];

    if (item.id === targetId && item.name === targetName) {
      return currentLevel;
    }

    if (item.children && item.children.length > 0) {
      const childLevel = findItemLevel(item.children, targetId, targetName, currentLevel + 1);
      if (childLevel !== -1) {
        return childLevel;
      }
    }
  }

  return -1;
};

//查询该数据在各个层级的索引
export const findItemEachLevel = (
  data,
  targetId,
  targetName,
  currentLevel = 0,
  level1 = -1,
  level2 = -1,
  level3 = -1,
) => {
  // const level1 = ref<number>(-1);
  // const level2 = ref<number>(-1);
  // const level3 = ref<number>(-1);
  for (let i = 0; i < data.length; i++) {
    const item = data[i];

    if (item.id === targetId && item.name === targetName) {
      // return currentLevel;
      if (currentLevel === 0) {
        level1 = i;
        return { level1: level1, level2: level2, level3: level3 };
      } else if (currentLevel === 1) {
        level2 = i;
        return { level1: level1, level2: level2, level3: level3 };
      } else if (currentLevel === 2) {
        level3 = i;
        return { level1: level1, level2: level2, level3: level3 };
      }
    }

    if (item.children && item.children.length > 0) {
      const childLevel = findItemLevel(item.children, targetId, targetName, currentLevel + 1, i);
      if (childLevel !== -1) {
        return childLevel;
      }
    }
  }

  return { level1: level1.value, level2: level2.value, level3: level3.value };
};

export function findIndexById(data, targetId, targetName, level = 1) {
  for (let i = 0; i < data.length; i++) {
    if (data[i].id === targetId && data[i].name === targetName) {
      return { level1: level, level2: -1, level3: -1 };
    }
    if (data[i].children && data[i].children.length > 0) {
      const childResult = findIndexById(data[i].children, targetId, targetName, level + 1);
      if (childResult.level1 !== -1) {
        if (childResult.level2 === -1 && childResult.level3 === -1) {
          return { level1: level, level2: childResult.level1, level3: -1 };
        }
        return childResult;
      }
    }
  }
  return { level1: -1, level2: -1, level3: -1 };
}

//删除行
export const deleteTableRow = (dataSource, targetId) => {
  const deleteRecursive = (data) => {
    for (let i = 0; i < data.length; i++) {
      const currentItem = data[i];

      if (currentItem.id === targetId) {
        // 删除当前项
        data.splice(i, 1);
        return true;
      }

      // 如果有子项，递归查找
      if (currentItem.children && currentItem.children.length > 0) {
        const found = deleteRecursive(currentItem.children);

        if (found) {
          return true; // 如果在子项中找到目标项，停止继续查找
        }
      }
    }

    return false; // 表示未找到目标项
  };

  // 从顶层开始递归删除
  deleteRecursive(dataSource);
};

//行的编辑提交功能
export const editTableRow = (
  dataSource,
  targetId,
  level,
  name,
  newName,
  newCode,
  newStatus,
  newLeader = '',
  newTemplete = '',
  newTag = 0,
  newToptag = [] as unknown as string[],
) => {
  const editTRecursive = (data) => {
    for (let i = 0; i < data.length; i++) {
      const currentItem = data[i];

      if (currentItem.id === targetId) {
        // 修改
        currentItem.name = newName;
        currentItem.code = newCode;
        currentItem.status = newStatus;
        if (level === 0) {
          currentItem.Toptag = newToptag;
        } else if (level === 1) {
          currentItem.companyLabelId = newTag;
          currentItem.templete = newTemplete;
        } else if (level === 2) {
          currentItem.leader = newLeader;
        }

        return true;
      }

      // 如果有子项，递归查找
      if (currentItem.children && currentItem.children.length > 0) {
        const found = editTRecursive(currentItem.children);

        if (found) {
          return true; // 如果在子项中找到目标项，停止继续查找
        }
      }
    }
    return false; // 表示未找到目标项
  };

  editTRecursive(dataSource);
};

export enum ENABLED {
  FALSE = 1,
  TRUE = 0,
}