Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/members/new.tsx
T

169 lines
6.8 KiB
TypeScript

import { ActionFunction, LoaderFunctionArgs, redirect, MetaFunction, useLoaderData } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { getTenant, getTenantMember } from "~/utils/db/tenants.db.server";
import { getUser, getUserByEmail } from "~/utils/db/users.db.server";
import { createWorkspaceInvite, WorkspaceInviteError } from "@toolctrl/db/workspace-invites.server";
import { getDbClient } from "@toolctrl/db/client.server";
import { publishOutboxEvent, type OutboxPublisherTransaction } from "@toolctrl/db/outbox";
import type { Prisma } from "@toolctrl/db/prisma-browser";
import NewMember from "~/components/core/settings/members/NewMember";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { getPlanFeatureUsage } from "~/utils/services/.server/subscriptionService";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import { getAbsoluteUrl } from "~/utils/url.server";
import { TenantUserType } from "~/application/enums/tenants/TenantUserType";
import ServerError from "~/components/ui/errors/ServerError";
import EventsService from "~/modules/events/services/.server/EventsService";
import { MemberInvitationCreatedDto } from "~/modules/events/dtos/MemberInvitationCreatedDto";
import { getUserInfo } from "~/utils/session.server";
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
import { getMailTranslator } from "~/locale/mail-translator.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
import { appPath } from "~/utils/app/CanonicalUrlUtils";
import { validateCSRFToken } from "~/utils/session.server";
export type NewMemberLoaderData = {
title: string;
featurePlanUsage: PlanFeatureUsageDto | undefined;
};
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.members.create", tenantId);
const featurePlanUsage = await getPlanFeatureUsage(tenantId, DefaultFeatures.Users);
const data: NewMemberLoaderData = {
title: `${t("settings.members.actions.new")} | ${process.env.APP_NAME}`,
featurePlanUsage,
};
return data;
};
export type NewMemberActionData = {
error?: string;
success?: string;
fields?: {
email: string;
firstName: string;
lastName: string;
role: number;
};
};
export const action: ActionFunction = async ({ request, params }) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await validateCSRFToken(request);
await verifyUserHasPermission(request, "app.settings.members.create", tenantId);
const { userId } = await getUserInfo(request);
const fromUser = await getUser(userId);
const tenant = await getTenant(tenantId);
if (!tenant || !fromUser) {
return Response.json({ error: t("settings.members.errors.tenantOrUserNotFound") });
}
const form = await request.formData();
const email = form.get("email")?.toString().toLowerCase().trim() ?? "";
const firstName = form.get("first-name")?.toString() ?? "";
const lastName = form.get("last-name")?.toString() ?? "";
const sendInvitationEmail = Boolean(form.get("send-invitation-email"));
try {
const user = await getUserByEmail(email);
if (user) {
const tenantUser = await getTenantMember(user.id, tenantId);
if (tenantUser) {
return Response.json({ error: t("settings.members.errors.userAlreadyInOrganization") });
}
}
const mailTranslator = sendInvitationEmail ? await getMailTranslator(fromUser.locale) : null;
const appConfiguration = sendInvitationEmail ? await getAppConfiguration({ request }) : null;
const db = getDbClient();
const invitation = await db.$transaction(async (tx) => {
const created = await createWorkspaceInvite(
{
tenantId,
email,
firstName,
lastName,
type: TenantUserType.MEMBER,
fromUserId: fromUser?.id ?? null,
// DoD "Einladung 48h": kein expliziter Wert mehr -> createWorkspaceInvite setzt den
// 48h-Default (WORKSPACE_INVITE_TTL_MS) als Single Source of Truth.
},
tx
);
if (sendInvitationEmail && mailTranslator && appConfiguration) {
const rendered = EmailTemplates.USER_INVITATION_EMAIL.parse({
appConfiguration,
data: {
name: firstName,
invite_sender_name: fromUser.firstName,
invite_sender_organization: tenant.name,
action_url: getAbsoluteUrl(request, `/invitation/${created.token}`),
},
t: mailTranslator.t,
locale: mailTranslator.locale,
});
await publishOutboxEvent(tx as OutboxPublisherTransaction, {
tenantId: tenant.id,
type: "mail.transactional.send",
dispatchKey: `mail:workspace-invite:${created.id}`,
payload: {
tenantId: tenant.id,
to: [email],
subject: rendered.subject,
html: rendered.body,
priorityOverride: "critical",
metadata: {
source: "workspace-invitation",
alias: "user-invitation",
invitationId: created.id,
},
} satisfies Prisma.InputJsonValue,
});
}
return created;
});
await EventsService.create({
request,
event: "member.invitation.created",
tenantId: tenant.id,
userId: fromUser.id,
data: {
user: { email: invitation.email, firstName: invitation.firstName, lastName: invitation.lastName, type: TenantUserType[invitation.type] },
tenant: { id: tenant.id, name: tenant.name },
fromUser: { id: fromUser!.id, email: fromUser!.email },
} satisfies MemberInvitationCreatedDto,
});
return redirect(appPath({ tenantSlug: params.tenant ?? "", path: "settings/members", mode: "host-aware" }));
} catch (error: any) {
if (error instanceof WorkspaceInviteError && error.code === "duplicate_active_invite") {
return Response.json({ error: t("settings.members.errors.invitationAlreadyExists") }, { status: 400 });
}
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: t("settings.members.errors.createInvitationFailed") }, { status: 400 });
}
};
export const meta: MetaFunction<typeof loader> = ({ data }) => [{ title: data?.title }];
export default function NewMemberRoute() {
const data = useLoaderData<NewMemberLoaderData>();
return <NewMember featurePlanUsage={data.featurePlanUsage} />;
}
export function ErrorBoundary() {
return <ServerError />;
}