Files
cal.diy/packages/trpc/server/routers/viewer/organizations/getUser.handler.ts
T
75465ac4bf feat: PBAC on team members page + org members page to use specific permissi… (#23004)
* PBAC on team members page + org members page to use specific permissions with fallbacks

* Implement checks on edit sheet fetch to check for permisisons

* WIP permission fixes

* fix tests

* WIP

* fix edit mode perms

* fix remove and list view permissions

* fix add

* feat: add pbac permissions for impersonation (#23035)

* registery + migration + i18n

* UI for can impersonate

* impersonation backend

* remove permission from db query

* add missing prisma import

* add resend invitation and edit mode checks for delete/changeRole

* fix canChangeRole

* canChangeRole gate

* fix permission logic

* fix depends on

* push migration

* fix migration

* fix scoped advanced permissions

* use listMembers instead of invite proxy

* remove isOrgAdmin check to rely on pbac

* wait for session to load before navigating

* use event-types testId to ensure session loaded

* use profile page instead of eventTypes

* use correct roles

* fix wait for session

* correct orgs private isFallBackRoles

* set a timeout on waiting for session

* remove adminOrOwner check since its in fallpack

---------

Co-authored-by: Volnei Munhoz <volnei.munhoz@gmail.com>
Co-authored-by: Eunjae Lee <hey@eunjae.dev>
2025-09-02 12:52:45 -03:00

133 lines
3.7 KiB
TypeScript

import { Resource, CustomAction } from "@calcom/features/pbac/domain/types/permission-registry";
import { getSpecificPermissions } from "@calcom/features/pbac/lib/resource-permissions";
import { prisma } from "@calcom/prisma";
import { MembershipRole } from "@calcom/prisma/enums";
import { TRPCError } from "@trpc/server";
import type { TrpcSessionUser } from "../../../types";
import type { TGetUserInput } from "./getUser.schema";
type AdminVerifyOptions = {
ctx: {
user: NonNullable<TrpcSessionUser>;
};
input: TGetUserInput;
};
export async function getUserHandler({ input, ctx }: AdminVerifyOptions) {
const currentUser = ctx.user;
if (!currentUser.organizationId) throw new TRPCError({ code: "UNAUTHORIZED" });
// Get user's membership role in the organization
const currentUserMembership = await prisma.membership.findFirst({
where: {
userId: currentUser.id,
teamId: currentUser.organizationId,
},
select: {
role: true,
},
});
if (!currentUserMembership) {
throw new TRPCError({ code: "UNAUTHORIZED", message: "User is not a member of this organization." });
}
// Check PBAC permissions for viewing/editing organization members
const permissions = await getSpecificPermissions({
userId: currentUser.id,
teamId: currentUser.organizationId,
resource: Resource.Organization,
userRole: currentUserMembership.role,
actions: [CustomAction.ListMembers, CustomAction.ChangeMemberRole],
fallbackRoles: {
[CustomAction.ListMembers]: {
roles: [MembershipRole.MEMBER, MembershipRole.ADMIN, MembershipRole.OWNER],
},
[CustomAction.ChangeMemberRole]: {
roles: [MembershipRole.ADMIN, MembershipRole.OWNER],
},
},
});
// User needs either ListMembers (to view) or ChangeMemberRole (to edit) permission
if (!permissions[CustomAction.ListMembers] || !permissions[CustomAction.ChangeMemberRole]) {
throw new TRPCError({ code: "UNAUTHORIZED" });
}
// get requested user from database and ensure they are in the same organization
const [requestedUser, membership, teams] = await prisma.$transaction([
prisma.user.findUnique({
where: { id: input.userId },
select: {
id: true,
email: true,
username: true,
name: true,
avatarUrl: true,
bio: true,
timeZone: true,
schedules: {
select: {
id: true,
name: true,
},
},
profiles: {
select: {
username: true,
},
},
},
}),
// Query on accepted as we don't want the user to be able to get this much info on a user that hasn't accepted the invite
prisma.membership.findFirst({
where: {
userId: input.userId,
teamId: currentUser.organizationId,
accepted: true,
},
select: {
role: true,
},
}),
prisma.membership.findMany({
where: {
userId: input.userId,
team: {
parentId: currentUser.organizationId,
},
},
select: {
team: {
select: {
id: true,
name: true,
},
},
accepted: true,
},
}),
]);
if (!requestedUser || !membership)
throw new TRPCError({ code: "UNAUTHORIZED", message: "user_not_exist_or_not_in_org" });
const foundUser = {
...requestedUser,
// Enrich with the users profile for the username or fall back to the username their account was created with.
username: requestedUser.profiles[0]?.username || requestedUser.username,
teams: teams.map((team) => ({
...team.team,
accepted: team.accepted,
})),
role: membership.role,
};
return foundUser;
}
export default getUserHandler;