infoalloggi-monorepo/apps/infoalloggi/src/server/controllers/stripe.controller.ts

import { TRPCError } from "@trpc/server";
import { env } from "~/env";
import stripe from "~/lib/stripe";
import OrderTypeEnum from "~/schemas/public/OrderTypeEnum";
import PaymentStatusEnum from "~/schemas/public/PaymentStatusEnum";
import type { Payments, PaymentsId } from "~/schemas/public/Payments";
import type { TestiEStringheStingaId } from "~/schemas/public/TestiEStringhe";
import TipologiaPosizioneEnum from "~/schemas/public/TipologiaPosizioneEnum";
import { db } from "~/server/db";
import { NewMail } from "~/server/services/mailer";
import { getUser } from "~/server/services/user.service";
import { addEventToQueue } from "./event_queue.controller";

export const stripeHealthCheck = async () => {
	try {
		const endpoints = await stripe.webhookEndpoints.list();
		return {
			success: true,
			endpoints,
			secretKey: env.STRIPE_SECRET_KEY,
			publicKey: env.NEXT_PUBLIC_STRIPE_PUBLIC_KEY,
		};
	} catch (e) {
		console.error("Stripe health check failed:", e);
		return {
			success: false,
			endpoints: null,
			secretKey: env.STRIPE_SECRET_KEY,
			publicKey: env.NEXT_PUBLIC_STRIPE_PUBLIC_KEY,
		};
	}
};

export const createIntentHandler = async ({
	paymentId,
}: {
	paymentId: PaymentsId;
}) => {
	try {
		const payment = await db
			.selectFrom("payments")
			.selectAll("payments")
			.innerJoin("users", "users.id", "payments.userid")
			.select("users.email")
			.innerJoin("ordini", "ordini.ordine_id", "payments.ordine_id")
			.innerJoin("prezziario", "prezziario.idprezziario", "ordini.packid")
			.select(["prezziario.nome_it", "prezziario.desc_it"])
			.where("payments.id", "=", paymentId)
			.executeTakeFirstOrThrow(
				() => new Error(`Payment not found - paymentId: ${paymentId}`),
			);

		const paymentIntent = await stripe.paymentIntents.create({
			amount: payment.amount_cent,
			//payment_method_configuration: "pmc_1P4NfjILe4KoQRqXYChFCTFj",
			automatic_payment_methods: {
				enabled: true,
			},
			currency: "eur",
			description: payment.nome_it,
			metadata: {
				paymentId,
				servizioId: payment.servizio_id,
				userId: payment.userid,
			},
			receipt_email: payment.email,
		});

		return {
			clientSecret: paymentIntent.client_secret,
			descrizione: payment.desc_it,
			prezzo: payment.amount_cent,
			titolo: payment.nome_it,
		};
	} catch (error) {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error creating payment intent: ${(error as Error).message}`,
		});
	}
};

export const whIntentCreatedHandler = async ({
	pIntentId,
	paymentId,
}: {
	pIntentId: Payments["intent_id"];
	paymentId: PaymentsId;
}) => {
	try {
		return await db
			.updateTable("payments")
			.set({
				intent_id: pIntentId,
				paymentstatus: PaymentStatusEnum.processing,
			})
			.where("id", "=", paymentId)
			.returning("id")
			.execute();
	} catch (error) {
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error whIntentCreatedHandler: ${(error as Error).message}`,
		});
	}
};

