* Add profile table Copy to profile table Update schema Migrations * wip * Get switcher working * Add organization seeder * wip * Remove dead code * Fix unit tests * relevantProfile -> profile * cache bust * One more comment * Squash migrations * Copy to profile table * Update schema * Fix existing user invite flow * Add profile table * Copy to profile table * Update schema * Format * Add profile table Copy to profile table Update schema Migrations * Format * wip Get switcher working Add organization seeder wip Remove dead code Fix unit tests relevantProfile -> profile cache bust One more comment Squash migrations Copy to profile table Update schema Fix existing user invite flow Add profile table Copy to profile table Update schema chore: small improvements to signup (#13227) * removed features on mobile, better background color * nit * dark mode nits New Crowdin translations by Github Action fix: event reschedule workflow trigger (#13122) * fix event reschedule workflow trigger * uncomment previously failed test * review fix --------- Co-authored-by: Joe Au-Yeung <65426560+joeauyeung@users.noreply.github.com> Co-authored-by: CarinaWolli <wollencarina@gmail.com> chore: added community support to help (#13213) refactor: Abstract `handleSeats` from `handleNewBooking` (#12062) * Refactor createBooking * Type fix * Abstract handleSeats * Create Invitee type * Create OrganizerUser type * Abstract addVideoCallDataToEvt * Abstract createLoggerWithEventDetails * Abstract `handleAppStatus` from handler * Create ReqAppsStatus type * Move `deleteMeeting` and `getCalendar` * Set parameters for `handleSeats` * Typescript refactor * Change function params from req * Type fix --------- Co-authored-by: Morgan <33722304+ThyMinimalDev@users.noreply.github.com> Co-authored-by: Erik <erik@erosemberg.com> fix: Dynamic group booking org-migration redirect (#13223) * fix: Dynamic group booking redirect * Fix flaky private team test test: Check availability tab and all your functions (teste2e-availability) (#12434) * add changes * add changes * add changes * add changes * Requested changes * Change way to grab element --------- Co-authored-by: gitstart-calcom <gitstart-calcom@users.noreply.github.com> Co-authored-by: gitstart-calcom <gitstart@users.noreply.github.com> Co-authored-by: Morgan <33722304+ThyMinimalDev@users.noreply.github.com> Co-authored-by: Keith Williams <keithwillcode@gmail.com> Co-authored-by: Joe Au-Yeung <65426560+joeauyeung@users.noreply.github.com> fix: Reschedule a cancelled booking (#13170) * fix: Reschedule a cancelled booking * canceled instead of cancelled --------- Co-authored-by: Joe Au-Yeung <65426560+joeauyeung@users.noreply.github.com> Co-authored-by: Carina Wollendorfer <30310907+CarinaWolli@users.noreply.github.com> v3.7.0 test: In Team Event type when location is Organizer Default App and U… (#12939) * test: In Team Event type when location is Organizer Default App and User Metadata is emoty * chore: use variable * fix: type error test: add test for invalid cal video (#13103) * test: add test for invalid cal video * chore: add confirm * chore: fix type error * chore: update code * test: add unit test * chore: type error * chore * chore: type * chore: fix test * chore --------- Co-authored-by: Carina Wollendorfer <30310907+CarinaWolli@users.noreply.github.com> chore: add error message for no availability (#13230) * chore: add error message for no default user availability * chore: check only availability * chore: change message * chore: add eventType fix: Team revert with members (#13228) refactor: Refactor seats logic (#12905) * Refactor createBooking * Type fix * Abstract handleSeats * Create Invitee type * Create OrganizerUser type * Abstract addVideoCallDataToEvt * Abstract createLoggerWithEventDetails * Abstract `handleAppStatus` from handler * Create ReqAppsStatus type * Move `deleteMeeting` and `getCalendar` * Set parameters for `handleSeats` * Typescript refactor * Change function params from req * Type fix * Move handleSeats * Abstract lastAttendeeDeleteBooking * Create function for rescheduling seated events * Fix imports on reschedule seats function * Fix imports * Import handleSeats function * Fix rescheduleUid type * Refactor owner reschedule to new time slot * Refactor combine two booking times together * Reschedule as an attendee * Refactor createNewSeat * Remove old handleSeats * Remove lastAttendeeDeleteBooking from handleNewBooking * Test for new attendee right params are passed * Unit test params for reschedule * Typo fix * Clean up * Create new seat test * Test when attendee already signs up for booking * Type fix * Test reschedule move attendee to existing booking * On reschedule create new booking * Test on last attendee cancel booking * Owner reschedule to new time slot * Owner rescheduling, merge two bookings together * Test: when merging more than available seats, then fail * Test: fail when event is full * Remove duplicate E2E tests * Clean up * Rename `addVideoCallDataToEvt` to `addVideoCallDataToEvent` * Refactor `calcAppsStatus` * Assign `evt` to resutl of `addVideoCallDataToEvent` * Use prisma.transaction when moving attendees * Clean create seat call * Use ErrorCode enum * Use attendeeRescheduledSeatedBooking function * Await function * Prevent double triggering of workflows * Use inviteeToAdd in createNewSeat * Remove unused error code * Remove old handleSeats file * Type fix * Type fix * Type fix * Type fix * Type fix * Type fix * Type fix * Type fix --------- Co-authored-by: Morgan <33722304+ThyMinimalDev@users.noreply.github.com> Co-authored-by: Peer Richelsen <peeroke@gmail.com> Co-authored-by: Erik <erik@erosemberg.com> feat: Allow admins to filter bookings only by attendee emails (#13236) * chore: Allow admins to filter bookings only by attendee emails * Fix type error Fixed [CAL-2930] Org branding isnt centered in shell #13225 (#13237) Add profile table Copy to profile table Update schema Migrations Format * wip * Add profile relation everywhere * Fix schema * Fix invite handler * Add profileId during eventTypec reation * Get dashboard working with profile relatioon * Add workflow create repository * Add profileId to host * Add profileId to credential table * Add destinationCalendar repository * Add profileId to membership * Revert all profile related changes * Add acme and dunder * Fix membership profileId usgae * Various fixes * Some renaming * Fix failing tests * Debugging next-aut * Consolidate migrations * Testing fixes * Fix unit tests * Self review feedback * PR feedback * Fix orgMigration as well * Add profile schema and copy users to it * Remove migrations from here * Fix type issues * Fix type error after main merge * Remove movedFromUserId * Add missing migration file * Self review addressed * Joe's review addressed * Fix profile switcher --------- Co-authored-by: Joe Au-Yeung <65426560+joeauyeung@users.noreply.github.com>
337 lines
8.8 KiB
TypeScript
337 lines
8.8 KiB
TypeScript
import { whereClauseForOrgWithSlugOrRequestedSlug } from "@calcom/ee/organizations/lib/orgDomains";
|
|
import prisma from "@calcom/prisma";
|
|
import type { UpId, UserProfile } from "@calcom/types/UserProfile";
|
|
|
|
import { isOrganization } from "../../entityPermissionUtils";
|
|
import logger from "../../logger";
|
|
import { safeStringify } from "../../safeStringify";
|
|
import { ProfileRepository } from "./profile";
|
|
import { getParsedTeam } from "./teamUtils";
|
|
import type { User as UserType, Prisma } from ".prisma/client";
|
|
|
|
const log = logger.getSubLogger({ prefix: ["[repository/user]"] });
|
|
|
|
export const ORGANIZATION_ID_UNKNOWN = "ORGANIZATION_ID_UNKNOWN";
|
|
export class UserRepository {
|
|
static async findTeamsByUserId({ userId }: { userId: UserType["id"] }) {
|
|
const teamMemberships = await prisma.membership.findMany({
|
|
where: {
|
|
userId: userId,
|
|
},
|
|
include: {
|
|
team: true,
|
|
},
|
|
});
|
|
|
|
const acceptedTeamMemberships = teamMemberships.filter((membership) => membership.accepted);
|
|
const pendingTeamMemberships = teamMemberships.filter((membership) => !membership.accepted);
|
|
|
|
return {
|
|
teams: acceptedTeamMemberships.map((membership) => membership.team),
|
|
memberships: teamMemberships,
|
|
acceptedTeamMemberships,
|
|
pendingTeamMemberships,
|
|
};
|
|
}
|
|
|
|
static async findOrganizations({ userId }: { userId: UserType["id"] }) {
|
|
const { acceptedTeamMemberships } = await UserRepository.findTeamsByUserId({
|
|
userId,
|
|
});
|
|
|
|
const acceptedOrgMemberships = acceptedTeamMemberships.filter((membership) =>
|
|
isOrganization({ team: membership.team })
|
|
);
|
|
|
|
const organizations = acceptedOrgMemberships.map((membership) => membership.team);
|
|
|
|
return {
|
|
organizations,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* It is aware of the fact that a user can be part of multiple organizations.
|
|
*/
|
|
static async findUsersByUsername({
|
|
orgSlug,
|
|
usernameList,
|
|
}: {
|
|
orgSlug: string | null;
|
|
usernameList: string[];
|
|
}) {
|
|
const { where, profiles } = await UserRepository._getWhereClauseForFindingUsersByUsername({
|
|
orgSlug,
|
|
usernameList,
|
|
});
|
|
|
|
log.debug("findUsersByUsername", safeStringify({ where, profiles }));
|
|
|
|
return (
|
|
await prisma.user.findMany({
|
|
where,
|
|
})
|
|
).map((user) => {
|
|
// User isn't part of any organization
|
|
if (!profiles) {
|
|
return {
|
|
...user,
|
|
profile: ProfileRepository.buildPersonalProfileFromUser({ user }),
|
|
};
|
|
}
|
|
const profile = profiles.find((profile) => profile.user.id === user.id) ?? null;
|
|
if (!profile) {
|
|
log.error("Profile not found for user", safeStringify({ user, profiles }));
|
|
// Profile must be there because profile itself was used to retrieve the user
|
|
throw new Error("Profile couldn't be found");
|
|
}
|
|
const { user: _1, ...profileWithoutUser } = profile;
|
|
return {
|
|
...user,
|
|
profile: profileWithoutUser,
|
|
};
|
|
});
|
|
}
|
|
|
|
static async _getWhereClauseForFindingUsersByUsername({
|
|
orgSlug,
|
|
usernameList,
|
|
}: {
|
|
orgSlug: string | null;
|
|
usernameList: string[];
|
|
}) {
|
|
// Lookup in profiles because that's where the organization usernames exist
|
|
const profiles = orgSlug
|
|
? (
|
|
await ProfileRepository.findManyByOrgSlugOrRequestedSlug({
|
|
orgSlug: orgSlug,
|
|
usernames: usernameList,
|
|
})
|
|
).map((profile) => ({
|
|
...profile,
|
|
organization: getParsedTeam(profile.organization),
|
|
}))
|
|
: null;
|
|
|
|
const where = profiles
|
|
? {
|
|
// Get UserIds from profiles
|
|
id: {
|
|
in: profiles.map((profile) => profile.user.id),
|
|
},
|
|
}
|
|
: {
|
|
username: {
|
|
in: usernameList,
|
|
},
|
|
...(orgSlug
|
|
? {
|
|
organization: whereClauseForOrgWithSlugOrRequestedSlug(orgSlug),
|
|
}
|
|
: {
|
|
organization: null,
|
|
}),
|
|
};
|
|
|
|
return { where, profiles };
|
|
}
|
|
|
|
static async findByEmailAndIncludeProfiles({ email }: { email: string }) {
|
|
const user = await prisma.user.findUnique({
|
|
where: {
|
|
email: email.toLowerCase(),
|
|
},
|
|
select: {
|
|
locked: true,
|
|
role: true,
|
|
id: true,
|
|
username: true,
|
|
name: true,
|
|
email: true,
|
|
metadata: true,
|
|
identityProvider: true,
|
|
password: true,
|
|
twoFactorEnabled: true,
|
|
twoFactorSecret: true,
|
|
backupCodes: true,
|
|
locale: true,
|
|
teams: {
|
|
include: {
|
|
team: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!user) {
|
|
return null;
|
|
}
|
|
|
|
const allProfiles = await ProfileRepository.findAllProfilesForUserIncludingMovedUser(user);
|
|
return {
|
|
...user,
|
|
allProfiles,
|
|
};
|
|
}
|
|
|
|
static async findById({ id }: { id: number }) {
|
|
const user = await prisma.user.findUnique({
|
|
where: {
|
|
id,
|
|
},
|
|
});
|
|
|
|
if (!user) {
|
|
return null;
|
|
}
|
|
return user;
|
|
}
|
|
|
|
static async findManyByOrganization({ organizationId }: { organizationId: number }) {
|
|
const profiles = await ProfileRepository.findManyForOrg({ organizationId });
|
|
return profiles.map((profile) => profile.user);
|
|
}
|
|
|
|
static isAMemberOfOrganization({
|
|
user,
|
|
organizationId,
|
|
}: {
|
|
user: { profiles: { organizationId: number }[] };
|
|
organizationId: number;
|
|
}) {
|
|
return user.profiles.some((profile) => profile.organizationId === organizationId);
|
|
}
|
|
|
|
static async enrichUserWithTheProfile<T extends { username: string | null; id: number }>({
|
|
user,
|
|
upId,
|
|
}: {
|
|
user: T;
|
|
upId: UpId;
|
|
}) {
|
|
log.debug("enrichUserWithTheProfile", safeStringify({ user, upId }));
|
|
const profile = await ProfileRepository.findByUpId(upId);
|
|
if (!profile) {
|
|
return {
|
|
...user,
|
|
profile: ProfileRepository.buildPersonalProfileFromUser({ user }),
|
|
};
|
|
}
|
|
return {
|
|
...user,
|
|
profile,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Use this method if you don't directly has the profileId.
|
|
* It can happen in two cases:
|
|
* 1. While dealing with a User that hasn't been added to any organization yet and thus have no Profile entries.
|
|
* 2. While dealing with a User that has been moved to a Profile i.e. he was invited to an organization when he was an existing user.
|
|
*/
|
|
static async enrichUserWithItsProfile<T extends { id: number; username: string | null }>({
|
|
user,
|
|
}: {
|
|
user: T;
|
|
}): Promise<T & { profile: UserProfile }> {
|
|
const profiles = await ProfileRepository.findManyForUser({ id: user.id });
|
|
if (profiles.length) {
|
|
const profile = profiles[0];
|
|
return {
|
|
...user,
|
|
username: profile.username,
|
|
profile,
|
|
};
|
|
}
|
|
|
|
// If no organization profile exists, use the personal profile so that the returned user is normalized to have a profile always
|
|
return {
|
|
...user,
|
|
profile: ProfileRepository.buildPersonalProfileFromUser({ user }),
|
|
};
|
|
}
|
|
|
|
static async enrichEntityWithProfile<
|
|
T extends
|
|
| {
|
|
profile: {
|
|
id: number;
|
|
username: string | null;
|
|
organizationId: number | null;
|
|
organization?: {
|
|
id: number;
|
|
name: string;
|
|
calVideoLogo: string | null;
|
|
slug: string | null;
|
|
metadata: Prisma.JsonValue;
|
|
};
|
|
};
|
|
}
|
|
| {
|
|
user: {
|
|
username: string | null;
|
|
id: number;
|
|
};
|
|
}
|
|
>(entity: T) {
|
|
if ("profile" in entity) {
|
|
const { profile, ...entityWithoutProfile } = entity;
|
|
const { organization, ...profileWithoutOrganization } = profile || {};
|
|
const parsedOrg = organization ? getParsedTeam(organization) : null;
|
|
|
|
const ret = {
|
|
...entityWithoutProfile,
|
|
profile: {
|
|
...profileWithoutOrganization,
|
|
...(parsedOrg
|
|
? {
|
|
organization: parsedOrg,
|
|
}
|
|
: {
|
|
organization: null,
|
|
}),
|
|
},
|
|
};
|
|
return ret;
|
|
} else {
|
|
const profiles = await ProfileRepository.findManyForUser(entity.user);
|
|
if (!profiles.length) {
|
|
return {
|
|
...entity,
|
|
profile: ProfileRepository.buildPersonalProfileFromUser({ user: entity.user }),
|
|
};
|
|
} else {
|
|
return {
|
|
...entity,
|
|
profile: profiles[0],
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
static async updateWhereId({
|
|
whereId,
|
|
data,
|
|
}: {
|
|
whereId: number;
|
|
data: {
|
|
movedToProfileId?: number | null;
|
|
};
|
|
}) {
|
|
return prisma.user.update({
|
|
where: {
|
|
id: whereId,
|
|
},
|
|
data: {
|
|
movedToProfile: data.movedToProfileId
|
|
? {
|
|
connect: {
|
|
id: data.movedToProfileId,
|
|
},
|
|
}
|
|
: undefined,
|
|
},
|
|
});
|
|
}
|
|
}
|