Files
cal.diy/packages/lib/server/repository/profile.ts
T
12466fb064 feat: New Organization Schema along with the ability to invite existing users to an organization (#13002)
* 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>
2024-02-02 21:34:13 +00:00

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),
};
};