696 lines
20 KiB
JavaScript

'use strict';
const Service = require('egg').Service;
class SettingRoleService extends Service {
createError(message, code = 500) {
const error = new Error(message);
error.code = code;
return error;
}
getCurrentStoreId() {
const storeId = Number(this.ctx.user && this.ctx.user.store_id);
if (!Number.isFinite(storeId) || storeId <= 0) {
throw this.createError('未识别到当前主体,无法操作角色', 400);
}
return storeId;
}
getCurrentEmployeeId() {
const employeeId = Number(this.ctx.user && this.ctx.user.employees_id);
if (!Number.isFinite(employeeId) || employeeId <= 0) {
return null;
}
return employeeId;
}
toPositiveNumber(value, fieldName) {
const num = Number(value);
if (!Number.isFinite(num) || num <= 0) {
throw this.createError(`${fieldName} 参数不能为空`, 400);
}
return num;
}
async getEmployee(employeeId, options = {}) {
const { ctx } = this;
const storeId = this.getCurrentStoreId();
const includeDisabled = options.includeDisabled === true;
const where = {
id: employeeId,
store_id: storeId,
};
if (!includeDisabled) {
where.status = 1;
}
const employee = await ctx.model.AccountStoreEmployee.findOne({ where });
if (!employee) {
throw this.createError('工号不存在或无权限操作', 404);
}
return employee;
}
normalizeRoleIds(inputRoleIds) {
if (!Array.isArray(inputRoleIds) || inputRoleIds.length === 0) {
throw this.createError('role_ids 参数不能为空', 400);
}
const roleIds = [];
for (const roleId of inputRoleIds) {
const normalized = Number(roleId);
if (!Number.isFinite(normalized) || normalized <= 0) {
throw this.createError('role_ids 必须是正整数数组', 400);
}
roleIds.push(normalized);
}
return Array.from(new Set(roleIds));
}
async findAssignableRoles(roleIds, storeId) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const roles = await ctx.model.Role.findAll({
where: {
id: roleIds,
status: 1,
[Op.or]: [
{ store_id: storeId },
{ store_id: 0 },
{ store_id: null },
],
},
order: [[ 'id', 'ASC' ]],
});
if (roles.length !== roleIds.length) {
const foundRoleIds = roles.map(role => Number(role.id));
const missingRoleIds = roleIds.filter(roleId => !foundRoleIds.includes(roleId));
throw this.createError(`角色不存在、已禁用或超出当前主体范围:${missingRoleIds.join(',')}`, 400);
}
return roles;
}
async clearEmployeeCache(employee) {
const { service } = this.ctx;
await service.systems.auth.user.clearUserCache(Number(employee.account_id));
}
async getCurrentEmployeeRoleIds() {
const { ctx } = this;
const currentEmployeeId = this.getCurrentEmployeeId();
if (!currentEmployeeId) {
return [];
}
const rows = await ctx.model.EmployeeRole.findAll({
where: {
employee_id: currentEmployeeId,
},
attributes: [ 'role_id' ],
});
return Array.from(new Set(rows.map(item => Number(item.role_id)).filter(id => Number.isFinite(id) && id > 0)));
}
collectDescendantRoleIds(roleRows, startRoleIds) {
const childrenMap = new Map();
for (const row of roleRows) {
const parentId = Number(row.pid || 0);
if (!childrenMap.has(parentId)) {
childrenMap.set(parentId, []);
}
childrenMap.get(parentId).push(Number(row.id));
}
const visited = new Set();
const stack = Array.from(startRoleIds);
while (stack.length > 0) {
const roleId = Number(stack.pop());
if (!Number.isFinite(roleId) || roleId <= 0 || visited.has(roleId)) {
continue;
}
visited.add(roleId);
const children = childrenMap.get(roleId) || [];
for (const childId of children) {
if (!visited.has(childId)) {
stack.push(childId);
}
}
}
return visited;
}
async buildRolePermissionMap(roleRows) {
const { service } = this.ctx;
const rows = Array.isArray(roleRows) ? roleRows : [];
const permissionMap = new Map();
for (const row of rows) {
const roleId = Number(row && row.id);
if (!Number.isFinite(roleId) || roleId <= 0) {
continue;
}
const directPermissionIds = service.systems.auth.rolePermission.toApiPermissionIds(row.permissions);
permissionMap.set(roleId, directPermissionIds);
}
return permissionMap;
}
buildRoleTree(roleRows, rootRoleIds, selectedRoleIdSet, rolePermissionMap = new Map()) {
const nodeMap = new Map();
for (const row of roleRows) {
const roleId = Number(row.id);
nodeMap.set(roleId, {
role_id: roleId,
role_code: row.role_code || '',
role_name: row.role_name || '',
description: row.description || '',
role_type: Number(row.role_type),
scope: Number(row.scope),
is_system: Number(row.is_system),
status: Number(row.status),
store_id: row.store_id === null ? null : Number(row.store_id),
pid: Number(row.pid || 0),
selected: selectedRoleIdSet.has(roleId),
permission_ids: rolePermissionMap.get(roleId) || [],
children: [],
});
}
for (const node of nodeMap.values()) {
const parent = nodeMap.get(node.pid);
if (parent) {
parent.children.push(node);
}
}
const sortNodes = nodes => {
nodes.sort((a, b) => a.role_id - b.role_id);
for (const item of nodes) {
if (item.children && item.children.length > 0) {
sortNodes(item.children);
}
}
};
const roots = Array.from(rootRoleIds)
.map(roleId => nodeMap.get(Number(roleId)))
.filter(Boolean);
sortNodes(roots);
return roots;
}
normalizeStoreScope(storeId) {
if (storeId === null || storeId === undefined) {
return 0;
}
const num = Number(storeId);
if (!Number.isFinite(num) || num <= 0) {
return 0;
}
return num;
}
isRoleVisibleInScope(role, currentRoleRows, currentStoreId, includeSystem) {
const roleStoreScope = this.normalizeStoreScope(role.store_id);
// 当前主体角色默认可见
if (roleStoreScope === currentStoreId) {
return true;
}
// includeSystem=true 时,可见系统角色
if (includeSystem && roleStoreScope === 0) {
return true;
}
// 当前工号若本身处于系统角色域,至少允许看到系统角色,避免空树。
const hasSystemCurrentRole = currentRoleRows
.some(item => this.normalizeStoreScope(item.store_id) === 0);
if (hasSystemCurrentRole && roleStoreScope === 0) {
return true;
}
return false;
}
normalizePermissionIds(inputPermissionIds) {
if (inputPermissionIds === '*') {
return [ '*' ];
}
if (typeof inputPermissionIds === 'string') {
const trimmed = inputPermissionIds.trim();
if (!trimmed) {
throw this.createError('permission_ids 参数不能为空', 400);
}
if (trimmed === '*') {
return [ '*' ];
}
try {
const parsed = JSON.parse(trimmed);
return this.normalizePermissionIds(parsed);
} catch (_) {
if (trimmed.includes(',')) {
return this.normalizePermissionIds(trimmed.split(','));
}
throw this.createError('permission_ids 必须是正整数数组或 ["*"]', 400);
}
}
if (!Array.isArray(inputPermissionIds)) {
throw this.createError('permission_ids 参数不能为空', 400);
}
if (inputPermissionIds.some(item => typeof item === 'string' && item.trim() === '*')) {
return [ '*' ];
}
const permissionIds = [];
for (const permissionId of inputPermissionIds) {
const normalized = Number(permissionId);
if (!Number.isFinite(normalized) || normalized <= 0) {
throw this.createError('permission_ids 必须是正整数数组或 ["*"]', 400);
}
permissionIds.push(Math.floor(normalized));
}
return Array.from(new Set(permissionIds));
}
normalizePid(value) {
if (value === undefined || value === null || value === '') {
return 0;
}
const pid = Number(value);
if (!Number.isFinite(pid) || pid < 0) {
throw this.createError('pid 参数不合法', 400);
}
return pid;
}
async getManageableRole(roleId, options = {}) {
const { ctx } = this;
const storeId = this.getCurrentStoreId();
const includeDisabled = options.includeDisabled === true;
const where = {
id: roleId,
store_id: storeId,
is_system: 0,
};
if (!includeDisabled) {
where.status = 1;
}
const role = await ctx.model.Role.findOne({ where });
if (!role) {
throw this.createError('角色不存在、无权限操作或为系统预设角色', 404);
}
return role;
}
async validatePermissionSet(permissionIds) {
const { ctx } = this;
if (!Array.isArray(permissionIds) || permissionIds.length === 0) {
return;
}
if (permissionIds.includes('*')) {
return;
}
const existingPermissions = await ctx.model.Permission.findAll({
where: {
id: permissionIds,
status: 1,
},
attributes: [ 'id' ],
raw: true,
});
if (existingPermissions.length !== permissionIds.length) {
const found = new Set(existingPermissions.map(item => Number(item.id)));
const missing = permissionIds.filter(id => !found.has(id));
throw this.createError(`权限不存在或已禁用:${missing.join(',')}`, 400);
}
}
async replaceRolePermissions(roleId, permissionIds, transaction) {
return await this.ctx.service.systems.auth.rolePermission.assignPermissions(roleId, permissionIds, {
transaction,
});
}
async clearRoleUsersCache(roleId) {
const { ctx, service } = this;
const storeId = this.getCurrentStoreId();
const employeeRoleRows = await ctx.model.EmployeeRole.findAll({
where: {
role_id: roleId,
},
include: [
{
model: ctx.model.AccountStoreEmployee,
as: 'employee',
attributes: [ 'account_id' ],
where: {
store_id: storeId,
status: 1,
},
required: true,
},
],
raw: false,
});
const accountIds = Array.from(new Set(employeeRoleRows
.map(item => Number(item.employee && item.employee.account_id))
.filter(id => Number.isFinite(id) && id > 0)));
for (const accountId of accountIds) {
await service.systems.auth.user.clearUserCache(accountId);
}
}
async list(data = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const storeId = this.getCurrentStoreId();
const includeDisabled = data.includeDisabled === true;
const includeSystem = data.includeSystem === true;
const currentEmployeeId = this.getCurrentEmployeeId();
let employee = null;
if (currentEmployeeId) {
employee = await this.getEmployee(currentEmployeeId, {
includeDisabled: true,
});
}
// 先拉取当前主体 + 系统角色域,后续按可见规则二次收敛。
const roleWhere = {
status: includeDisabled ? { [Op.in]: [ 0, 1 ] } : 1,
[Op.or]: [{ store_id: storeId }, { store_id: 0 }, { store_id: null }],
};
const roleRows = await ctx.model.Role.findAll({
where: roleWhere,
attributes: [
'id',
'role_code',
'role_name',
'description',
'role_type',
'scope',
'is_system',
'status',
'store_id',
'pid',
'permissions',
],
order: [
[ 'is_system', 'DESC' ],
[ 'id', 'ASC' ],
],
});
const currentRoleIds = await this.getCurrentEmployeeRoleIds();
if (currentRoleIds.length === 0) {
return {
code: 200,
data: {
employee_id: employee ? Number(employee.id) : null,
roles: [],
},
};
}
const roleMap = new Map(roleRows.map(item => [ Number(item.id), item ]));
const currentRoleRows = currentRoleIds
.map(roleId => roleMap.get(roleId))
.filter(Boolean);
if (currentRoleRows.length === 0) {
return {
code: 200,
data: {
employee_id: employee ? Number(employee.id) : null,
roles: [],
},
};
}
const currentRoleIdSet = new Set(currentRoleRows.map(item => Number(item.id)));
// 仅返回当前角色的下级角色树,不返回自己及同级角色。
const subordinateRootRoleIds = new Set(roleRows
.filter(item => currentRoleIdSet.has(Number(item.pid || 0)))
.filter(item => this.isRoleVisibleInScope(item, currentRoleRows, storeId, includeSystem))
.map(item => Number(item.id)));
if (subordinateRootRoleIds.size === 0) {
return {
code: 200,
data: {
employee_id: employee ? Number(employee.id) : null,
roles: [],
},
};
}
const visibleRoleIds = this.collectDescendantRoleIds(roleRows, Array.from(subordinateRootRoleIds));
const visibleRoleRows = roleRows
.filter(item => visibleRoleIds.has(Number(item.id)))
.filter(item => this.isRoleVisibleInScope(item, currentRoleRows, storeId, includeSystem));
const rootRoleIds = new Set(visibleRoleRows
.filter(item => subordinateRootRoleIds.has(Number(item.id)))
.map(item => Number(item.id)));
let selectedRoleIdSet = new Set();
if (employee) {
const employeeRoles = await ctx.model.EmployeeRole.findAll({
where: {
employee_id: employee.id,
},
});
selectedRoleIdSet = new Set(employeeRoles.map(item => Number(item.role_id)));
}
const rolePermissionMap = await this.buildRolePermissionMap(visibleRoleRows);
const roles = this.buildRoleTree(visibleRoleRows, rootRoleIds, selectedRoleIdSet, rolePermissionMap);
return {
code: 200,
data: {
employee_id: employee ? Number(employee.id) : null,
roles,
},
};
}
async permission(data = {}) {
return this.ctx.service.systems.setting.permission.list(data);
}
async add(data = {}) {
const { ctx } = this;
const storeId = this.getCurrentStoreId();
const roleCode = typeof data.role_code === 'string' ? data.role_code.trim() : '';
const roleName = typeof data.role_name === 'string' ? data.role_name.trim() : '';
const description = typeof data.description === 'string' ? data.description.trim() : '';
const roleType = Number(data.role_type || 1);
const scope = Number(data.scope || 1);
const status = data.status === 0 || data.status === '0' ? 0 : 1;
const pid = this.normalizePid(data.pid);
const permissionIds = this.normalizePermissionIds(data.permission_ids || data.permissionIds || []);
const creatorId = Number(this.ctx.user && this.ctx.user.id);
if (!roleCode) {
throw this.createError('role_code 参数不能为空', 400);
}
if (!roleName) {
throw this.createError('role_name 参数不能为空', 400);
}
if (!Number.isFinite(creatorId) || creatorId <= 0) {
throw this.createError('未识别到当前账号,无法创建角色', 400);
}
await this.validatePermissionSet(permissionIds);
const transaction = await ctx.model.transaction();
let createdRole = null;
try {
createdRole = await ctx.model.Role.create({
role_code: roleCode,
role_name: roleName,
description,
role_type: roleType,
scope,
is_system: 0,
status,
created_by: creatorId,
store_id: storeId,
pid,
}, { transaction });
await this.replaceRolePermissions(Number(createdRole.id), permissionIds, transaction);
await transaction.commit();
} catch (error) {
await transaction.rollback();
if (error && error.name === 'SequelizeUniqueConstraintError') {
throw this.createError('role_code 已存在', 409);
}
throw error;
}
return {
code: 200,
data: {
role_id: Number(createdRole.id),
role_code: createdRole.role_code,
role_name: createdRole.role_name,
permission_ids: permissionIds,
created: true,
},
};
}
async delete(data = {}) {
const { ctx } = this;
const roleIds = this.normalizeRoleIds(data.ids);
const roles = [];
for (const roleId of roleIds) {
const role = await this.getManageableRole(roleId, {
includeDisabled: true,
});
roles.push(role);
}
const deletedIds = [];
const alreadyDeletedIds = [];
const transaction = await ctx.model.transaction();
try {
for (const role of roles) {
const roleId = Number(role.id);
if (Number(role.status) === 0) {
alreadyDeletedIds.push(roleId);
continue;
}
await role.update({
status: 0,
updated_at: new Date(),
}, { transaction });
deletedIds.push(roleId);
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
for (const roleId of deletedIds) {
await this.clearRoleUsersCache(roleId);
}
return {
code: 200,
data: {
ids: roleIds,
deleted_ids: deletedIds,
already_deleted_ids: alreadyDeletedIds,
status: 'deleted',
},
};
}
async update(data = {}) {
const { ctx } = this;
const roleId = this.toPositiveNumber(data.role_id || data.roleId, 'role_id');
const role = await this.getManageableRole(roleId, {
includeDisabled: true,
});
const hasRoleName = Object.prototype.hasOwnProperty.call(data, 'role_name');
const hasDescription = Object.prototype.hasOwnProperty.call(data, 'description');
const hasStatus = Object.prototype.hasOwnProperty.call(data, 'status');
const hasPid = Object.prototype.hasOwnProperty.call(data, 'pid');
const hasPermissionIds = Object.prototype.hasOwnProperty.call(data, 'permission_ids')
|| Object.prototype.hasOwnProperty.call(data, 'permissionIds');
if (!hasRoleName && !hasDescription && !hasStatus && !hasPid && !hasPermissionIds) {
throw this.createError('至少需要更新角色信息或 permission_ids', 400);
}
if (!hasPermissionIds) {
throw this.createError('permission_ids 参数不能为空,角色权限需一次性提交', 400);
}
const permissionIds = this.normalizePermissionIds(data.permission_ids || data.permissionIds || []);
await this.validatePermissionSet(permissionIds);
const updates = {};
if (hasRoleName) {
const roleName = typeof data.role_name === 'string' ? data.role_name.trim() : '';
if (!roleName) {
throw this.createError('role_name 参数不能为空', 400);
}
updates.role_name = roleName;
}
if (hasDescription) {
updates.description = typeof data.description === 'string' ? data.description.trim() : '';
}
if (hasStatus) {
const status = data.status === 0 || data.status === '0' ? 0 : 1;
updates.status = status;
}
if (hasPid) {
updates.pid = this.normalizePid(data.pid);
}
updates.updated_at = new Date();
const transaction = await ctx.model.transaction();
try {
if (Object.keys(updates).length > 0) {
await role.update(updates, { transaction });
}
await this.replaceRolePermissions(roleId, permissionIds, transaction);
await transaction.commit();
} catch (error) {
await transaction.rollback();
if (error && error.name === 'SequelizeUniqueConstraintError') {
throw this.createError('角色信息冲突(可能 role_code 重复)', 409);
}
throw error;
}
await this.clearRoleUsersCache(roleId);
return {
code: 200,
data: {
role_id: roleId,
role_name: role.role_name,
permission_ids: permissionIds,
},
};
}
}
module.exports = SettingRoleService;