export const whIntentSucceededHandler = async ({
	pIntentId,
	paymentId,
	pm_id,
}: {
	pIntentId: Payments["intent_id"];
	paymentId: PaymentsId;
	pm_id: string;
}) => {
	try {
		const paymentMethod = await stripe.paymentMethods.retrieve(pm_id);

		await db.transaction().execute(async (trx) => {
			const payment = await trx
				.updateTable("payments")
				.set({
					paid_at: new Date(),
					paymentmethod: paymentMethod.type,
					paymentstatus: PaymentStatusEnum.success,
				})
				.where("intent_id", "=", pIntentId)
				.where("payments.id", "=", paymentId)
				.returning(["servizio_id", "ordine_id"])
				.executeTakeFirstOrThrow(() => {
					throw new Error(
						`Payment not found - intent_id: ${pIntentId}, paymentId: ${paymentId}`,
					);
				});

			const ordine = await trx
				.selectFrom("ordini")
				.selectAll("ordini")
				.where("ordine_id", "=", payment.ordine_id)
				.executeTakeFirstOrThrow(() => {
					throw new Error(`Ordine not found - ordine_id: ${payment.ordine_id}`);
				});

			await trx
				.updateTable("ordini")
				.where("ordine_id", "=", payment.ordine_id)
				.set({
					isActive: true,
				})
				.execute();

			const servizio = await trx
				.selectFrom("servizio")
				.select("servizio.tipologia")
				.where("servizio_id", "=", payment.servizio_id)
				.executeTakeFirstOrThrow(() => {
					throw new Error(
						`Servizio not found - servizio_id: ${payment.servizio_id}`,
					);
				});

			const utente = await getUser({
				db: trx,
				userId: ordine.userid,
			});
			const lock_expires = new Date(Date.now() + 60 * 1000); // Lock for 1 minute

			switch (ordine.type) {
				case OrderTypeEnum.Acconto:
					await trx
						.updateTable("servizio")
						.where("servizio_id", "=", payment.servizio_id)
						.set({
							decorrenza: new Date(),
							isOkAcconto: true,
						})
						.execute();

					await addEventToQueue({
						data: {
							tipo: "email",
							data: {
								template: {
									mailType: "servizioAttivato",
								},
								mail: {
									subject: "Pagamento Confermato - Acconto Infoalloggi.it",
									to: utente.email,
									attachments: [
										{
											filename: `condizioni_contrattuali_${ordine.created_at.toISOString()}.pdf`,
											//ATTENTION: hardcoded condizioni key

											generate: {
												type: "condizioni",
												stringId: "CONDIZIONI_CERCHI" as TestiEStringheStingaId,
											},
											encoding: "base64",
											contentType: "application/pdf",
										},
										{
											filename: `ricevuta_cortesia_${ordine.ordine_id}.pdf`,

											generate: {
												type: "ricevuta_cortesia",
												ordineId: ordine.ordine_id,
											},
											encoding: "base64",
											contentType: "application/pdf",
										},
									],
								},
								userId: utente.id,
							},
						},
						lock_expires,
					});
					//SERVIZIO ATTIVATO

					break;

				case OrderTypeEnum.Saldo:
					await trx
						.updateTable("servizio")
						.where("servizio_id", "=", payment.servizio_id)
						.set({
							isOkConsulenza:
								servizio.tipologia === TipologiaPosizioneEnum.Transitorio,
							isOkSaldo: true,
						})
						.execute();
					await addEventToQueue({
						data: {
							tipo: "email",
							data: {
								template: {
									mailType: "pagamentoConferma",
								},
								mail: {
									subject: "Pagamento Confermato - Saldo Infoalloggi.it",
									to: utente.email,
									attachments: [
										{
											filename: `ricevuta_cortesia_${ordine.ordine_id}.pdf`,
											generate: {
												type: "ricevuta_cortesia",
												ordineId: ordine.ordine_id,
											},

											encoding: "base64",
											contentType: "application/pdf",
										},
									],
								},
								userId: utente.id,
							},
						},
						lock_expires,
					});
					//PAGAMENTO SALDO CONFERMATO
					break;
				case OrderTypeEnum.Consulenza:
					await trx
						.updateTable("servizio")
						.where("servizio_id", "=", payment.servizio_id)
						.set({
							isOkConsulenza: true,
						})
						.execute();
					await addEventToQueue({
						data: {
							tipo: "email",
							data: {
								template: {
									mailType: "pagamentoConferma",
								},
								mail: {
									subject: "Pagamento Confermato - Consulenza Infoalloggi.it",
									to: utente.email,
									attachments: [
										{
											filename: `ricevuta_cortesia_${ordine.ordine_id}.pdf`,

											generate: {
												type: "ricevuta_cortesia",
												ordineId: ordine.ordine_id,
											},
											encoding: "base64",
											contentType: "application/pdf",
										},
									],
								},
								userId: utente.id,
							},
						},
						lock_expires,
					});
					//CONSULENZA ATTIVATA
					break;
				case OrderTypeEnum.Altro:
					// TODO: Handle other types
					await addEventToQueue({
						data: {
							tipo: "email",
							data: {
								template: {
									mailType: "pagamentoConferma",
								},
								mail: {
									subject: "Pagamento Confermato - Infoalloggi.it",
									to: utente.email,
									attachments: [
										{
											filename: `ricevuta_cortesia_${ordine.ordine_id}.pdf`,

											generate: {
												type: "ricevuta_cortesia",
												ordineId: ordine.ordine_id,
											},
											encoding: "base64",
											contentType: "application/pdf",
										},
									],
								},
								userId: utente.id,
							},
						},
						lock_expires,
					});
					break;
			}
		});
		return true;
	} catch (error) {
		// Enhanced error logging
		console.error("whIntentSucceededHandler error:", {
			pIntentId,
			paymentId,
			pm_id,
			error: error instanceof Error ? error.message : String(error),
			stack: error instanceof Error ? error.stack : undefined,
		});
		throw new TRPCError({
			code: "INTERNAL_SERVER_ERROR",
			message: `Error updating payment intent: ${(error as Error).message}`,
			cause: error,
		});
	}
};

export const whIntentFailedHandler = async ({
	pIntentId,
}: {
	pIntentId: Payments["intent_id"];
}) => {
	const userId = await db
		.updateTable("payments")
		.set({
			paymentstatus: PaymentStatusEnum.failed,
		})
		.returning("userid")
		.where("intent_id", "=", pIntentId)
		.execute();

	if (userId[0]) {
		const utente = await getUser({
			db,
			userId: userId[0].userid,
		});

		await NewMail({
			template: {
				mailType: "pagamentoErrore",
			},
			mail: {
				subject: "Pagamento Fallito - Infoalloggi.it",
				to: utente.email,
			},
			userId: utente.id,
		});
	}
	return true;
};