WMS_MAIN/app/service/systems/auth/role_permission.js

211 lines
5.6 KiB
JavaScript

'use strict';
const Service = require('egg').Service;
class RolePermissionService extends Service {
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,
};
if (options.type) {
permissionWhere.type = options.type;
}
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;