* 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>
501 lines
12 KiB
TypeScript
501 lines
12 KiB
TypeScript
import type { User as PrismaUser } from "@prisma/client";
|
|
import { v4 as uuidv4 } from "uuid";
|
|
|
|
import { whereClauseForOrgWithSlugOrRequestedSlug } from "@calcom/ee/organizations/lib/orgDomains";
|
|
import { safeStringify } from "@calcom/lib/safeStringify";
|
|
import prisma from "@calcom/prisma";
|
|
import type { Team } from "@calcom/prisma/client";
|
|
import type { UpId, UserAsPersonalProfile, UserProfile } from "@calcom/types/UserProfile";
|
|
|
|
import logger from "../../logger";
|
|
import { getParsedTeam } from "./teamUtils";
|
|
import { UserRepository } from "./user";
|
|
|
|
const log = logger.getSubLogger({ prefix: ["repository/profile"] });
|
|
const organizationSelect = {
|
|
id: true,
|
|
slug: true,
|
|
name: true,
|
|
metadata: true,
|
|
calVideoLogo: true,
|
|
};
|
|
|
|
export enum LookupTarget {
|
|
User,
|
|
Profile,
|
|
}
|
|
|
|
export class ProfileRepository {
|
|
static generateProfileUid() {
|
|
return uuidv4();
|
|
}
|
|
|
|
private static getInheritedDataFromUser({ user }: { user: PrismaUser }) {
|
|
return {
|
|
name: user.name,
|
|
avatarUrl: user.avatarUrl,
|
|
startTime: user.startTime,
|
|
endTime: user.endTime,
|
|
bufferTime: user.bufferTime,
|
|
avatar: user.avatar,
|
|
};
|
|
}
|
|
|
|
static getLookupTarget(upId: UpId) {
|
|
if (upId.startsWith("usr-")) {
|
|
return {
|
|
type: LookupTarget.User,
|
|
id: parseInt(upId.replace("usr-", "")),
|
|
} as const;
|
|
}
|
|
return {
|
|
type: LookupTarget.Profile,
|
|
id: parseInt(upId),
|
|
} as const;
|
|
}
|
|
|
|
private static async _create({
|
|
userId,
|
|
organizationId,
|
|
username,
|
|
email,
|
|
movedFromUserId,
|
|
}: {
|
|
userId: number;
|
|
organizationId: number;
|
|
username: string | null;
|
|
email: string;
|
|
movedFromUserId?: number;
|
|
}) {
|
|
log.debug("_create", safeStringify({ userId, organizationId, username, email }));
|
|
return prisma.profile.create({
|
|
data: {
|
|
uid: ProfileRepository.generateProfileUid(),
|
|
user: {
|
|
connect: {
|
|
id: userId,
|
|
},
|
|
},
|
|
organization: {
|
|
connect: {
|
|
id: organizationId,
|
|
},
|
|
},
|
|
...(movedFromUserId
|
|
? {
|
|
movedFromUser: {
|
|
connect: {
|
|
id: movedFromUserId,
|
|
},
|
|
},
|
|
}
|
|
: null),
|
|
|
|
username: username || email.split("@")[0],
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Accepts `email` as a source to derive username from when username is null
|
|
* @returns
|
|
*/
|
|
static create({
|
|
userId,
|
|
organizationId,
|
|
username,
|
|
email,
|
|
}: {
|
|
userId: number;
|
|
organizationId: number;
|
|
username: string | null;
|
|
email: string;
|
|
}) {
|
|
return ProfileRepository._create({ userId, organizationId, username, email });
|
|
}
|
|
|
|
static async upsert({
|
|
create,
|
|
update,
|
|
updateWhere,
|
|
}: {
|
|
create: {
|
|
userId: number;
|
|
organizationId: number;
|
|
username: string | null;
|
|
email: string;
|
|
};
|
|
update: {
|
|
username: string | null;
|
|
email: string;
|
|
};
|
|
updateWhere: {
|
|
userId: number;
|
|
organizationId: number;
|
|
};
|
|
}) {
|
|
return prisma.profile.upsert({
|
|
create: {
|
|
uid: ProfileRepository.generateProfileUid(),
|
|
user: {
|
|
connect: {
|
|
id: create.userId,
|
|
},
|
|
},
|
|
organization: {
|
|
connect: {
|
|
id: create.organizationId,
|
|
},
|
|
},
|
|
username: create.username || create.email.split("@")[0],
|
|
},
|
|
update: {
|
|
username: update.username || update.email.split("@")[0],
|
|
},
|
|
where: {
|
|
userId_organizationId: {
|
|
userId: updateWhere.userId,
|
|
organizationId: updateWhere.organizationId,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
static async createForExistingUser({
|
|
userId,
|
|
organizationId,
|
|
username,
|
|
email,
|
|
movedFromUserId,
|
|
}: {
|
|
userId: number;
|
|
organizationId: number;
|
|
username: string | null;
|
|
email: string;
|
|
movedFromUserId: number;
|
|
}) {
|
|
return await ProfileRepository._create({
|
|
userId,
|
|
organizationId,
|
|
username,
|
|
email: email,
|
|
movedFromUserId,
|
|
});
|
|
}
|
|
|
|
static createMany({
|
|
users,
|
|
organizationId,
|
|
}: {
|
|
users: { id: number; username: string; email: string }[];
|
|
organizationId: number;
|
|
}) {
|
|
return prisma.profile.createMany({
|
|
data: users.map((user) => ({
|
|
uid: ProfileRepository.generateProfileUid(),
|
|
userId: user.id,
|
|
organizationId,
|
|
username: user.username || user.email.split("@")[0],
|
|
})),
|
|
});
|
|
}
|
|
|
|
static delete({ userId, organizationId }: { userId: number; organizationId: number }) {
|
|
// Even though there can be just one profile matching a userId and organizationId, we are using deleteMany as it won't error if the profile doesn't exist
|
|
return prisma.profile.deleteMany({
|
|
where: { userId, organizationId },
|
|
});
|
|
}
|
|
|
|
static deleteMany({ userIds }: { userIds: number[] }) {
|
|
// Even though there can be just one profile matching a userId and organizationId, we are using deleteMany as it won't error if the profile doesn't exist
|
|
return prisma.profile.deleteMany({
|
|
where: { userId: { in: userIds } },
|
|
});
|
|
}
|
|
|
|
static async findByUserIdAndOrgId({
|
|
userId,
|
|
organizationId,
|
|
}: {
|
|
userId: number;
|
|
organizationId: number | null;
|
|
}) {
|
|
if (!organizationId) {
|
|
return null;
|
|
}
|
|
const profile = await prisma.profile.findFirst({
|
|
where: {
|
|
userId,
|
|
organizationId,
|
|
},
|
|
include: {
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
user: true,
|
|
},
|
|
});
|
|
|
|
if (!profile) {
|
|
return null;
|
|
}
|
|
|
|
const organization = getParsedTeam(profile.organization);
|
|
return normalizeProfile({
|
|
...profile,
|
|
organization: {
|
|
...organization,
|
|
requestedSlug: organization.metadata?.requestedSlug ?? null,
|
|
metadata: organization.metadata,
|
|
},
|
|
});
|
|
}
|
|
|
|
static async findByOrgIdAndUsername({
|
|
organizationId,
|
|
username,
|
|
}: {
|
|
organizationId: number;
|
|
username: string;
|
|
}) {
|
|
const profile = await prisma.profile.findFirst({
|
|
where: {
|
|
username,
|
|
organizationId,
|
|
},
|
|
include: {
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
user: true,
|
|
},
|
|
});
|
|
return profile;
|
|
}
|
|
|
|
static async findByUpId(upId: string) {
|
|
const lookupTarget = ProfileRepository.getLookupTarget(upId);
|
|
log.debug("findById", safeStringify({ upId, lookupTarget }));
|
|
if (lookupTarget.type === LookupTarget.User) {
|
|
const user = await UserRepository.findById({ id: lookupTarget.id });
|
|
if (!user) {
|
|
return null;
|
|
}
|
|
return {
|
|
username: user.username,
|
|
upId: `usr-${user.id}`,
|
|
id: null,
|
|
organizationId: null,
|
|
organization: null,
|
|
...ProfileRepository.getInheritedDataFromUser({ user }),
|
|
};
|
|
}
|
|
|
|
const profile = await ProfileRepository.findById(lookupTarget.id);
|
|
if (!profile) {
|
|
return null;
|
|
}
|
|
const user = profile.user;
|
|
return {
|
|
...profile,
|
|
...ProfileRepository.getInheritedDataFromUser({ user }),
|
|
};
|
|
}
|
|
|
|
static async findById(id: number | null) {
|
|
if (!id) {
|
|
return null;
|
|
}
|
|
|
|
const profile = await prisma.profile.findUnique({
|
|
where: {
|
|
id,
|
|
},
|
|
include: {
|
|
user: true,
|
|
organization: {
|
|
include: {
|
|
members: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (!profile) {
|
|
return null;
|
|
}
|
|
|
|
return normalizeProfile(profile);
|
|
}
|
|
|
|
static async findManyByOrgSlugOrRequestedSlug({
|
|
usernames,
|
|
orgSlug,
|
|
}: {
|
|
usernames: string[];
|
|
orgSlug: string;
|
|
}) {
|
|
logger.debug("findManyByOrgSlugOrRequestedSlug", safeStringify({ usernames, orgSlug }));
|
|
const profiles = await prisma.profile.findMany({
|
|
where: {
|
|
username: {
|
|
in: usernames,
|
|
},
|
|
organization: whereClauseForOrgWithSlugOrRequestedSlug(orgSlug),
|
|
},
|
|
include: {
|
|
user: true,
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
},
|
|
});
|
|
|
|
return profiles.map(normalizeProfile);
|
|
}
|
|
|
|
static async findAllProfilesForUserIncludingMovedUser(user: {
|
|
id: number;
|
|
username: string | null;
|
|
}): Promise<UserProfile[]> {
|
|
const profiles = await ProfileRepository.findManyForUser(user);
|
|
// User isn't member of any organization. Also, he has no user profile. We build the profile from user table
|
|
if (!profiles.length) {
|
|
return [
|
|
ProfileRepository.buildPersonalProfileFromUser({
|
|
user,
|
|
}),
|
|
];
|
|
}
|
|
|
|
return profiles;
|
|
}
|
|
|
|
static async findManyForUser(user: { id: number }) {
|
|
const profiles = (
|
|
await prisma.profile.findMany({
|
|
where: {
|
|
userId: user.id,
|
|
},
|
|
include: {
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
},
|
|
})
|
|
)
|
|
.map((profile) => {
|
|
return {
|
|
...profile,
|
|
organization: getParsedTeam(profile.organization),
|
|
};
|
|
})
|
|
.map((profile) => {
|
|
return normalizeProfile({
|
|
username: profile.username,
|
|
id: profile.id,
|
|
userId: profile.userId,
|
|
uid: profile.uid,
|
|
name: profile.organization.name,
|
|
organizationId: profile.organizationId,
|
|
organization: {
|
|
...profile.organization,
|
|
requestedSlug: profile.organization.metadata?.requestedSlug ?? null,
|
|
metadata: profile.organization.metadata,
|
|
},
|
|
});
|
|
});
|
|
return profiles;
|
|
}
|
|
|
|
static async findManyForOrg({ organizationId }: { organizationId: number }) {
|
|
return await prisma.profile.findMany({
|
|
where: {
|
|
organizationId,
|
|
},
|
|
include: {
|
|
user: true,
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
static async findByUserIdAndProfileId({ userId, profileId }: { userId: number; profileId: number }) {
|
|
const profile = await prisma.profile.findUnique({
|
|
where: {
|
|
userId,
|
|
id: profileId,
|
|
},
|
|
include: {
|
|
organization: {
|
|
select: organizationSelect,
|
|
},
|
|
user: true,
|
|
},
|
|
});
|
|
if (!profile) {
|
|
return profile;
|
|
}
|
|
return normalizeProfile(profile);
|
|
}
|
|
|
|
/**
|
|
* Personal profile should come from Profile table only
|
|
*/
|
|
static buildPersonalProfileFromUser({
|
|
user,
|
|
}: {
|
|
user: { username: string | null; id: number };
|
|
}): UserAsPersonalProfile {
|
|
return {
|
|
id: null,
|
|
upId: `usr-${user.id}`,
|
|
username: user.username,
|
|
organizationId: null,
|
|
organization: null,
|
|
};
|
|
}
|
|
|
|
static _getPrismaWhereForProfilesOfOrg({ orgSlug }: { orgSlug: string | null }) {
|
|
return {
|
|
profiles: {
|
|
...(orgSlug
|
|
? {
|
|
some: {
|
|
organization: {
|
|
slug: orgSlug,
|
|
},
|
|
},
|
|
}
|
|
: // If it's not orgSlug we want to ensure that no profile is there. Having a profile means that the user is a member of some organization.
|
|
{
|
|
none: {},
|
|
}),
|
|
},
|
|
};
|
|
}
|
|
}
|
|
|
|
export const normalizeProfile = <
|
|
T extends {
|
|
id: number;
|
|
organization: Pick<Team, keyof typeof organizationSelect>;
|
|
createdAt?: Date;
|
|
updatedAt?: Date;
|
|
}
|
|
>(
|
|
profile: T
|
|
) => {
|
|
return {
|
|
...profile,
|
|
upId: profile.id.toString(),
|
|
organization: getParsedTeam(profile.organization),
|
|
// Make these ↓ props ISO strings so that they can be returned from getServerSideProps as is without any issues
|
|
...(profile.createdAt ? { createdAt: profile.createdAt.toISOString() } : null),
|
|
...(profile.updatedAt ? { updatedAt: profile.updatedAt.toISOString() } : null),
|
|
};
|
|
};
|