WMS_MAIN/app/service/systems/auth/role_permission.js
liufumingren 9845a239e2 1
2026-05-16 02:44:53 +08:00

237 lines
6.4 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
const Service = require('egg').Service;
class RolePermissionService extends Service {
/**
* 规范化权限类型过滤参数
* @param {string|string[]|undefined|null} type 权限类型过滤值
* @return {null|string|string[]} 可用于 where.type 的过滤值;null 表示不加过滤
*/
normalizeTypeFilter(type) {
if (Array.isArray(type)) {
const normalizedTypes = Array.from(new Set(type
.map(item => (typeof item === 'string' ? item.trim() : ''))
.filter(Boolean)));
return normalizedTypes.length > 0 ? normalizedTypes : null;
}
if (typeof type === 'string') {
const normalizedType = type.trim();
return normalizedType || null;
}
return null;
}
normalizePermissionSet(rawValue) {
if (rawValue === undefined || rawValue === null) {
return { allAccess: false, permissionIds: [] };
}
if (Array.isArray(rawValue)) {
const normalizedItems = rawValue.map(item => (typeof item === 'string' ? item.trim() : item));
if (normalizedItems.some(item => item === '*')) {
return { allAccess: true, permissionIds: [] };
}
const permissionIds = normalizedItems
.map(item => Number(item))
.filter(item => Number.isFinite(item) && item > 0)
.map(item => Math.floor(item));
return {
allAccess: false,
permissionIds: Array.from(new Set(permissionIds)).sort((a, b) => a - b),
};
}
if (typeof rawValue === 'number') {
return this.normalizePermissionSet([ rawValue ]);
}
if (typeof rawValue === 'string') {
const trimmed = rawValue.trim();
if (!trimmed) {
return { allAccess: false, permissionIds: [] };
}
if (trimmed === '*') {
return { allAccess: true, permissionIds: [] };
}
try {
const parsed = JSON.parse(trimmed);
if (parsed !== rawValue) {
return this.normalizePermissionSet(parsed);
}
} catch (_) {
// ignore JSON parse failure and continue with string splitting.
}
if (trimmed.includes(',')) {
return this.normalizePermissionSet(trimmed.split(','));
}
return this.normalizePermissionSet([ trimmed ]);
}
return { allAccess: false, permissionIds: [] };
}
toApiPermissionIds(rawValue) {
const state = this.normalizePermissionSet(rawValue);
return state.allAccess ? [ '*' ] : state.permissionIds;
}
serializePermissionSet(rawValue) {
const state = this.normalizePermissionSet(rawValue);
return state.allAccess ? '*' : JSON.stringify(state.permissionIds);
}
async getPermissionIdsForRoles(roleIds, options = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const normalizedRoleIds = Array.from(new Set((roleIds || [])
.map(roleId => Number(roleId))
.filter(roleId => Number.isFinite(roleId) && roleId > 0)));
if (normalizedRoleIds.length === 0) {
return [];
}
const roleRows = await ctx.model.Role.findAll({
where: {
id: {
[Op.in]: normalizedRoleIds,
},
...(options.includeRoleDisabled === true ? {} : { status: 1 }),
},
attributes: [ 'id', 'permissions' ],
raw: true,
transaction: options.transaction,
});
if (!roleRows || roleRows.length === 0) {
return [];
}
const directPermissionIds = [];
let allAccess = false;
for (const row of roleRows) {
const state = this.normalizePermissionSet(row.permissions);
if (state.allAccess) {
allAccess = true;
break;
}
if (state.permissionIds.length > 0) {
directPermissionIds.push(...state.permissionIds);
}
}
const permissionWhere = {
status: options.includeDisabled === true ? { [Op.in]: [ 0, 1 ] } : 1,
};
const typeFilter = this.normalizeTypeFilter(options.type);
if (Array.isArray(typeFilter) && typeFilter.length > 0) {
permissionWhere.type = {
[Op.in]: typeFilter,
};
} else if (typeFilter) {
permissionWhere.type = typeFilter;
}
if (allAccess) {
const allPermissions = await ctx.model.Permission.findAll({
where: permissionWhere,
attributes: [ 'id' ],
raw: true,
transaction: options.transaction,
});
return Array.from(new Set(allPermissions
.map(item => Number(item.id))
.filter(item => Number.isFinite(item) && item > 0)));
}
const permissionIds = Array.from(new Set(directPermissionIds
.filter(item => Number.isFinite(item) && item > 0)));
if (permissionIds.length === 0) {
return [];
}
const permissions = await ctx.model.Permission.findAll({
where: {
...permissionWhere,
id: {
[Op.in]: permissionIds,
},
},
attributes: [ 'id' ],
raw: true,
transaction: options.transaction,
});
return Array.from(new Set(permissions
.map(item => Number(item.id))
.filter(item => Number.isFinite(item) && item > 0)));
}
async assignPermissions(roleId, permissionIds, options = {}) {
const { ctx } = this;
await ctx.model.Role.update({
permissions: this.serializePermissionSet(permissionIds),
updated_at: new Date(),
}, {
where: { id: roleId },
transaction: options.transaction,
});
return true;
}
async removePermissionsFromAllRoles(permissionIds, options = {}) {
const { ctx } = this;
const removeSet = new Set((permissionIds || [])
.map(item => Number(item))
.filter(item => Number.isFinite(item) && item > 0));
if (removeSet.size === 0) {
return 0;
}
const roleRows = await ctx.model.Role.findAll({
attributes: [ 'id', 'permissions' ],
transaction: options.transaction,
});
let updatedCount = 0;
for (const role of roleRows) {
const state = this.normalizePermissionSet(role.permissions);
if (state.allAccess || state.permissionIds.length === 0) {
continue;
}
const nextPermissionIds = state.permissionIds.filter(permissionId => !removeSet.has(Number(permissionId)));
if (nextPermissionIds.length === state.permissionIds.length) {
continue;
}
await role.update({
permissions: JSON.stringify(nextPermissionIds),
updated_at: new Date(),
}, {
transaction: options.transaction,
});
updatedCount++;
}
return updatedCount;
}
}
module.exports = RolePermissionService;