Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/subscription.tsx
T
2026-07-08 16:15:37 +02:00

224 lines
9.9 KiB
TypeScript

import { useEffect } from "react";
import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router";
import { useActionData } from "react-router";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import { getTranslations } from "~/locale/i18next.server";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getOrPersistTenantSubscription, getTenantSubscription } from "~/utils/db/tenantSubscriptions.db.server";
import { getTenant } from "~/utils/db/tenants.db.server";
import { cancelTenantSubscription, getPlanFeaturesUsage } from "~/utils/services/.server/subscriptionService";
import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { serverTimingHeaders } from "~/modules/metrics/utils/defaultHeaders";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import EditPageLayout from "~/components/ui/layouts/EditPageLayout";
import SubscriptionSettings from "~/modules/users/components/SubscriptionSettings";
import toast from "react-hot-toast";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { useAppData } from "~/utils/data/useAppData";
import { v2MetaFunction } from "~/utils/compat/v2MetaFunction";
import { tenantHasModule } from "~/utils/connector/tenantConnector.server";
import { BILLING_MODULE_KEY } from "~/utils/services/.server/billingStatusService";
import { appTenantPlanRequiredPath } from "~/utils/app/AppTenantStatusPaths";
import { CustomerBillingInvoiceError, listCustomerBillingInvoices } from "~/services/billing/customer-invoices.server";
import type { CustomerBillingInvoiceDto } from "~/application/dtos/billing/CustomerBillingInvoiceDto";
import { getAllSubscriptionProducts } from "~/utils/db/subscriptionProducts.db.server";
import { getCurrenciesAndPeriods } from "~/utils/helpers/PricingHelper";
import type { SubscriptionProductDto } from "~/application/dtos/subscriptions/SubscriptionProductDto";
import { createSelfServiceCheckout, SelfServiceCheckoutError } from "~/services/billing/self-service-checkout.server";
export { serverTimingHeaders as headers };
type LoaderData = {
title: string;
myFeatures: PlanFeatureUsageDto[];
myInvoices: CustomerBillingInvoiceDto[];
availablePlans: SubscriptionProductDto[];
currenciesAndPeriod: ReturnType<typeof getCurrenciesAndPeriods>;
canViewInvoices: boolean;
canManageSubscription: boolean;
invoiceErrorKey: string | null;
};
async function canViewSubscriptionInvoices(request: Request, tenantId: string): Promise<boolean> {
try {
await verifyUserHasPermission(request, "app.settings.subscription.invoices.view", tenantId);
return true;
} catch (error) {
if (error instanceof Response && (error.status === 403 || error.status === 404)) {
return false;
}
throw error;
}
}
async function canManageSubscription(request: Request, tenantId: string): Promise<boolean> {
try {
await verifyUserHasPermission(request, "app.settings.subscription.update", tenantId);
return true;
} catch (error) {
if (error instanceof Response && (error.status === 403 || error.status === 404)) {
return false;
}
throw error;
}
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { time, getServerTimingHeader } = await createMetrics({ request, params }, "app.$tenant.settings.subscription");
let { t } = await getTranslations(request);
const tenantId = await time(getTenantIdFromUrl(params), "getTenantIdFromUrl");
await time(verifyUserHasPermission(request, "app.settings.subscription.view", tenantId), "verifyUserHasPermission");
const userInfoPromise = time(getUserInfo(request), "getUserInfo");
const userPromise = userInfoPromise.then((userInfo) => time(getUser(userInfo.userId), "getUser"));
const tenantPromise = time(getTenant(tenantId), "getTenant");
const [user, tenant] = await Promise.all([userPromise, tenantPromise]);
const userInfo = await userInfoPromise;
const hasBillingModule = await tenantHasModule({ tenantId, userId: userInfo.userId, moduleKey: BILLING_MODULE_KEY });
if (!hasBillingModule) {
throw redirect(appTenantPlanRequiredPath(params));
}
if (!user) {
return badRequest({ error: t("shared.invalidUser") });
}
if (!tenant) {
return badRequest({ error: t("settings.subscription.errors.invalidTenant", { tenantId }) });
}
const tenantSubscription = await time(getOrPersistTenantSubscription(tenantId), "getOrPersistTenantSubscription");
const [canViewInvoices, canUpdateSubscription, availablePlans] = await Promise.all([
time(canViewSubscriptionInvoices(request, tenantId), "verifyInvoicePermission"),
time(canManageSubscription(request, tenantId), "verifySubscriptionUpdatePermission"),
time(getAllSubscriptionProducts(true), "subscription[getPublicProducts]"),
]);
const [myFeatures, invoiceResult] = await Promise.all([
time(getPlanFeaturesUsage(tenantId, tenantSubscription), "subscription[getPlanFeaturesUsage]"),
canViewInvoices
? time(
listCustomerBillingInvoices({ tenantId, tenantSlug: tenant.slug })
.then((invoices) => ({ invoices, errorKey: null }))
.catch((error) => ({
invoices: [],
errorKey: error instanceof CustomerBillingInvoiceError ? error.i18nKey : "settings.subscription.errors.INVOICE_LIST_UNAVAILABLE",
})),
"billing[listCustomerInvoices]"
)
: Promise.resolve({ invoices: [], errorKey: null }),
]);
const data: LoaderData = {
title: `${t("app.navbar.subscription")} | ${process.env.APP_NAME}`,
myFeatures,
myInvoices: invoiceResult.invoices,
availablePlans: availablePlans as SubscriptionProductDto[],
currenciesAndPeriod: getCurrenciesAndPeriods(availablePlans.flatMap((plan) => plan.prices)),
canViewInvoices,
canManageSubscription: canUpdateSubscription,
invoiceErrorKey: invoiceResult.errorKey,
};
return Response.json(data, { headers: getServerTimingHeader() });
};
type ActionData = {
error?: string;
success?: string;
};
const badRequest = (data: ActionData) => Response.json(data, { status: 400 });
export const action: ActionFunction = async ({ request, params }) => {
const { t } = await getTranslations(request);
const tenantId = await getTenantIdFromUrl(params);
await verifyUserHasPermission(request, "app.settings.subscription.update", tenantId);
const userInfo = await getUserInfo(request);
const tenantSubscription = await getTenantSubscription(tenantId);
await validateCSRFToken(request);
const form = await request.formData();
const action = form.get("action")?.toString();
if (!tenantSubscription) {
return badRequest({
error: t("settings.subscription.errors.invalidSubscription"),
});
} else if (action === "cancel") {
await verifyUserHasPermission(request, "app.settings.subscription.delete", tenantId);
const tenantSubscriptionProductId = form.get("tenant-subscription-product-id")?.toString() ?? "";
try {
await cancelTenantSubscription(tenantSubscriptionProductId, { t, tenantId, userId: userInfo.userId });
return Response.json({ success: t("settings.subscription.success.cancelled") });
} catch (error) {
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: t("shared.unexpectedError") }, { status: 400 });
}
} else if (action === "subscribe") {
const tenant = await getTenant(tenantId);
const user = await getUser(userInfo.userId);
if (!tenant) {
return badRequest({ error: t("settings.subscription.errors.invalidTenant", { tenantId }) });
}
if (!user) {
return badRequest({ error: t("shared.invalidUser") });
}
const tenantSlugContext = form.get("tenant-slug-context")?.toString();
if (tenantSlugContext && tenantSlugContext !== tenant.slug) {
return badRequest({ error: t("settings.subscription.checkout.invalid") });
}
try {
const checkout = await createSelfServiceCheckout({
request,
tenantId,
tenantSlug: tenant.slug,
tenantName: tenant.name,
userId: user.id,
userEmail: user.email,
userName: `${user.firstName ?? ""} ${user.lastName ?? ""}`.trim() || user.email,
productId: form.get("product-id")?.toString() ?? "",
billingPeriod: Number(form.get("billing-period")?.toString()),
currency: form.get("currency")?.toString() ?? "",
quantity: Number(form.get("quantity")?.toString() ?? "1"),
});
return redirect(checkout.checkoutUrl);
} catch (error) {
if (error instanceof Response) {
throw error;
}
if (error instanceof SelfServiceCheckoutError) {
return Response.json({ error: t(error.i18nKey) }, { status: 400 });
}
// eslint-disable-next-line no-console
console.error(error);
return Response.json({ error: t("shared.unexpectedError") }, { status: 400 });
}
}
};
export const meta: v2MetaFunction<typeof loader> = ({ data }) => (data && "title" in data ? [{ title: data.title }] : []);
export default function SubscriptionRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<ActionData>();
const appData = useAppData();
useEffect(() => {
if (actionData?.error) {
toast.error(actionData.error);
} else if (actionData?.success) {
toast.success(actionData.success);
}
}, [actionData]);
return (
<EditPageLayout className="mb-12">
<SubscriptionSettings
{...data}
mySubscription={appData.mySubscription}
permissions={{
viewInvoices: data.canViewInvoices && getUserHasPermission(appData, "app.settings.subscription.invoices.view"),
manageSubscription: data.canManageSubscription && getUserHasPermission(appData, "app.settings.subscription.update"),
}}
/>
</EditPageLayout>
);
}