610 lines
17 KiB
JavaScript
610 lines
17 KiB
JavaScript
import { defineStore } from 'pinia';
|
|
import { ref, computed } from 'vue';
|
|
import {
|
|
getTenantDepartments,
|
|
getDepartmentInfo
|
|
} from '@/api/department';
|
|
import {
|
|
getTenantPositions,
|
|
getPositionsByDepartment
|
|
} from '@/api/position';
|
|
import { getRoleByTenantId } from '@/api/role';
|
|
import { getOABaseData } from '@/api/oa';
|
|
import { useAuthStore } from '@/stores/auth';
|
|
|
|
/**
|
|
* OA 基础数据 Store
|
|
* 统一管理部门、职位、角色等基础数据，并提供缓存机制
|
|
*/
|
|
export const useOAStore = defineStore('oa', () => {
|
|
// ========== 状态定义 ==========
|
|
const departments = ref([]); // 部门列表（扁平结构）
|
|
const departmentTree = ref([]); // 部门树结构
|
|
const positions = ref([]); // 职位列表
|
|
const roles = ref([]); // 角色列表
|
|
|
|
// 缓存时间戳（毫秒）
|
|
const cacheTime = 5 * 60 * 1000; // 5分钟缓存
|
|
const departmentsCacheTime = ref(0);
|
|
const positionsCacheTime = ref(0);
|
|
const rolesCacheTime = ref(0);
|
|
|
|
// 加载状态
|
|
const loadingDepartments = ref(false);
|
|
const loadingPositions = ref(false);
|
|
const loadingRoles = ref(false);
|
|
|
|
// ========== 工具函数 ==========
|
|
const authStore = useAuthStore();
|
|
|
|
// 获取当前租户ID
|
|
const getCurrentTenantId = () => {
|
|
if (authStore.user && authStore.user.tenant_id) {
|
|
return authStore.user.tenant_id;
|
|
}
|
|
const userInfo = localStorage.getItem('userInfo');
|
|
if (userInfo) {
|
|
try {
|
|
const user = JSON.parse(userInfo);
|
|
return user.tenant_id || user.tenantId || 0;
|
|
} catch (e) {
|
|
console.error('Failed to parse user info:', e);
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
// 检查缓存是否有效
|
|
const isCacheValid = (cacheTimeValue) => {
|
|
return Date.now() - cacheTimeValue < cacheTime;
|
|
};
|
|
|
|
// 构建部门树
|
|
const buildDepartmentTree = (deptList, tenantId) => {
|
|
if (!deptList || deptList.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
// 先按tenant_id过滤
|
|
let filteredList = deptList;
|
|
if (tenantId !== undefined && tenantId !== null) {
|
|
filteredList = deptList.filter((dept) => {
|
|
const deptTenantId = dept.tenant_id || dept.tenantId;
|
|
return deptTenantId === tenantId || deptTenantId === 0;
|
|
});
|
|
}
|
|
|
|
const tree = [];
|
|
const map = new Map();
|
|
|
|
// 第一遍：创建所有节点的映射
|
|
filteredList.forEach((dept) => {
|
|
if (!dept.id) return;
|
|
map.set(dept.id, {
|
|
...dept,
|
|
children: [],
|
|
});
|
|
});
|
|
|
|
// 第二遍：构建树结构
|
|
filteredList.forEach((dept) => {
|
|
if (!dept.id) return;
|
|
|
|
const node = map.get(dept.id);
|
|
if (!node) return;
|
|
|
|
const parentId = dept.parent_id || 0;
|
|
if (parentId === 0 || parentId === null || parentId === undefined) {
|
|
tree.push(node);
|
|
} else {
|
|
const parent = map.get(parentId);
|
|
if (parent) {
|
|
parent.children.push(node);
|
|
} else {
|
|
tree.push(node);
|
|
}
|
|
}
|
|
});
|
|
|
|
// 排序
|
|
const sortTree = (nodes) => {
|
|
nodes.sort((a, b) => (a.sort_order || 0) - (b.sort_order || 0));
|
|
nodes.forEach((node) => {
|
|
if (node.children && node.children.length > 0) {
|
|
sortTree(node.children);
|
|
}
|
|
});
|
|
};
|
|
sortTree(tree);
|
|
|
|
return tree;
|
|
};
|
|
|
|
// 解析接口返回的数据
|
|
const parseResponse = (res) => {
|
|
if (Array.isArray(res)) {
|
|
return res;
|
|
} else if (res?.data && Array.isArray(res.data)) {
|
|
return res.data;
|
|
} else if (res?.data?.data && Array.isArray(res.data.data)) {
|
|
return res.data.data;
|
|
} else if (res?.data) {
|
|
return res.data;
|
|
}
|
|
return [];
|
|
};
|
|
|
|
// ========== 部门相关方法 ==========
|
|
|
|
/**
|
|
* 获取部门列表（带缓存）
|
|
* @param {boolean} forceRefresh 是否强制刷新，忽略缓存
|
|
* @returns {Promise}
|
|
*/
|
|
const fetchDepartments = async (forceRefresh = false) => {
|
|
// 如果缓存有效且不强制刷新，直接返回缓存数据
|
|
if (!forceRefresh && isCacheValid(departmentsCacheTime.value) && departments.value.length > 0) {
|
|
return departments.value;
|
|
}
|
|
|
|
// 如果正在加载，等待加载完成
|
|
if (loadingDepartments.value) {
|
|
return new Promise((resolve) => {
|
|
const checkInterval = setInterval(() => {
|
|
if (!loadingDepartments.value) {
|
|
clearInterval(checkInterval);
|
|
resolve(departments.value);
|
|
}
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
loadingDepartments.value = true;
|
|
try {
|
|
const tenantId = getCurrentTenantId();
|
|
const res = await getTenantDepartments(tenantId);
|
|
const deptList = parseResponse(res);
|
|
|
|
departments.value = deptList;
|
|
departmentTree.value = buildDepartmentTree(deptList, tenantId);
|
|
departmentsCacheTime.value = Date.now();
|
|
|
|
return deptList;
|
|
} catch (error) {
|
|
console.error('获取部门列表失败:', error);
|
|
// 如果出错且没有缓存数据，返回空数组
|
|
if (departments.value.length === 0) {
|
|
departments.value = [];
|
|
departmentTree.value = [];
|
|
}
|
|
throw error;
|
|
} finally {
|
|
loadingDepartments.value = false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 获取部门树（计算属性）
|
|
*/
|
|
const getDepartmentTree = computed(() => departmentTree.value);
|
|
|
|
/**
|
|
* 根据ID获取部门信息
|
|
*/
|
|
const getDepartmentById = (id) => {
|
|
const findInTree = (nodes) => {
|
|
for (const node of nodes) {
|
|
if (node.id === id) return node;
|
|
if (node.children && node.children.length > 0) {
|
|
const found = findInTree(node.children);
|
|
if (found) return found;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
return findInTree(departmentTree.value) || departments.value.find(d => d.id === id);
|
|
};
|
|
|
|
// ========== 职位相关方法 ==========
|
|
|
|
/**
|
|
* 获取职位列表（带缓存）
|
|
* @param {number|null} departmentId 部门ID，如果提供则只获取该部门的职位
|
|
* @param {boolean} forceRefresh 是否强制刷新
|
|
* @returns {Promise}
|
|
*/
|
|
const fetchPositions = async (departmentId = null, forceRefresh = false) => {
|
|
// 如果指定了部门ID，先尝试从已有数据中过滤
|
|
if (departmentId) {
|
|
// 如果已加载所有职位且缓存有效，直接过滤返回
|
|
// 注意：即使某个部门没有职位，只要已加载所有职位，也应该直接返回空数组
|
|
if (!forceRefresh && isCacheValid(positionsCacheTime.value)) {
|
|
// 如果已加载所有职位（positions.value.length > 0 或已加载过），直接过滤
|
|
const filteredPositions = positions.value.filter((pos) => {
|
|
return Number(pos.department_id) === Number(departmentId);
|
|
});
|
|
// 直接返回过滤结果（即使为空数组，也说明该部门确实没有职位）
|
|
return filteredPositions;
|
|
}
|
|
|
|
// 如果缓存中没有数据或需要刷新，请求该部门的职位
|
|
try {
|
|
loadingPositions.value = true;
|
|
const res = await getPositionsByDepartment(departmentId);
|
|
const posList = parseResponse(res);
|
|
|
|
// 将获取到的职位合并到职位列表中（去重）
|
|
if (posList && posList.length > 0) {
|
|
const uniquePositions = new Map();
|
|
// 先添加现有职位
|
|
positions.value.forEach((pos) => {
|
|
uniquePositions.set(Number(pos.id), pos);
|
|
});
|
|
// 再添加新获取的职位
|
|
posList.forEach((pos) => {
|
|
const posId = Number(pos.id);
|
|
if (posId && !uniquePositions.has(posId)) {
|
|
uniquePositions.set(posId, pos);
|
|
}
|
|
});
|
|
positions.value = Array.from(uniquePositions.values());
|
|
}
|
|
// 更新缓存时间（即使返回空数组也要更新，表示已查询过）
|
|
positionsCacheTime.value = Date.now();
|
|
|
|
return posList || [];
|
|
} catch (error) {
|
|
console.error('获取职位列表失败:', error);
|
|
throw error;
|
|
} finally {
|
|
loadingPositions.value = false;
|
|
}
|
|
}
|
|
|
|
// 如果缓存有效且不强制刷新，直接返回缓存数据
|
|
if (!forceRefresh && isCacheValid(positionsCacheTime.value) && positions.value.length > 0) {
|
|
return positions.value;
|
|
}
|
|
|
|
// 如果正在加载，等待加载完成
|
|
if (loadingPositions.value) {
|
|
return new Promise((resolve) => {
|
|
const checkInterval = setInterval(() => {
|
|
if (!loadingPositions.value) {
|
|
clearInterval(checkInterval);
|
|
resolve(positions.value);
|
|
}
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
loadingPositions.value = true;
|
|
try {
|
|
const tenantId = getCurrentTenantId();
|
|
const res = await getTenantPositions(tenantId);
|
|
const posList = parseResponse(res);
|
|
|
|
// 去重
|
|
const uniquePositions = new Map();
|
|
posList.forEach((pos) => {
|
|
const posId = Number(pos.id);
|
|
if (posId && !uniquePositions.has(posId)) {
|
|
uniquePositions.set(posId, pos);
|
|
}
|
|
});
|
|
positions.value = Array.from(uniquePositions.values());
|
|
positionsCacheTime.value = Date.now();
|
|
|
|
return positions.value;
|
|
} catch (error) {
|
|
console.error('获取职位列表失败:', error);
|
|
if (positions.value.length === 0) {
|
|
positions.value = [];
|
|
}
|
|
throw error;
|
|
} finally {
|
|
loadingPositions.value = false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 根据ID获取职位信息
|
|
*/
|
|
const getPositionById = (id) => {
|
|
return positions.value.find(p => p.id === id);
|
|
};
|
|
|
|
// ========== 角色相关方法 ==========
|
|
|
|
/**
|
|
* 获取角色列表（带缓存）
|
|
* @param {boolean} forceRefresh 是否强制刷新
|
|
* @returns {Promise}
|
|
*/
|
|
const fetchRoles = async (forceRefresh = false) => {
|
|
// 如果缓存有效且不强制刷新，直接返回缓存数据
|
|
if (!forceRefresh && isCacheValid(rolesCacheTime.value) && roles.value.length > 0) {
|
|
return roles.value;
|
|
}
|
|
|
|
// 如果正在加载，等待加载完成
|
|
if (loadingRoles.value) {
|
|
return new Promise((resolve) => {
|
|
const checkInterval = setInterval(() => {
|
|
if (!loadingRoles.value) {
|
|
clearInterval(checkInterval);
|
|
resolve(roles.value);
|
|
}
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
loadingRoles.value = true;
|
|
try {
|
|
const tenantId = getCurrentTenantId();
|
|
const res = await getRoleByTenantId(tenantId);
|
|
|
|
// 兼容接口返回的数据结构
|
|
if (res?.data && Array.isArray(res.data)) {
|
|
roles.value = res.data;
|
|
} else if (res?.data?.data && Array.isArray(res.data.data)) {
|
|
roles.value = res.data.data;
|
|
} else if (Array.isArray(res)) {
|
|
roles.value = res;
|
|
} else {
|
|
roles.value = [];
|
|
}
|
|
|
|
rolesCacheTime.value = Date.now();
|
|
return roles.value;
|
|
} catch (error) {
|
|
console.error('获取角色列表失败:', error);
|
|
if (roles.value.length === 0) {
|
|
roles.value = [];
|
|
}
|
|
throw error;
|
|
} finally {
|
|
loadingRoles.value = false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 根据ID获取角色信息
|
|
*/
|
|
const getRoleById = (id) => {
|
|
return roles.value.find(r => r.roleId === id || r.id === id);
|
|
};
|
|
|
|
// ========== 批量获取方法 ==========
|
|
|
|
/**
|
|
* 批量获取所有基础数据（用于页面初始化）
|
|
* 使用合并接口，一次性获取所有数据，减少网络请求次数
|
|
* @param {boolean} forceRefresh 是否强制刷新
|
|
* @returns {Promise}
|
|
*/
|
|
const fetchAllBaseData = async (forceRefresh = false) => {
|
|
// 如果缓存有效且不强制刷新，直接返回
|
|
if (!forceRefresh &&
|
|
isCacheValid(departmentsCacheTime.value) &&
|
|
isCacheValid(positionsCacheTime.value) &&
|
|
isCacheValid(rolesCacheTime.value) &&
|
|
departments.value.length > 0 &&
|
|
positions.value.length > 0 &&
|
|
roles.value.length > 0) {
|
|
return;
|
|
}
|
|
|
|
// 如果正在加载，等待加载完成
|
|
if (loadingDepartments.value || loadingPositions.value || loadingRoles.value) {
|
|
return new Promise((resolve) => {
|
|
const checkInterval = setInterval(() => {
|
|
if (!loadingDepartments.value && !loadingPositions.value && !loadingRoles.value) {
|
|
clearInterval(checkInterval);
|
|
resolve();
|
|
}
|
|
}, 100);
|
|
});
|
|
}
|
|
|
|
// 设置加载状态
|
|
loadingDepartments.value = true;
|
|
loadingPositions.value = true;
|
|
loadingRoles.value = true;
|
|
|
|
try {
|
|
const tenantId = getCurrentTenantId();
|
|
|
|
// 调用合并接口，一次性获取所有数据
|
|
const res = await getOABaseData(tenantId);
|
|
|
|
// 解析返回的数据
|
|
let baseData;
|
|
if (res?.data) {
|
|
if (res.data.data) {
|
|
baseData = res.data.data;
|
|
} else {
|
|
baseData = res.data;
|
|
}
|
|
} else {
|
|
baseData = res;
|
|
}
|
|
|
|
// 更新部门数据
|
|
if (baseData.departments && Array.isArray(baseData.departments)) {
|
|
departments.value = baseData.departments;
|
|
departmentTree.value = buildDepartmentTree(baseData.departments, tenantId);
|
|
departmentsCacheTime.value = Date.now();
|
|
}
|
|
|
|
// 更新职位数据
|
|
if (baseData.positions && Array.isArray(baseData.positions)) {
|
|
// 去重
|
|
const uniquePositions = new Map();
|
|
baseData.positions.forEach((pos) => {
|
|
const posId = Number(pos.id);
|
|
if (posId && !uniquePositions.has(posId)) {
|
|
uniquePositions.set(posId, pos);
|
|
}
|
|
});
|
|
positions.value = Array.from(uniquePositions.values());
|
|
positionsCacheTime.value = Date.now();
|
|
}
|
|
|
|
// 更新角色数据
|
|
if (baseData.roles && Array.isArray(baseData.roles)) {
|
|
roles.value = baseData.roles;
|
|
rolesCacheTime.value = Date.now();
|
|
}
|
|
|
|
} catch (error) {
|
|
console.error('批量获取基础数据失败:', error);
|
|
// 如果合并接口失败，回退到分别请求
|
|
console.warn('合并接口失败，回退到分别请求');
|
|
try {
|
|
await Promise.all([
|
|
fetchDepartments(forceRefresh),
|
|
fetchPositions(null, forceRefresh),
|
|
fetchRoles(forceRefresh),
|
|
]);
|
|
} catch (fallbackError) {
|
|
console.error('回退请求也失败:', fallbackError);
|
|
throw fallbackError;
|
|
}
|
|
} finally {
|
|
loadingDepartments.value = false;
|
|
loadingPositions.value = false;
|
|
loadingRoles.value = false;
|
|
}
|
|
};
|
|
|
|
// ========== 缓存管理方法 ==========
|
|
|
|
/**
|
|
* 清除所有缓存
|
|
*/
|
|
const clearCache = () => {
|
|
departmentsCacheTime.value = 0;
|
|
positionsCacheTime.value = 0;
|
|
rolesCacheTime.value = 0;
|
|
};
|
|
|
|
/**
|
|
* 清除部门缓存
|
|
*/
|
|
const clearDepartmentsCache = () => {
|
|
departmentsCacheTime.value = 0;
|
|
};
|
|
|
|
/**
|
|
* 清除职位缓存
|
|
*/
|
|
const clearPositionsCache = () => {
|
|
positionsCacheTime.value = 0;
|
|
};
|
|
|
|
/**
|
|
* 清除角色缓存
|
|
*/
|
|
const clearRolesCache = () => {
|
|
rolesCacheTime.value = 0;
|
|
};
|
|
|
|
/**
|
|
* 临时添加部门到列表（用于显示不在当前租户列表中的部门）
|
|
*/
|
|
const addTemporaryDepartment = (deptData) => {
|
|
if (!deptData || !deptData.id) return;
|
|
|
|
// 检查是否已存在
|
|
const exists = departments.value.some((dept) => dept.id === deptData.id);
|
|
if (!exists) {
|
|
departments.value.push(deptData);
|
|
// 重新构建部门树
|
|
const tenantId = getCurrentTenantId();
|
|
departmentTree.value = buildDepartmentTree(departments.value, tenantId);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 临时添加职位到列表（用于显示不在当前租户列表中的职位）
|
|
*/
|
|
const addTemporaryPosition = (posData) => {
|
|
if (!posData || !posData.id) return;
|
|
|
|
// 检查是否已存在
|
|
const exists = positions.value.some((pos) => pos.id === posData.id);
|
|
if (!exists) {
|
|
positions.value.push(posData);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 临时添加角色到列表（用于显示不在当前租户列表中的角色）
|
|
*/
|
|
const addTemporaryRole = (roleData) => {
|
|
if (!roleData) return;
|
|
|
|
// 获取角色ID（兼容不同的字段名）
|
|
const roleId = roleData.roleId || roleData.id || roleData.role_id;
|
|
if (!roleId) return;
|
|
|
|
// 检查是否已存在
|
|
const exists = roles.value.some((role) => {
|
|
const rId = role.roleId || role.id || role.role_id;
|
|
return Number(rId) === Number(roleId);
|
|
});
|
|
|
|
if (!exists) {
|
|
roles.value.push(roleData);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 刷新指定数据（清除缓存并重新获取）
|
|
*/
|
|
const refreshDepartments = () => fetchDepartments(true);
|
|
const refreshPositions = () => fetchPositions(null, true);
|
|
const refreshRoles = () => fetchRoles(true);
|
|
const refreshAll = () => fetchAllBaseData(true);
|
|
|
|
return {
|
|
// 状态
|
|
departments,
|
|
departmentTree,
|
|
positions,
|
|
roles,
|
|
loadingDepartments,
|
|
loadingPositions,
|
|
loadingRoles,
|
|
|
|
// 计算属性
|
|
getDepartmentTree,
|
|
|
|
// 方法
|
|
fetchDepartments,
|
|
fetchPositions,
|
|
fetchRoles,
|
|
fetchAllBaseData,
|
|
getDepartmentById,
|
|
getPositionById,
|
|
getRoleById,
|
|
|
|
// 缓存管理
|
|
clearCache,
|
|
clearDepartmentsCache,
|
|
clearPositionsCache,
|
|
clearRolesCache,
|
|
refreshDepartments,
|
|
refreshPositions,
|
|
refreshRoles,
|
|
refreshAll,
|
|
|
|
// 临时数据添加
|
|
addTemporaryDepartment,
|
|
addTemporaryPosition,
|
|
addTemporaryRole,
|
|
};
|
|
});
|
|
|