medreport_mrb2b/lib/services/medusaCart.service.ts

'use server';

import { loadCurrentUserAccount } from '@/app/home/(user)/_lib/server/load-user-account';
import { MontonioOrderHandlerService } from '@/packages/billing/montonio/src';
import { addToCart, deleteLineItem, retrieveCart } from '@lib/data/cart';
import { getCartId } from '@lib/data/cookies';
import { StoreCartLineItem, StoreProductVariant } from '@medusajs/types';
import { z } from 'zod';



import { getSupabaseServerClient } from '@kit/supabase/server-client';



import { cancelReservation, getOrderedTtoServices } from '~/lib/services/reservation.service';



import { isSameMinute } from 'date-fns';
import { getAvailableAppointmentsForService } from './connected-online.service';





const env = () =>
  z
    .object({
      medusaBackendPublicUrl: z
        .string({
          error: 'MEDUSA_BACKEND_PUBLIC_URL is required',
        })
        .min(1),
      siteUrl: z
        .string({
          error: 'NEXT_PUBLIC_SITE_URL is required',
        })
        .min(1),
    })
    .parse({
      medusaBackendPublicUrl: process.env.MEDUSA_BACKEND_PUBLIC_URL!,
      siteUrl: process.env.NEXT_PUBLIC_SITE_URL!,
    });

export async function handleAddToCart({
  selectedVariant,
  countryCode,
}: {
  selectedVariant: Pick<StoreProductVariant, 'id'>;
  countryCode: string;
}) {
  const supabase = getSupabaseServerClient();
  const { account, user } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  const quantity = 1;
  const { newCart, addedItem } = await addToCart({
    variantId: selectedVariant.id,
    quantity,
    countryCode,
  });

  const { error } = await supabase.schema('audit').from('cart_entries').insert({
    variant_id: selectedVariant.id,
    operation: 'ADD_TO_CART',
    account_id: account.id,
    cart_id: newCart.id,
    changed_by: user.id,
  });
  if (error) {
    throw new Error('Error logging cart entry: ' + error.message);
  }

  return { cart: newCart, addedItem };
}

export async function handleDeleteCartItem({ lineId }: { lineId: string }) {
  await deleteLineItem(lineId);
  await cancelReservation(lineId);

  const supabase = getSupabaseServerClient();
  const cartId = await getCartId();
  const { account, user } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  const { error } = await supabase.schema('audit').from('cart_entries').insert({
    variant_id: lineId,
    operation: 'REMOVE_FROM_CART',
    account_id: account.id,
    cart_id: cartId!,
    changed_by: user.id,
  });
  if (error) {
    throw new Error('Error logging cart entry: ' + error.message);
  }
}

export async function handleNavigateToPayment({
  language,
  paymentSessionId,
}: {
  language: string;
  paymentSessionId: string;
}) {
  const supabase = getSupabaseServerClient();
  const { account, user } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  const cart = await retrieveCart();
  if (!cart) {
    throw new Error('No cart found');
  }
    const orderedTtoServices = await getOrderedTtoServices({ cart });

    if (orderedTtoServices?.length) {
      const unavailableLineItemIds: string[] = []
      for (const ttoService of orderedTtoServices) {
        const availabilities = await getAvailableAppointmentsForService(
          ttoService.service_id,
          ttoService.provider.key,
          ttoService.location_sync_id,
          new Date(ttoService.start_time),
          1,
        );
        const isAvailable = availabilities?.T_Booking?.length ? availabilities.T_Booking.find((timeSlot) => isSameMinute(ttoService.start_time, timeSlot.StartTime)) : false
        
        if (!isAvailable) {
          unavailableLineItemIds.push(ttoService.medusa_cart_line_item_id!)
        }
      }

      if (unavailableLineItemIds.length) {
        return { unavailableLineItemIds }
      }
    }
  

  const paymentLink =
    await new MontonioOrderHandlerService().getMontonioPaymentLink({
      notificationUrl: `${env().medusaBackendPublicUrl}/hooks/payment/montonio_montonio`,
      returnUrl: `${env().siteUrl}/home/cart/montonio-callback`,
      amount: cart.total,
      currency: cart.currency_code.toUpperCase(),
      description: `Order from Medreport`,
      locale: language,
      merchantReference: `${account.id}:${paymentSessionId}:${cart.id}`,
    });

  const { error } = await supabase.schema('audit').from('cart_entries').insert({
    operation: 'NAVIGATE_TO_PAYMENT',
    account_id: account.id,
    cart_id: cart.id,
    changed_by: user.id,
  });
  
  if (error) {
    throw new Error('Error logging cart entry: ' + error.message);
  }

  return { url: paymentLink };
}

export async function handleLineItemTimeout({
  lineItem,
}: {
  lineItem: StoreCartLineItem;
}) {
  const supabase = getSupabaseServerClient();
  const { account, user } = await loadCurrentUserAccount();
  if (!account) {
    throw new Error('Account not found');
  }

  await deleteLineItem(lineItem.id);

  const { error } = await supabase.schema('audit').from('cart_entries').insert({
    operation: 'LINE_ITEM_TIMEOUT',
    account_id: account.id,
    cart_id: lineItem.cart_id,
    changed_by: user.id,
  });
  if (error) {
    throw new Error('Error logging cart entry: ' + error.message);
  }
}