medreport_mrb2b/app/home/(user)/(dashboard)/cart/montonio-callback/actions.ts

'use server';

import jwt from 'jsonwebtoken';
import { z } from "zod";
import { MontonioOrderToken } from "@/app/home/(user)/_components/cart/types";
import { loadCurrentUserAccount } from "@/app/home/(user)/_lib/server/load-user-account";
import { listProductTypes } from "@lib/data/products";
import { placeOrder, retrieveCart } from "@lib/data/cart";
import { createI18nServerInstance } from "~/lib/i18n/i18n.server";
import { createAnalysisOrder, getAnalysisOrder } from '~/lib/services/order.service';
import { sendOrderToMedipost } from '~/lib/services/medipost/medipostPrivateMessage.service';
import { getOrderedAnalysisIds } from '~/lib/services/medusaOrder.service';
import { createNotificationsApi } from '@kit/notifications/api';
import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
import type { AccountWithParams } from '@kit/accounts/types/accounts';
import type { StoreOrder } from '@medusajs/types';

const ANALYSIS_PACKAGES_TYPE_HANDLE = 'analysis-packages';
const ANALYSIS_TYPE_HANDLE = 'synlab-analysis';
const MONTONIO_PAID_STATUS = 'PAID';

const env = () => z
  .object({
    emailSender: z
      .string({
        error: 'EMAIL_SENDER is required',
      })
      .min(1),
    siteUrl: z
      .string({
        error: 'NEXT_PUBLIC_SITE_URL is required',
      })
      .min(1),
    isEnabledDispatchOnMontonioCallback: z
      .boolean({
        error: 'MEDIPOST_ENABLE_DISPATCH_ON_MONTONIO_CALLBACK is required',
      }),
  })
  .parse({
    emailSender: process.env.EMAIL_SENDER,
    siteUrl: process.env.NEXT_PUBLIC_SITE_URL!,
    isEnabledDispatchOnMontonioCallback: process.env.MEDIPOST_ENABLE_DISPATCH_ON_MONTONIO_CALLBACK === 'true',
  });

const sendEmail = async ({
  account,
  email,
  analysisPackageName,
  partnerLocationName,
  language,
}: {
  account: Pick<AccountWithParams, 'name' | 'id'>,
  email: string,
  analysisPackageName: string,
  partnerLocationName: string,
  language: string,
}) => {
  const client = getSupabaseServerAdminClient();
  try {
    const { renderSynlabAnalysisPackageEmail } = await import('@kit/email-templates');
    const { getMailer } = await import('@kit/mailers');

    const mailer = await getMailer();

    const { html, subject } = await renderSynlabAnalysisPackageEmail({
      analysisPackageName,
      personName: account.name,
      partnerLocationName,
      language,
    });

    await mailer
      .sendEmail({
        from: env().emailSender,
        to: email,
        subject,
        html,
      })
      .catch((error) => {
        throw new Error(`Failed to send email, message=${error}`);
      });
    await createNotificationsApi(client)
      .createNotification({
        account_id: account.id,
        body: html,
      });
  } catch (error) {
    throw new Error(`Failed to send email, message=${error}`);
  }
}

async function decodeOrderToken(orderToken: string) {
  const secretKey = process.env.MONTONIO_SECRET_KEY as string;

  const decoded = jwt.verify(orderToken, secretKey, {
    algorithms: ['HS256'],
  }) as MontonioOrderToken;

  if (decoded.paymentStatus !== MONTONIO_PAID_STATUS) {
    throw new Error("Payment not successful");
  }

  return decoded;
}

async function getCartByOrderToken(decoded: MontonioOrderToken) {
  const [, , cartId] = decoded.merchantReferenceDisplay.split(':');
  if (!cartId) {
    throw new Error("Cart ID not found");
  }
  const cart = await retrieveCart(cartId);
  if (!cart) {
    throw new Error("Cart not found");
  }
  return cart;
}

async function getOrderResultParameters(medusaOrder: StoreOrder) {
  const { productTypes } = await listProductTypes();
  const analysisPackagesType = productTypes.find(({ metadata }) => metadata?.handle === ANALYSIS_PACKAGES_TYPE_HANDLE);
  const analysisType = productTypes.find(({ metadata }) => metadata?.handle === ANALYSIS_TYPE_HANDLE);

  const analysisPackageOrderItem = medusaOrder.items?.find(({ product_type_id }) => product_type_id === analysisPackagesType?.id);
  const analysisItems = medusaOrder.items?.filter(({ product_type_id }) => product_type_id === analysisType?.id);

  return {
    medusaOrderId: medusaOrder.id,
    email: medusaOrder.email,
    analysisPackageOrder: analysisPackageOrderItem
      ? {
        partnerLocationName: analysisPackageOrderItem?.metadata?.partner_location_name as string ?? '',
        analysisPackageName: analysisPackageOrderItem?.title ?? '',
      }
      : null,
    analysisItemsOrder: Array.isArray(analysisItems) && analysisItems.length > 0
      ? analysisItems.map(({ product }) => ({
          analysisName: product?.title ?? '',
          analysisId: product?.metadata?.analysisIdOriginal as string ?? '',
        }))
      : null,
  };
}

async function sendAnalysisPackageOrderEmail({
  account,
  email,
  analysisPackageOrder,
}: {
  account: AccountWithParams,
  email: string,
  analysisPackageOrder: {
    partnerLocationName: string,
    analysisPackageName: string,
  },
}) {
  const { language } = await createI18nServerInstance();
  const { analysisPackageName, partnerLocationName } = analysisPackageOrder;
  try {
    await sendEmail({
      account: { id: account.id, name: account.name },
      email,
      analysisPackageName,
      partnerLocationName,
      language,
    });
  } catch (error) {
    console.error("Failed to send email", error);
  }
}

export async function processMontonioCallback(orderToken: string) {
  const { account } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error("Account not found in context");
  }

  try {
    const decoded = await decodeOrderToken(orderToken);
    const cart = await getCartByOrderToken(decoded);

    const medusaOrder = await placeOrder(cart.id, { revalidateCacheTags: false });
    const orderedAnalysisElements = await getOrderedAnalysisIds({ medusaOrder });

    try {
      const existingAnalysisOrder = await getAnalysisOrder({ medusaOrderId: medusaOrder.id });
      console.info(`Analysis order already exists for medusaOrderId=${medusaOrder.id}, orderId=${existingAnalysisOrder.id}`);
      return { success: true, orderId: existingAnalysisOrder.id };
    } catch {
      // ignored
    }

    const orderId = await createAnalysisOrder({ medusaOrder, orderedAnalysisElements });
    const orderResult = await getOrderResultParameters(medusaOrder);

    const { medusaOrderId, email, analysisPackageOrder, analysisItemsOrder } = orderResult;

    if (email) {
      if (analysisPackageOrder) {
        await sendAnalysisPackageOrderEmail({ account, email, analysisPackageOrder });
      } else {
        console.info(`Order has no analysis package, skipping email.`);
      }

      if (analysisItemsOrder) {
        // @TODO send email for separate analyses
        console.warn(`Order has analysis items, but no email template exists yet`);
      } else {
        console.info(`Order has no analysis items, skipping email.`);
      }
    } else {
      console.error("Missing email to send order result email", orderResult);
    }

    if (env().isEnabledDispatchOnMontonioCallback) {
      await sendOrderToMedipost({ medusaOrderId, orderedAnalysisElements });
    }

    return { success: true, orderId };
  } catch (error) {
    console.error("Failed to place order", error);
    throw new Error(`Failed to place order, message=${error}`);
  }
}