* Abstract app category navigation * Send key schema to frontend Co-authored-by: Omar López <zomars@users.noreply.github.com> * Render keys for apps on admin * Add enabled col for apps * Save app keys to DB * Add checks for admin role * Abstract setup components * Add AdminAppsList to setup wizard * Migrate to v10 tRPC * Default hide keys * Display enabled apps * Merge branch 'main' into admin-apps-ui * Toggle calendars * WIP * Add params and include AppCategoryNavigation * Refactor getEnabledApps * Add warning for disabling apps * Fallback to cal video when a video app is disabled * WIP send disabled email * Send email to all users of event types with payment app * Disable Stripe when app is disabled * Disable apps in event types * Send email to users on disabled apps * Send email based on what app was disabled * WIP type fix * Disable navigation to apps list if already setup * UI import fixes * Waits for session data before redirecting * Updates admin seeded password To comply with admin password requirements * Update yarn.lock * Flex fixes * Adds admin middleware * Clean up * WIP * WIP * NTS * Add dirName to app metadata * Upsert app if not in db * Upsert app if not in db * Add dirName to app metadata * Add keys to app packages w/ keys * Merge with main * Toggle show keys & on enable * Fix empty keys * Fix lark calendar metadata * Fix some type errors * Fix Lark metadata & check for category when upserting * More type fixes * Fix types & add keys to google cal * WIP * WIP * WIP * More type fixes * Fix type errors * Fix type errors * More type fixes * More type fixes * More type fixes * Feedback * Fixes default value * Feedback * Migrate credential invalid col default value "false" * Upsert app on saving keys * Clean up * Validate app keys on frontend * Add nonempty to app keys schemas * Add web3 * Listlocale filter on categories / category * Grab app metadata via category or categories * Show empty screen if no apps are enabled * Fix type checks * Fix type checks * Fix type checks * Fix type checks * Fix type checks * Fix type checks * Replace .nonempty() w/ .min(1) * Fix type error * Address feedback * Added migration to keep current apps enabled * Update apps.tsx * Fix bug * Add keys schema to Plausible app * Add appKeysSchema to zod.ts template * Update AdminAppsList.tsx Co-authored-by: Omar López <zomars@users.noreply.github.com> Co-authored-by: Peer Richelsen <peeroke@gmail.com> Co-authored-by: zomars <zomars@me.com> Co-authored-by: sean-brydon <55134778+sean-brydon@users.noreply.github.com>
243 lines
7.4 KiB
TypeScript
243 lines
7.4 KiB
TypeScript
import { Prisma } from "@prisma/client";
|
|
import { TFunction } from "next-i18next";
|
|
import { z } from "zod";
|
|
|
|
import { defaultLocations, EventLocationType } from "@calcom/app-store/locations";
|
|
import { EventTypeModel } from "@calcom/prisma/zod";
|
|
import { EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
|
|
import type { App, AppMeta } from "@calcom/types/App";
|
|
|
|
// If you import this file on any app it should produce circular dependency
|
|
// import appStore from "./index";
|
|
import { appStoreMetadata } from "./apps.metadata.generated";
|
|
|
|
export type EventTypeApps = NonNullable<NonNullable<z.infer<typeof EventTypeMetaDataSchema>>["apps"]>;
|
|
export type EventTypeAppsList = keyof EventTypeApps;
|
|
|
|
const ALL_APPS_MAP = Object.keys(appStoreMetadata).reduce((store, key) => {
|
|
store[key] = appStoreMetadata[key as keyof typeof appStoreMetadata];
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
//@ts-ignore
|
|
delete store[key]["/*"];
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
//@ts-ignore
|
|
delete store[key]["__createdUsingCli"];
|
|
return store;
|
|
}, {} as Record<string, AppMeta>);
|
|
|
|
const credentialData = Prisma.validator<Prisma.CredentialArgs>()({
|
|
select: { id: true, type: true, key: true, userId: true, appId: true, invalid: true },
|
|
});
|
|
|
|
export type CredentialData = Prisma.CredentialGetPayload<typeof credentialData>;
|
|
|
|
export enum InstalledAppVariants {
|
|
"conferencing" = "conferencing",
|
|
"calendar" = "calendar",
|
|
"payment" = "payment",
|
|
"analytics" = "analytics",
|
|
"automation" = "automation",
|
|
"other" = "other",
|
|
}
|
|
|
|
export const ALL_APPS = Object.values(ALL_APPS_MAP);
|
|
|
|
type OptionTypeBase = {
|
|
label: string;
|
|
value: EventLocationType["type"];
|
|
disabled?: boolean;
|
|
};
|
|
|
|
function translateLocations(locations: OptionTypeBase[], t: TFunction) {
|
|
return locations.map((l) => ({
|
|
...l,
|
|
label: t(l.label),
|
|
}));
|
|
}
|
|
|
|
export function getLocationOptions(integrations: ReturnType<typeof getApps>, t: TFunction) {
|
|
const locations: OptionTypeBase[] = [];
|
|
defaultLocations.forEach((l) => {
|
|
locations.push({
|
|
label: l.label,
|
|
value: l.type,
|
|
});
|
|
});
|
|
integrations.forEach((app) => {
|
|
if (app.locationOption) {
|
|
locations.push(app.locationOption);
|
|
}
|
|
});
|
|
|
|
return translateLocations(locations, t);
|
|
}
|
|
|
|
export function getLocationGroupedOptions(integrations: ReturnType<typeof getApps>, t: TFunction) {
|
|
const apps: Record<string, { label: string; value: string; disabled?: boolean; icon?: string }[]> = {};
|
|
integrations.forEach((app) => {
|
|
if (app.locationOption) {
|
|
const category = app.category;
|
|
const option = { ...app.locationOption, icon: app.imageSrc };
|
|
if (apps[category]) {
|
|
apps[category] = [...apps[category], option];
|
|
} else {
|
|
apps[category] = [option];
|
|
}
|
|
}
|
|
});
|
|
|
|
defaultLocations.forEach((l) => {
|
|
const category = l.category;
|
|
if (apps[category]) {
|
|
apps[category] = [
|
|
...apps[category],
|
|
{
|
|
label: l.label,
|
|
value: l.type,
|
|
icon: l.iconUrl,
|
|
},
|
|
];
|
|
} else {
|
|
apps[category] = [
|
|
{
|
|
label: l.label,
|
|
value: l.type,
|
|
icon: l.iconUrl,
|
|
},
|
|
];
|
|
}
|
|
});
|
|
const locations = [];
|
|
|
|
// Translating labels and pushing into array
|
|
for (const category in apps) {
|
|
const tmp = { label: category, options: apps[category] };
|
|
if (tmp.label === "in person") {
|
|
tmp.options.map((l) => ({ ...l, label: t(l.value) }));
|
|
} else {
|
|
tmp.options.map((l) => ({
|
|
...l,
|
|
label: t(l.label.toLowerCase().split(" ").join("_")),
|
|
}));
|
|
}
|
|
|
|
tmp.label = t(tmp.label);
|
|
|
|
locations.push(tmp);
|
|
}
|
|
return locations;
|
|
}
|
|
|
|
/**
|
|
* This should get all available apps to the user based on his saved
|
|
* credentials, this should also get globally available apps.
|
|
*/
|
|
function getApps(userCredentials: CredentialData[]) {
|
|
const apps = ALL_APPS.map((appMeta) => {
|
|
const credentials = userCredentials.filter((credential) => credential.type === appMeta.type);
|
|
let locationOption: OptionTypeBase | null = null;
|
|
|
|
/** If the app is a globally installed one, let's inject it's key */
|
|
if (appMeta.isGlobal) {
|
|
credentials.push({
|
|
id: +new Date().getTime(),
|
|
type: appMeta.type,
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
key: appMeta.key!,
|
|
userId: +new Date().getTime(),
|
|
appId: appMeta.slug,
|
|
invalid: false,
|
|
});
|
|
}
|
|
|
|
/** Check if app has location option AND add it if user has credentials for it */
|
|
if (credentials.length > 0 && appMeta?.appData?.location) {
|
|
locationOption = {
|
|
value: appMeta.appData.location.type,
|
|
label: appMeta.appData.location.label || "No label set",
|
|
disabled: false,
|
|
};
|
|
}
|
|
|
|
const credential: typeof credentials[number] | null = credentials[0] || null;
|
|
return {
|
|
...appMeta,
|
|
/**
|
|
* @deprecated use `credentials`
|
|
*/
|
|
credential,
|
|
credentials,
|
|
/** Option to display in `location` field while editing event types */
|
|
locationOption,
|
|
};
|
|
});
|
|
|
|
return apps;
|
|
}
|
|
|
|
export function getLocalAppMetadata() {
|
|
return ALL_APPS;
|
|
}
|
|
|
|
export function hasIntegrationInstalled(type: App["type"]): boolean {
|
|
return ALL_APPS.some((app) => app.type === type && !!app.installed);
|
|
}
|
|
|
|
export function getAppName(name: string): string | null {
|
|
return ALL_APPS_MAP[name as keyof typeof ALL_APPS_MAP]?.name ?? null;
|
|
}
|
|
|
|
export function getAppType(name: string): string {
|
|
const type = ALL_APPS_MAP[name as keyof typeof ALL_APPS_MAP].type;
|
|
|
|
if (type.endsWith("_calendar")) {
|
|
return "Calendar";
|
|
}
|
|
if (type.endsWith("_payment")) {
|
|
return "Payment";
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
export const getEventTypeAppData = <T extends EventTypeAppsList>(
|
|
eventType: Pick<z.infer<typeof EventTypeModel>, "price" | "currency" | "metadata">,
|
|
appId: T,
|
|
forcedGet?: boolean
|
|
): EventTypeApps[T] => {
|
|
const metadata = eventType.metadata;
|
|
const appMetadata = metadata?.apps && metadata.apps[appId];
|
|
if (appMetadata) {
|
|
const allowDataGet = forcedGet ? true : appMetadata.enabled;
|
|
return allowDataGet ? appMetadata : null;
|
|
}
|
|
|
|
// Backward compatibility for existing event types.
|
|
// TODO: After the new AppStore EventType App flow is stable, write a migration to migrate metadata to new format which will let us remove this compatibility code
|
|
// Migration isn't being done right now, to allow a revert if needed
|
|
const legacyAppsData = {
|
|
stripe: {
|
|
enabled: eventType.price > 0,
|
|
// Price default is 0 in DB. So, it would always be non nullish.
|
|
price: eventType.price,
|
|
// Currency default is "usd" in DB.So, it would also be available always
|
|
currency: eventType.currency,
|
|
},
|
|
rainbow: {
|
|
enabled: !!(eventType.metadata?.smartContractAddress && eventType.metadata?.blockchainId),
|
|
smartContractAddress: eventType.metadata?.smartContractAddress || "",
|
|
blockchainId: eventType.metadata?.blockchainId || 0,
|
|
},
|
|
giphy: {
|
|
enabled: !!eventType.metadata?.giphyThankYouPage,
|
|
thankYouPage: eventType.metadata?.giphyThankYouPage || "",
|
|
},
|
|
} as const;
|
|
|
|
// TODO: This assertion helps typescript hint that only one of the app's data can be returned
|
|
const legacyAppData = legacyAppsData[appId as Extract<T, keyof typeof legacyAppsData>];
|
|
const allowDataGet = forcedGet ? true : legacyAppData?.enabled;
|
|
return allowDataGet ? legacyAppData : null;
|
|
};
|
|
|
|
export default getApps;
|