731 lines
21 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 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;
}
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', '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 ensureParentPermissionInScope(parentId) {
if (!parentId) {
return;
}
await this.getPermission(parentId, false);
const availableSet = await this.getAvailablePermissionIdSet({ includeDisabled: false });
if (!availableSet.has(Number(parentId))) {
throw this.createError(`parent_id 超出当前登录工号可用权限集:${parentId}`, 400);
}
}
async ensurePermissionsInAvailableScope(permissionIds, options = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const includeDisabled = options.includeDisabled === true;
const availableSet = await this.getAvailablePermissionIdSet({ includeDisabled });
if (availableSet.size === 0) {
throw this.createError('当前登录工号可用权限集为空,无法操作权限', 400);
}
const targetRows = await ctx.model.Permission.findAll({
where: {
id: permissionIds,
},
attributes: [ 'id', 'parent_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);
}
const parentMap = new Map(targetRows.map(item => [ Number(item.id), item.parent_id === null ? null : Number(item.parent_id) ]));
let pendingParentIds = Array.from(new Set(targetRows
.map(item => item.parent_id === null ? null : Number(item.parent_id))
.filter(parentId => Number.isFinite(parentId) && parentId > 0)));
while (pendingParentIds.length > 0) {
const fetchIds = pendingParentIds.filter(parentId => !parentMap.has(parentId));
if (fetchIds.length === 0) {
break;
}
const parentRows = await ctx.model.Permission.findAll({
where: {
id: {
[Op.in]: fetchIds,
},
},
attributes: [ 'id', 'parent_id' ],
raw: true,
});
for (const row of parentRows) {
parentMap.set(Number(row.id), row.parent_id === null ? null : Number(row.parent_id));
}
pendingParentIds = Array.from(new Set(parentRows
.map(row => row.parent_id === null ? null : Number(row.parent_id))
.filter(parentId => Number.isFinite(parentId) && parentId > 0 && !parentMap.has(parentId))));
}
const outOfScopeIds = [];
for (const permissionId of permissionIds) {
let currentId = Number(permissionId);
let inScope = false;
const visited = new Set();
while (Number.isFinite(currentId) && currentId > 0 && !visited.has(currentId)) {
visited.add(currentId);
if (availableSet.has(currentId)) {
inScope = true;
break;
}
const parentId = parentMap.has(currentId) ? parentMap.get(currentId) : null;
if (!Number.isFinite(parentId) || parentId <= 0) {
break;
}
currentId = Number(parentId);
}
if (!inScope) {
outOfScopeIds.push(Number(permissionId));
}
}
if (outOfScopeIds.length > 0) {
throw this.createError(`包含超出当前登录工号可用权限集的权限ID:${outOfScopeIds.join(',')}`, 400);
}
}
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, app } = this;
const { Op } = app.Sequelize;
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 [];
}
const rolePermissions = await ctx.model.RolePermission.findAll({
where: {
role_id: {
[Op.in]: roleIds,
},
},
attributes: [ 'permission_id' ],
raw: true,
});
return Array.from(new Set(rolePermissions
.map(item => Number(item.permission_id))
.filter(id => Number.isFinite(id) && id > 0)));
}
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 = '' } = {}) {
const { ctx, app } = this;
const { Op } = app.Sequelize;
const currentPermissionIds = await this.getCurrentEmployeePermissionIds();
if (currentPermissionIds.length === 0) {
return [];
}
const where = {
id: {
[Op.in]: currentPermissionIds,
},
status: includeDisabled ? { [Op.in]: [ 0, 1 ] } : 1,
type: {
[Op.notLike]: '%_pages',
},
};
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',
'meta_title',
],
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,
});
let selectedPermissionSet = new Set();
if (role) {
const rolePermissions = await ctx.model.RolePermission.findAll({
where: {
role_id: role.id,
},
attributes: [ 'permission_id' ],
});
selectedPermissionSet = new Set(rolePermissions.map(item => Number(item.permission_id)));
}
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),
meta_title: item.meta_title || '',
selected: role ? 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.ensureParentPermissionInScope(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.ensurePermissionsInAvailableScope(permissionIds, {
includeDisabled: true,
});
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.model.RolePermission.destroy({
where: {
permission_id: 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 { ctx } = this;
const permissionId = this.toPositiveNumber(data.permission_id || data.permissionId, 'permission_id');
await this.ensurePermissionsInAvailableScope([ permissionId ], {
includeDisabled: true,
});
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.ensureParentPermissionInScope(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;