liufumingren 9845a239e2 1
2026-05-16 02:44:53 +08:00

657 lines
19 KiB
JavaScript

'use strict';
const Service = require('egg').Service;
class SettingPermissionService 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 getRole(roleId) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const storeId = this.getCurrentStoreId();
const role = await ctx.model.Role.findOne({
where: {
id: roleId,
[Op.or]: [
{ store_id: storeId },
{ store_id: 0 },
{ store_id: null },
],
},
});
if (!role) {
throw this.createError('角色不存在或无权限操作', 404);
}
return role;
}
async getPermission(permissionId, includeDisabled = false) {
const { ctx } = this;
const where = { id: permissionId };
if (!includeDisabled) {
where.status = 1;
}
const permission = await ctx.model.Permission.findOne({ where });
if (!permission) {
throw this.createError('权限不存在或已禁用', 404);
}
return permission;
}
/**
* 规范化并校验权限类型
* @param {string} type 权限类型
* @return {string} 规范化后的权限类型
*/
normalizePermissionType(type) {
const normalized = typeof type === 'string' ? type.trim() : '';
if (!normalized) {
throw this.createError('type 参数不能为空', 400);
}
const allowedTypes = new Set([ 'web_pages', 'pda_pages', 'btns', 'api', 'miniprogram_pages', 'workerstation_pages', 'block' ]);
if (!allowedTypes.has(normalized)) {
throw this.createError('type 参数不合法', 400);
}
return normalized;
}
normalizeOptionalString(value, fieldName, maxLength = 255) {
if (value === undefined || value === null) {
return null;
}
const normalized = String(value).trim();
if (!normalized) {
return '';
}
if (normalized.length > maxLength) {
throw this.createError(`${fieldName} 长度不能超过 ${maxLength}`, 400);
}
return normalized;
}
normalizeParentId(value) {
if (value === undefined || value === null || value === '' || Number(value) === 0) {
return null;
}
const num = Number(value);
if (!Number.isFinite(num) || num <= 0) {
throw this.createError('parent_id 参数不合法', 400);
}
return num;
}
normalizeSort(value) {
if (value === undefined || value === null || value === '') {
return 0;
}
const num = Number(value);
if (!Number.isFinite(num) || num < 0) {
throw this.createError('sort 参数不合法', 400);
}
return Math.floor(num);
}
normalizeStatus(value) {
if (value === undefined || value === null || value === '') {
return 1;
}
const num = Number(value);
if (num === 0 || num === 1) {
return num;
}
throw this.createError('status 参数不合法', 400);
}
normalizeBooleanFlag(value, fieldName) {
if (value === undefined || value === null || value === '') {
return 0;
}
const num = Number(value);
if (num === 0 || num === 1) {
return num;
}
throw this.createError(`${fieldName} 参数不合法`, 400);
}
async getAvailablePermissionIdSet({ includeDisabled = false } = {}) {
const rows = await this.resolveVisiblePermissionRows({
includeDisabled,
type: null,
keyword: '',
});
return new Set(rows.map(item => Number(item.id)).filter(id => Number.isFinite(id) && id > 0));
}
async ensureParentPermissionExists(parentId) {
if (!parentId) {
return;
}
await this.getPermission(parentId, false);
}
async ensurePermissionsExist(permissionIds) {
const { ctx } = this;
const targetRows = await ctx.model.Permission.findAll({
where: {
id: permissionIds,
},
attributes: [ 'id' ],
raw: true,
});
if (targetRows.length !== permissionIds.length) {
const found = new Set(targetRows.map(item => Number(item.id)));
const missing = permissionIds.filter(id => !found.has(Number(id)));
throw this.createError(`权限不存在:${missing.join(',')}`, 404);
}
return targetRows;
}
normalizePermissionIds(inputPermissionIds) {
if (!Array.isArray(inputPermissionIds)) {
throw this.createError('permission_ids 参数不能为空', 400);
}
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(normalized);
}
return Array.from(new Set(permissionIds));
}
normalizeIds(inputIds, fieldName = 'ids') {
if (!Array.isArray(inputIds)) {
throw this.createError(`${fieldName} 参数不能为空`, 400);
}
const ids = [];
for (const item of inputIds) {
const normalized = Number(item);
if (!Number.isFinite(normalized) || normalized <= 0) {
throw this.createError(`${fieldName} 必须是正整数数组`, 400);
}
ids.push(normalized);
}
if (ids.length === 0) {
throw this.createError(`${fieldName} 参数不能为空`, 400);
}
return Array.from(new Set(ids));
}
async validatePermissions(permissionIds) {
const { ctx } = this;
if (permissionIds.length === 0) {
return [];
}
const permissions = await ctx.model.Permission.findAll({
where: {
id: permissionIds,
status: 1,
},
attributes: [ 'id' ],
});
if (permissions.length !== permissionIds.length) {
const foundIds = permissions.map(item => Number(item.id));
const missingIds = permissionIds.filter(item => !foundIds.includes(item));
throw this.createError(`权限不存在或已禁用:${missingIds.join(',')}`, 400);
}
return permissions;
}
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 getCurrentEmployeePermissionIds() {
const { ctx } = this;
const currentEmployeeId = this.getCurrentEmployeeId();
if (!currentEmployeeId) {
return [];
}
const employeeRoles = await ctx.model.EmployeeRole.findAll({
attributes: [ 'role_id' ],
where: {
employee_id: currentEmployeeId,
},
include: [
{
model: ctx.model.Role,
as: 'role',
attributes: [],
where: {
status: 1,
},
required: true,
},
],
raw: true,
});
const roleIds = Array.from(new Set(employeeRoles
.map(item => Number(item.role_id))
.filter(id => Number.isFinite(id) && id > 0)));
if (roleIds.length === 0) {
return [];
}
return await ctx.service.systems.auth.rolePermission.getPermissionIdsForRoles(roleIds, {
includeDisabled: false,
});
}
async getCurrentRoleId() {
const { ctx } = this;
const currentEmployeeId = this.getCurrentEmployeeId();
if (!currentEmployeeId) {
return null;
}
const row = await ctx.model.EmployeeRole.findOne({
attributes: [ 'role_id' ],
where: {
employee_id: currentEmployeeId,
},
include: [
{
model: ctx.model.Role,
as: 'role',
attributes: [],
where: {
status: 1,
},
required: true,
},
],
order: [[ 'id', 'ASC' ]],
raw: true,
});
const roleId = Number(row && row.role_id);
if (!Number.isFinite(roleId) || roleId <= 0) {
return null;
}
return roleId;
}
async resolveVisiblePermissionRows({ includeDisabled = false, type = null, keyword = '', scopeMode = 'available' } = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const where = {
status: includeDisabled ? { [Op.in]: [ 0, 1 ] } : 1,
};
if (scopeMode !== 'all') {
const currentPermissionIds = await this.getCurrentEmployeePermissionIds();
if (currentPermissionIds.length === 0) {
return [];
}
where.id = {
[Op.in]: currentPermissionIds,
};
}
if (type) {
where.type = type;
}
if (keyword) {
where[Op.or] = [
{ path: { [Op.like]: `%${keyword}%` } },
{ name: { [Op.like]: `%${keyword}%` } },
{ meta_title: { [Op.like]: `%${keyword}%` } },
];
}
const permissionRows = await ctx.model.Permission.findAll({
where,
attributes: [
'id',
'path',
'name',
'type',
'status',
'parent_id',
'sort',
'component',
'redirect',
'meta_title',
'meta_icon',
'hidden',
'always_show',
],
order: [
[ 'sort', 'ASC' ],
[ 'id', 'ASC' ],
],
});
return permissionRows;
}
async list(data = {}) {
const { ctx } = this;
const includeDisabled = data.includeDisabled === true;
const roleIdRaw = data.role_id || data.roleId;
const type = typeof data.type === 'string' && data.type.trim() ? data.type.trim() : null;
const keyword = typeof data.keyword === 'string' ? data.keyword.trim() : '';
let role = null;
let targetRoleId = roleIdRaw;
if (targetRoleId === undefined || targetRoleId === null || targetRoleId === '') {
targetRoleId = await this.getCurrentRoleId();
}
if (targetRoleId !== undefined && targetRoleId !== null && targetRoleId !== '') {
const roleId = this.toPositiveNumber(targetRoleId, 'role_id');
role = await this.getRole(roleId);
}
// 权限管理页需要展示全量权限树,不能再按当前登录工号已分配权限做裁剪。
const permissionRows = await this.resolveVisiblePermissionRows({
includeDisabled,
type,
keyword,
scopeMode: 'all',
});
let selectedPermissionSet = new Set();
let selectAllPermissions = false;
if (role) {
const directPermissionIds = ctx.service.systems.auth.rolePermission.toApiPermissionIds(role.permissions);
if (directPermissionIds.includes('*')) {
selectAllPermissions = true;
} else if (directPermissionIds.length > 0) {
selectedPermissionSet = new Set(directPermissionIds.map(item => Number(item)));
}
}
const permissions = permissionRows.map(item => ({
permission_id: Number(item.id),
path: item.path || '',
name: item.name || '',
type: item.type || '',
status: Number(item.status),
parent_id: item.parent_id === null ? null : Number(item.parent_id),
sort: Number(item.sort || 0),
component: item.component || '',
redirect: item.redirect || '',
meta_title: item.meta_title || '',
meta_icon: item.meta_icon || '',
hidden: Number(item.hidden || 0),
always_show: Number(item.always_show || 0),
selected: role ? (selectAllPermissions || selectedPermissionSet.has(Number(item.id))) : false,
}));
return {
code: 200,
data: {
role_id: role ? Number(role.id) : null,
permissions,
},
};
}
async add(data = {}) {
const { ctx } = this;
const path = this.normalizeOptionalString(data.path, 'path', 255);
if (!path) {
throw this.createError('path 参数不能为空', 400);
}
const permissionData = {
path,
type: this.normalizePermissionType(data.type),
name: this.normalizeOptionalString(data.name, 'name', 100) || '',
component: this.normalizeOptionalString(data.component, 'component', 255),
redirect: this.normalizeOptionalString(data.redirect, 'redirect', 255),
meta_title: this.normalizeOptionalString(data.meta_title, 'meta_title', 100),
meta_icon: this.normalizeOptionalString(data.meta_icon, 'meta_icon', 50),
parent_id: this.normalizeParentId(data.parent_id),
sort: this.normalizeSort(data.sort),
hidden: this.normalizeBooleanFlag(data.hidden, 'hidden'),
always_show: this.normalizeBooleanFlag(data.always_show, 'always_show'),
status: this.normalizeStatus(data.status),
};
await this.ensureParentPermissionExists(permissionData.parent_id);
let created = null;
try {
created = await ctx.model.Permission.create(permissionData);
} catch (error) {
throw error;
}
return {
code: 200,
data: {
permission_id: Number(created.id),
path: created.path || '',
type: created.type || '',
parent_id: created.parent_id === null ? null : Number(created.parent_id),
status: Number(created.status),
},
};
}
async delete(data = {}) {
const { ctx } = this;
const permissionIds = this.normalizeIds(data.ids, 'ids');
await this.ensurePermissionsExist(permissionIds);
const permissions = await ctx.model.Permission.findAll({
where: {
id: permissionIds,
},
attributes: [ 'id', 'status' ],
raw: true,
});
const deletedIds = [];
const alreadyDeletedIds = [];
for (const permission of permissions) {
if (Number(permission.status) === 0) {
alreadyDeletedIds.push(Number(permission.id));
} else {
deletedIds.push(Number(permission.id));
}
}
const transaction = await ctx.model.transaction();
try {
if (deletedIds.length > 0) {
await ctx.model.Permission.update({
status: 0,
}, {
where: {
id: deletedIds,
},
transaction,
});
await ctx.service.systems.auth.rolePermission.removePermissionsFromAllRoles(deletedIds, {
transaction,
});
}
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
return {
code: 200,
data: {
ids: permissionIds,
deleted_ids: deletedIds,
already_deleted_ids: alreadyDeletedIds,
status: 'deleted',
},
};
}
async update(data = {}) {
const permissionId = this.toPositiveNumber(data.permission_id || data.permissionId, 'permission_id');
await this.ensurePermissionsExist([ permissionId ]);
const permission = await this.getPermission(permissionId, true);
const hasPath = Object.prototype.hasOwnProperty.call(data, 'path');
const hasName = Object.prototype.hasOwnProperty.call(data, 'name');
const hasType = Object.prototype.hasOwnProperty.call(data, 'type');
const hasComponent = Object.prototype.hasOwnProperty.call(data, 'component');
const hasRedirect = Object.prototype.hasOwnProperty.call(data, 'redirect');
const hasMetaTitle = Object.prototype.hasOwnProperty.call(data, 'meta_title');
const hasMetaIcon = Object.prototype.hasOwnProperty.call(data, 'meta_icon');
const hasParentId = Object.prototype.hasOwnProperty.call(data, 'parent_id');
const hasSort = Object.prototype.hasOwnProperty.call(data, 'sort');
const hasHidden = Object.prototype.hasOwnProperty.call(data, 'hidden');
const hasAlwaysShow = Object.prototype.hasOwnProperty.call(data, 'always_show');
const hasStatus = Object.prototype.hasOwnProperty.call(data, 'status');
if (!hasPath && !hasName && !hasType && !hasComponent && !hasRedirect
&& !hasMetaTitle && !hasMetaIcon && !hasParentId && !hasSort
&& !hasHidden && !hasAlwaysShow && !hasStatus) {
throw this.createError('至少需要提供一个可更新字段', 400);
}
const updates = {};
if (hasPath) {
const path = this.normalizeOptionalString(data.path, 'path', 255);
if (!path) {
throw this.createError('path 参数不能为空', 400);
}
updates.path = path;
}
if (hasName) {
updates.name = this.normalizeOptionalString(data.name, 'name', 100) || '';
}
if (hasType) {
updates.type = this.normalizePermissionType(data.type);
}
if (hasComponent) {
updates.component = this.normalizeOptionalString(data.component, 'component', 255);
}
if (hasRedirect) {
updates.redirect = this.normalizeOptionalString(data.redirect, 'redirect', 255);
}
if (hasMetaTitle) {
updates.meta_title = this.normalizeOptionalString(data.meta_title, 'meta_title', 100);
}
if (hasMetaIcon) {
updates.meta_icon = this.normalizeOptionalString(data.meta_icon, 'meta_icon', 50);
}
if (hasParentId) {
const parentId = this.normalizeParentId(data.parent_id);
if (parentId && parentId === permissionId) {
throw this.createError('parent_id 不能等于 permission_id', 400);
}
await this.ensureParentPermissionExists(parentId);
updates.parent_id = parentId;
}
if (hasSort) {
updates.sort = this.normalizeSort(data.sort);
}
if (hasHidden) {
updates.hidden = this.normalizeBooleanFlag(data.hidden, 'hidden');
}
if (hasAlwaysShow) {
updates.always_show = this.normalizeBooleanFlag(data.always_show, 'always_show');
}
if (hasStatus) {
updates.status = this.normalizeStatus(data.status);
}
await permission.update(updates);
return {
code: 200,
data: {
permission_id: Number(permission.id),
path: permission.path || '',
type: permission.type || '',
parent_id: permission.parent_id === null ? null : Number(permission.parent_id),
status: Number(permission.status),
},
};
}
}
module.exports = SettingPermissionService;