root
511 lines
21 KiB
JavaScript
511 lines
21 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.listMenuItems = listMenuItems;
|
|
exports.getMenuItem = getMenuItem;
|
|
exports.createMenuItem = createMenuItem;
|
|
exports.updateMenuItem = updateMenuItem;
|
|
exports.setMenuItemStatus = setMenuItemStatus;
|
|
exports.deleteMenuItem = deleteMenuItem;
|
|
exports.assignMenuItemToPlans = assignMenuItemToPlans;
|
|
exports.removeMenuItemFromPlan = removeMenuItemFromPlan;
|
|
exports.assignMenuItemToCompanies = assignMenuItemToCompanies;
|
|
exports.removeMenuItemFromCompany = removeMenuItemFromCompany;
|
|
exports.previewCompanyMenu = previewCompanyMenu;
|
|
exports.getEmployeeMenu = getEmployeeMenu;
|
|
exports.listMenuAuditLogs = listMenuAuditLogs;
|
|
const errors_1 = require("../../http/errors");
|
|
const prisma_1 = require("../../lib/prisma");
|
|
const EMPLOYEE_ROLES = ['OWNER', 'MANAGER', 'AGENT'];
|
|
const MENU_AUDIT_RESOURCES = ['MenuItem', 'MenuSubscriptionAssignment', 'MenuCompanyAssignment', 'MenuRoleVisibility'];
|
|
const MENU_ITEM_TYPES_WITHOUT_ROUTE = new Set([
|
|
'PARENT_MENU',
|
|
'SECTION_LABEL',
|
|
'DIVIDER',
|
|
]);
|
|
function normalizeNullableString(value) {
|
|
if (typeof value !== 'string')
|
|
return null;
|
|
const trimmed = value.trim();
|
|
return trimmed.length > 0 ? trimmed : null;
|
|
}
|
|
function sortByDisplayOrder(items) {
|
|
return [...items].sort((a, b) => {
|
|
if (a.displayOrder !== b.displayOrder)
|
|
return a.displayOrder - b.displayOrder;
|
|
return (a.label ?? '').localeCompare(b.label ?? '');
|
|
});
|
|
}
|
|
function toPlanValue(plan) {
|
|
return plan;
|
|
}
|
|
function toItemTypeValue(itemType) {
|
|
return itemType;
|
|
}
|
|
function describeEntitlement(plan, hasSubscriptionAssignment, hasCompanyAssignment, defaultsToAllSubscriptions) {
|
|
if (hasCompanyAssignment)
|
|
return 'Visible because it is assigned directly to this company.';
|
|
if (defaultsToAllSubscriptions)
|
|
return 'Visible because this menu item defaults to all subscription plans.';
|
|
if (hasSubscriptionAssignment && plan)
|
|
return `Visible because ${plan} includes this menu item.`;
|
|
if (plan)
|
|
return `Hidden because ${plan} does not include this menu item.`;
|
|
return 'Hidden because the company does not have an active subscription assignment for this item.';
|
|
}
|
|
async function createAuditLog(admin, action, resource, resourceId, before, after) {
|
|
await prisma_1.prisma.auditLog.create({
|
|
data: {
|
|
adminUserId: admin.id,
|
|
action,
|
|
resource,
|
|
resourceId,
|
|
before: before === undefined ? undefined : JSON.parse(JSON.stringify(before)),
|
|
after: after === undefined ? undefined : JSON.parse(JSON.stringify(after)),
|
|
},
|
|
});
|
|
}
|
|
async function assertMenuItemPayload(input, menuItemId) {
|
|
const label = input.label.trim();
|
|
if (!label)
|
|
throw new errors_1.AppError('Menu label is required.', 400, 'validation_error');
|
|
const itemType = toItemTypeValue(input.itemType);
|
|
const routeOrUrl = normalizeNullableString(input.routeOrUrl);
|
|
const parentId = normalizeNullableString(input.parentId);
|
|
if (MENU_ITEM_TYPES_WITHOUT_ROUTE.has(itemType)) {
|
|
if (routeOrUrl) {
|
|
throw new errors_1.AppError('This menu item type cannot define a route or URL.', 400, 'validation_error');
|
|
}
|
|
}
|
|
else if (!routeOrUrl) {
|
|
throw new errors_1.AppError('Route or URL is required for this menu item type.', 400, 'validation_error');
|
|
}
|
|
if (routeOrUrl && itemType === 'EXTERNAL_LINK') {
|
|
if (!routeOrUrl.startsWith('https://')) {
|
|
throw new errors_1.AppError('External links must use HTTPS.', 400, 'validation_error');
|
|
}
|
|
}
|
|
if (routeOrUrl && itemType === 'INTERNAL_PAGE' && !routeOrUrl.startsWith('/')) {
|
|
throw new errors_1.AppError('Internal page routes must start with "/".', 400, 'validation_error');
|
|
}
|
|
if (parentId) {
|
|
if (menuItemId && parentId === menuItemId) {
|
|
throw new errors_1.AppError('A menu item cannot be its own parent.', 400, 'validation_error');
|
|
}
|
|
const parent = await prisma_1.prisma.menuItem.findUnique({ where: { id: parentId } });
|
|
if (!parent)
|
|
throw new errors_1.AppError('Parent menu item was not found.', 400, 'validation_error');
|
|
if (parent.itemType !== 'PARENT_MENU') {
|
|
throw new errors_1.AppError('Only parent menu items can contain children.', 400, 'validation_error');
|
|
}
|
|
}
|
|
if (routeOrUrl && !MENU_ITEM_TYPES_WITHOUT_ROUTE.has(itemType)) {
|
|
const duplicate = await prisma_1.prisma.menuItem.findFirst({
|
|
where: {
|
|
routeOrUrl,
|
|
parentId,
|
|
...(menuItemId ? { id: { not: menuItemId } } : {}),
|
|
},
|
|
select: { id: true },
|
|
});
|
|
if (duplicate) {
|
|
throw new errors_1.AppError('Duplicate route under the same parent is not allowed.', 409, 'duplicate_menu_route');
|
|
}
|
|
}
|
|
const roles = Array.from(new Set(input.roles ?? []));
|
|
if (roles.some((role) => !EMPLOYEE_ROLES.includes(role))) {
|
|
throw new errors_1.AppError('One or more role visibility values are invalid.', 400, 'validation_error');
|
|
}
|
|
const companyIds = Array.from(new Set((input.companyAssignments ?? []).map((assignment) => assignment.companyId)));
|
|
if (companyIds.length > 0) {
|
|
const companies = await prisma_1.prisma.company.findMany({
|
|
where: { id: { in: companyIds }, status: { not: 'CANCELLED' } },
|
|
select: { id: true },
|
|
});
|
|
if (companies.length !== companyIds.length) {
|
|
throw new errors_1.AppError('Menu items can only be assigned to active companies.', 400, 'validation_error');
|
|
}
|
|
}
|
|
}
|
|
async function syncMenuAssignments(tx, menuItemId, input) {
|
|
await tx.menuItemRoleVisibility.deleteMany({ where: { menuItemId } });
|
|
if ((input.roles ?? []).length > 0) {
|
|
await tx.menuItemRoleVisibility.createMany({
|
|
data: Array.from(new Set(input.roles)).map((role) => ({ menuItemId, role })),
|
|
});
|
|
}
|
|
await tx.subscriptionMenuItem.deleteMany({ where: { menuItemId } });
|
|
if ((input.subscriptionPlans ?? []).length > 0) {
|
|
await tx.subscriptionMenuItem.createMany({
|
|
data: input.subscriptionPlans.map((assignment) => ({
|
|
menuItemId,
|
|
plan: toPlanValue(assignment.plan),
|
|
displayOrder: assignment.displayOrder ?? input.displayOrder ?? 0,
|
|
isActive: assignment.isActive ?? true,
|
|
})),
|
|
});
|
|
}
|
|
await tx.companyMenuItem.deleteMany({ where: { menuItemId } });
|
|
if ((input.companyAssignments ?? []).length > 0) {
|
|
await tx.companyMenuItem.createMany({
|
|
data: input.companyAssignments.map((assignment) => ({
|
|
menuItemId,
|
|
companyId: assignment.companyId,
|
|
displayOrder: assignment.displayOrder ?? input.displayOrder ?? 0,
|
|
isActive: assignment.isActive ?? true,
|
|
})),
|
|
});
|
|
}
|
|
}
|
|
async function loadMenuItemDetail(id) {
|
|
return prisma_1.prisma.menuItem.findUniqueOrThrow({
|
|
where: { id },
|
|
include: {
|
|
parent: { select: { id: true, label: true } },
|
|
children: { select: { id: true, label: true } },
|
|
roleVisibilities: { orderBy: { role: 'asc' } },
|
|
subscriptionAssignments: { orderBy: [{ plan: 'asc' }, { displayOrder: 'asc' }] },
|
|
companyAssignments: {
|
|
include: { company: { select: { id: true, name: true } } },
|
|
orderBy: [{ displayOrder: 'asc' }, { companyId: 'asc' }],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
async function listMenuItems() {
|
|
return prisma_1.prisma.menuItem.findMany({
|
|
include: {
|
|
parent: { select: { id: true, label: true } },
|
|
roleVisibilities: { orderBy: { role: 'asc' } },
|
|
subscriptionAssignments: { orderBy: [{ plan: 'asc' }, { displayOrder: 'asc' }] },
|
|
companyAssignments: {
|
|
include: { company: { select: { id: true, name: true } } },
|
|
orderBy: [{ displayOrder: 'asc' }, { companyId: 'asc' }],
|
|
},
|
|
},
|
|
orderBy: [{ displayOrder: 'asc' }, { createdAt: 'asc' }],
|
|
});
|
|
}
|
|
async function getMenuItem(id) {
|
|
return loadMenuItemDetail(id);
|
|
}
|
|
async function createMenuItem(input, admin) {
|
|
await assertMenuItemPayload(input);
|
|
const created = await prisma_1.prisma.$transaction(async (tx) => {
|
|
const menuItem = await tx.menuItem.create({
|
|
data: {
|
|
systemKey: normalizeNullableString(input.systemKey) ?? undefined,
|
|
label: input.label.trim(),
|
|
itemType: toItemTypeValue(input.itemType),
|
|
routeOrUrl: normalizeNullableString(input.routeOrUrl) ?? undefined,
|
|
icon: normalizeNullableString(input.icon) ?? undefined,
|
|
parentId: normalizeNullableString(input.parentId) ?? undefined,
|
|
displayOrder: input.displayOrder ?? 0,
|
|
openInNewTab: input.openInNewTab ?? false,
|
|
isRequired: input.isRequired ?? false,
|
|
isActive: input.isActive ?? true,
|
|
createdBy: admin.id,
|
|
updatedBy: admin.id,
|
|
},
|
|
});
|
|
await syncMenuAssignments(tx, menuItem.id, input);
|
|
return menuItem;
|
|
});
|
|
const detail = await loadMenuItemDetail(created.id);
|
|
await createAuditLog(admin, 'CREATE_MENU_ITEM', 'MenuItem', created.id, undefined, detail);
|
|
return detail;
|
|
}
|
|
async function updateMenuItem(id, input, admin) {
|
|
const before = await loadMenuItemDetail(id);
|
|
await assertMenuItemPayload(input, id);
|
|
const updated = await prisma_1.prisma.$transaction(async (tx) => {
|
|
const menuItem = await tx.menuItem.update({
|
|
where: { id },
|
|
data: {
|
|
systemKey: normalizeNullableString(input.systemKey) ?? undefined,
|
|
label: input.label.trim(),
|
|
itemType: toItemTypeValue(input.itemType),
|
|
routeOrUrl: normalizeNullableString(input.routeOrUrl) ?? undefined,
|
|
icon: normalizeNullableString(input.icon) ?? undefined,
|
|
parentId: normalizeNullableString(input.parentId) ?? undefined,
|
|
displayOrder: input.displayOrder ?? 0,
|
|
openInNewTab: input.openInNewTab ?? false,
|
|
isRequired: input.isRequired ?? false,
|
|
isActive: input.isActive ?? true,
|
|
updatedBy: admin.id,
|
|
},
|
|
});
|
|
await syncMenuAssignments(tx, id, input);
|
|
return menuItem;
|
|
});
|
|
const detail = await loadMenuItemDetail(updated.id);
|
|
await createAuditLog(admin, 'UPDATE_MENU_ITEM', 'MenuItem', id, before, detail);
|
|
return detail;
|
|
}
|
|
async function setMenuItemStatus(id, isActive, admin) {
|
|
const before = await prisma_1.prisma.menuItem.findUniqueOrThrow({ where: { id } });
|
|
if (!isActive && before.isRequired && admin.role !== 'SUPER_ADMIN') {
|
|
throw new errors_1.AppError('Required system items can only be disabled by a Super Admin.', 403, 'forbidden');
|
|
}
|
|
const updated = await prisma_1.prisma.menuItem.update({
|
|
where: { id },
|
|
data: { isActive, updatedBy: admin.id },
|
|
});
|
|
await createAuditLog(admin, isActive ? 'ENABLE_MENU_ITEM' : 'DISABLE_MENU_ITEM', 'MenuItem', id, { isActive: before.isActive }, { isActive: updated.isActive });
|
|
return updated;
|
|
}
|
|
async function deleteMenuItem(id, admin) {
|
|
const before = await loadMenuItemDetail(id);
|
|
if (before.isRequired && admin.role !== 'SUPER_ADMIN') {
|
|
throw new errors_1.AppError('Required system items can only be deleted by a Super Admin.', 403, 'forbidden');
|
|
}
|
|
await prisma_1.prisma.menuItem.delete({ where: { id } });
|
|
await createAuditLog(admin, 'DELETE_MENU_ITEM', 'MenuItem', id, before, undefined);
|
|
}
|
|
async function assignMenuItemToPlans(id, assignments, admin) {
|
|
await prisma_1.prisma.menuItem.findUniqueOrThrow({ where: { id } });
|
|
const payload = assignments.map((assignment) => ({
|
|
menuItemId: id,
|
|
plan: toPlanValue(assignment.plan),
|
|
displayOrder: assignment.displayOrder ?? 0,
|
|
isActive: assignment.isActive ?? true,
|
|
}));
|
|
await prisma_1.prisma.subscriptionMenuItem.deleteMany({
|
|
where: { menuItemId: id, plan: { in: payload.map((assignment) => assignment.plan) } },
|
|
});
|
|
if (payload.length > 0) {
|
|
await prisma_1.prisma.subscriptionMenuItem.createMany({ data: payload });
|
|
}
|
|
await createAuditLog(admin, 'ASSIGN_MENU_ITEM_TO_SUBSCRIPTIONS', 'MenuSubscriptionAssignment', id, undefined, payload);
|
|
return loadMenuItemDetail(id);
|
|
}
|
|
async function removeMenuItemFromPlan(id, plan, admin) {
|
|
await prisma_1.prisma.subscriptionMenuItem.deleteMany({
|
|
where: {
|
|
menuItemId: id,
|
|
plan: toPlanValue(plan),
|
|
},
|
|
});
|
|
await createAuditLog(admin, 'REMOVE_MENU_ITEM_FROM_SUBSCRIPTION', 'MenuSubscriptionAssignment', id, { plan }, undefined);
|
|
return loadMenuItemDetail(id);
|
|
}
|
|
async function assignMenuItemToCompanies(id, assignments, admin) {
|
|
await prisma_1.prisma.menuItem.findUniqueOrThrow({ where: { id } });
|
|
const companyIds = assignments.map((assignment) => assignment.companyId);
|
|
const companies = await prisma_1.prisma.company.findMany({
|
|
where: { id: { in: companyIds }, status: { not: 'CANCELLED' } },
|
|
select: { id: true },
|
|
});
|
|
if (companies.length !== new Set(companyIds).size) {
|
|
throw new errors_1.AppError('Menu items can only be assigned to active companies.', 400, 'validation_error');
|
|
}
|
|
await prisma_1.prisma.companyMenuItem.deleteMany({
|
|
where: {
|
|
menuItemId: id,
|
|
companyId: { in: companyIds },
|
|
},
|
|
});
|
|
if (assignments.length > 0) {
|
|
await prisma_1.prisma.companyMenuItem.createMany({
|
|
data: assignments.map((assignment) => ({
|
|
menuItemId: id,
|
|
companyId: assignment.companyId,
|
|
displayOrder: assignment.displayOrder ?? 0,
|
|
isActive: assignment.isActive ?? true,
|
|
})),
|
|
});
|
|
}
|
|
await createAuditLog(admin, 'ASSIGN_MENU_ITEM_TO_COMPANIES', 'MenuCompanyAssignment', id, undefined, assignments);
|
|
return loadMenuItemDetail(id);
|
|
}
|
|
async function removeMenuItemFromCompany(id, companyId, admin) {
|
|
await prisma_1.prisma.companyMenuItem.deleteMany({
|
|
where: { menuItemId: id, companyId },
|
|
});
|
|
await createAuditLog(admin, 'REMOVE_MENU_ITEM_FROM_COMPANY', 'MenuCompanyAssignment', id, { companyId }, undefined);
|
|
return loadMenuItemDetail(id);
|
|
}
|
|
async function getMenuEvaluationContext(companyId, role, employeeIsActive = true) {
|
|
const company = await prisma_1.prisma.company.findUniqueOrThrow({
|
|
where: { id: companyId },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
status: true,
|
|
subscription: {
|
|
select: {
|
|
plan: true,
|
|
status: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
const menuItems = await prisma_1.prisma.menuItem.findMany({
|
|
include: {
|
|
roleVisibilities: true,
|
|
subscriptionAssignments: true,
|
|
companyAssignments: {
|
|
where: { companyId },
|
|
},
|
|
},
|
|
orderBy: [{ displayOrder: 'asc' }, { createdAt: 'asc' }],
|
|
});
|
|
const currentPlan = company.subscription?.plan ?? null;
|
|
const currentPlanName = currentPlan;
|
|
const evaluated = menuItems.map((item) => {
|
|
const defaultsToAllSubscriptions = item.subscriptionAssignments.length === 0;
|
|
const subscriptionAssignment = item.subscriptionAssignments.find((assignment) => assignment.isActive && (!currentPlan || assignment.plan === currentPlan));
|
|
const companyAssignment = item.companyAssignments.find((assignment) => assignment.isActive);
|
|
const roleAllowed = item.roleVisibilities.length === 0 || item.roleVisibilities.some((visibility) => visibility.role === role);
|
|
const subscriptionEntitled = Boolean(subscriptionAssignment || (defaultsToAllSubscriptions && currentPlan));
|
|
const entitled = Boolean(subscriptionEntitled || companyAssignment);
|
|
const visible = Boolean(item.isActive && entitled && roleAllowed && employeeIsActive);
|
|
const displayOrder = companyAssignment?.displayOrder ?? subscriptionAssignment?.displayOrder ?? item.displayOrder;
|
|
const reasons = [];
|
|
if (!item.isActive)
|
|
reasons.push('Hidden because the menu item is inactive.');
|
|
if (!employeeIsActive)
|
|
reasons.push('Hidden because the user account is inactive.');
|
|
if (!entitled)
|
|
reasons.push(describeEntitlement(currentPlanName, false, false, false));
|
|
if (entitled) {
|
|
reasons.push(describeEntitlement(currentPlanName, Boolean(subscriptionAssignment), Boolean(companyAssignment), Boolean(defaultsToAllSubscriptions && !companyAssignment)));
|
|
}
|
|
if (!roleAllowed)
|
|
reasons.push(`Hidden because the ${role} role is not allowed to see this item.`);
|
|
return {
|
|
id: item.id,
|
|
systemKey: item.systemKey,
|
|
label: item.label ?? '',
|
|
itemType: item.itemType,
|
|
routeOrUrl: item.routeOrUrl,
|
|
icon: item.icon,
|
|
parentId: item.parentId,
|
|
openInNewTab: item.openInNewTab,
|
|
isRequired: item.isRequired,
|
|
isActive: item.isActive,
|
|
displayOrder,
|
|
source: companyAssignment ? 'company' : subscriptionEntitled ? 'subscription' : 'none',
|
|
visible,
|
|
reasons,
|
|
};
|
|
});
|
|
return {
|
|
company,
|
|
role,
|
|
currentPlan: currentPlanName,
|
|
items: sortByDisplayOrder(evaluated),
|
|
};
|
|
}
|
|
function buildMenuTree(items) {
|
|
const byId = new Map();
|
|
const roots = [];
|
|
for (const item of items) {
|
|
byId.set(item.id, {
|
|
id: item.id,
|
|
systemKey: item.systemKey,
|
|
label: item.label ?? '',
|
|
itemType: item.itemType,
|
|
routeOrUrl: item.routeOrUrl,
|
|
icon: item.icon,
|
|
parentId: item.parentId,
|
|
openInNewTab: item.openInNewTab,
|
|
displayOrder: item.displayOrder,
|
|
children: [],
|
|
});
|
|
}
|
|
for (const item of items) {
|
|
const node = byId.get(item.id);
|
|
if (item.parentId && byId.has(item.parentId)) {
|
|
byId.get(item.parentId).children.push(node);
|
|
}
|
|
else {
|
|
roots.push(node);
|
|
}
|
|
}
|
|
const sortTree = (nodes) => {
|
|
nodes.sort((a, b) => {
|
|
if (a.displayOrder !== b.displayOrder)
|
|
return a.displayOrder - b.displayOrder;
|
|
return a.label.localeCompare(b.label);
|
|
});
|
|
nodes.forEach((node) => sortTree(node.children));
|
|
};
|
|
sortTree(roots);
|
|
return roots;
|
|
}
|
|
async function previewCompanyMenu(input) {
|
|
const context = await getMenuEvaluationContext(input.companyId, input.role);
|
|
return {
|
|
company: context.company,
|
|
role: context.role,
|
|
subscriptionPlan: context.currentPlan,
|
|
items: context.items,
|
|
finalMenu: buildMenuTree(context.items
|
|
.filter((item) => item.visible)
|
|
.map((item) => ({
|
|
id: item.id,
|
|
systemKey: item.systemKey,
|
|
label: item.label,
|
|
itemType: item.itemType,
|
|
routeOrUrl: item.routeOrUrl,
|
|
icon: item.icon,
|
|
parentId: item.parentId,
|
|
openInNewTab: item.openInNewTab,
|
|
displayOrder: item.displayOrder,
|
|
}))),
|
|
};
|
|
}
|
|
async function getEmployeeMenu(employeeId) {
|
|
const employee = await prisma_1.prisma.employee.findUniqueOrThrow({
|
|
where: { id: employeeId },
|
|
select: {
|
|
id: true,
|
|
role: true,
|
|
isActive: true,
|
|
companyId: true,
|
|
},
|
|
});
|
|
const context = await getMenuEvaluationContext(employee.companyId, employee.role, employee.isActive);
|
|
const visibleItems = context.items.filter((item) => item.visible);
|
|
return {
|
|
companyId: employee.companyId,
|
|
role: employee.role,
|
|
subscriptionPlan: context.currentPlan,
|
|
items: buildMenuTree(visibleItems.map((item) => ({
|
|
id: item.id,
|
|
systemKey: item.systemKey,
|
|
label: item.label,
|
|
itemType: item.itemType,
|
|
routeOrUrl: item.routeOrUrl,
|
|
icon: item.icon,
|
|
parentId: item.parentId,
|
|
openInNewTab: item.openInNewTab,
|
|
displayOrder: item.displayOrder,
|
|
}))),
|
|
};
|
|
}
|
|
async function listMenuAuditLogs(query) {
|
|
const where = {
|
|
resource: {
|
|
in: MENU_AUDIT_RESOURCES,
|
|
},
|
|
};
|
|
const [data, total] = await Promise.all([
|
|
prisma_1.prisma.auditLog.findMany({
|
|
where,
|
|
include: { adminUser: { select: { firstName: true, lastName: true, email: true } } },
|
|
skip: (query.page - 1) * query.pageSize,
|
|
take: query.pageSize,
|
|
orderBy: { createdAt: 'desc' },
|
|
}),
|
|
prisma_1.prisma.auditLog.count({ where }),
|
|
]);
|
|
return {
|
|
data,
|
|
total,
|
|
page: query.page,
|
|
pageSize: query.pageSize,
|
|
totalPages: Math.ceil(total / query.pageSize),
|
|
};
|
|
}
|
|
//# sourceMappingURL=menu.service.js.map
|