wip

lib/services/analyses.service.ts

@@ -2,7 +2,7 @@ import type { Tables } from '@/packages/supabase/src/database.types';
 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
 import type { IUuringElement } from "./medipost.types";
 
-type AnalysesWithGroupsAndElements = ({
+export type AnalysesWithGroupsAndElements = ({
   analysis_elements: Tables<{ schema: 'medreport' }, 'analysis_elements'> & {
     analysis_groups: Tables<{ schema: 'medreport' }, 'analysis_groups'>;
   };

lib/services/medipost.service.ts

@@ -37,10 +37,10 @@ import { Tables } from '@kit/supabase/database';
 import { createAnalysisGroup } from './analysis-group.service';
 import { getSupabaseServerAdminClient } from '@/packages/supabase/src/clients/server-admin-client';
 import { getOrder, updateOrderStatus } from './order.service';
-import { getAnalysisElements, getAnalysisElementsAdmin } from './analysis-element.service';
-import { getAnalyses } from './analyses.service';
+import { AnalysisElement, getAnalysisElements, getAnalysisElementsAdmin } from './analysis-element.service';
+import { AnalysesWithGroupsAndElements, getAnalyses } from './analyses.service';
 import { getAccountAdmin } from './account.service';
-import { StoreOrder } from '@medusajs/types';
+import { StoreOrder, StoreOrderLineItem } from '@medusajs/types';
 import { listProducts } from '@lib/data/products';
 import { listRegions } from '@lib/data/regions';
 import { getAnalysisElementMedusaProductIds } from '@/utils/medusa-product';
@@ -480,72 +480,60 @@ export async function composeOrderXML({
     throw new Error(`Got ${analyses.length} analyses, expected ${orderedAnalysesIds.length}`);
   }
 
+  const uniques = [
+    ...analysisElements?.flatMap(({ analysis_groups }) => analysis_groups) ?? [],
+    ...analyses?.flatMap(({ analysis_elements }) => analysis_elements.analysis_groups) ?? []
+  ];
   const analysisGroups: Tables<{ schema: 'medreport' }, 'analysis_groups'>[] =
-    uniqBy(
-      (
-        analysisElements?.flatMap(({ analysis_groups }) => analysis_groups) ??
-        []
-      ).concat(
-        analyses?.flatMap(
-          ({ analysis_elements }) => analysis_elements.analysis_groups,
-        ) ?? [],
-      ),
-      'id',
-    );
+    uniqBy(uniques, 'id');
+  console.log('analysisGroups', { analysisGroups, uniques });
 
   const specimenSection = [];
   const analysisSection = [];
   let order = 1;
   for (const currentGroup of analysisGroups) {
-    let relatedAnalysisElement = analysisElements?.find(
-      (element) => element.analysis_groups.id === currentGroup.id,
-    );
-    const relatedAnalyses = analyses?.filter((analysis) => {
-      return analysis.analysis_elements.analysis_groups.id === currentGroup.id;
+    const relatedAnalysisElements = await getRelatedAnalysisElements({
+      analysisElements,
+      analyses,
+      currentGroup,
     });
 
-    if (!relatedAnalysisElement) {
-      relatedAnalysisElement = relatedAnalyses?.find(
-        (relatedAnalysis) =>
-          relatedAnalysis.analysis_elements.analysis_groups.id ===
-          currentGroup.id,
-      )?.analysis_elements;
-    }
+    for (const relatedAnalysisElement of relatedAnalysisElements) {
+      if (!relatedAnalysisElement || !relatedAnalysisElement.material_groups) {
+        throw new Error(
+          `Failed to find related analysis element for group ${currentGroup.name} (id: ${currentGroup.id})`,
+        );
+      }
 
-    if (!relatedAnalysisElement || !relatedAnalysisElement.material_groups) {
-      throw new Error(
-        `Failed to find related analysis element for group ${currentGroup.name} (id: ${currentGroup.id})`,
+      for (const group of relatedAnalysisElement?.material_groups as MaterjalideGrupp[]) {
+        const materials = toArray(group.Materjal);
+        const specimenXml = materials.flatMap(
+          ({ MaterjaliNimi, MaterjaliTyyp, MaterjaliTyypOID, Konteiner }) => {
+            return toArray(Konteiner).map((container) =>
+              getSpecimen(
+                MaterjaliTyypOID,
+                MaterjaliTyyp,
+                MaterjaliNimi,
+                order,
+                container.ProovinouKoodOID,
+                container.ProovinouKood,
+              ),
+            );
+          },
+        );
+
+        specimenSection.push(...specimenXml);
+      }
+      
+      const groupXml = getAnalysisGroup(
+        currentGroup.original_id,
+        currentGroup.name,
+        order,
+        relatedAnalysisElement,
       );
+      order++;
+      analysisSection.push(groupXml);
     }
-
-    for (const group of relatedAnalysisElement?.material_groups as MaterjalideGrupp[]) {
-      const materials = toArray(group.Materjal);
-      const specimenXml = materials.flatMap(
-        ({ MaterjaliNimi, MaterjaliTyyp, MaterjaliTyypOID, Konteiner }) => {
-          return toArray(Konteiner).map((container) =>
-            getSpecimen(
-              MaterjaliTyypOID,
-              MaterjaliTyyp,
-              MaterjaliNimi,
-              order,
-              container.ProovinouKoodOID,
-              container.ProovinouKood,
-            ),
-          );
-        },
-      );
-
-      specimenSection.push(...specimenXml);
-    }
-
-    const groupXml = getAnalysisGroup(
-      currentGroup.original_id,
-      currentGroup.name,
-      order,
-      relatedAnalysisElement,
-    );
-    order++;
-    analysisSection.push(groupXml);
   }
 
   return `<?xml version="1.0" encoding="UTF-8"?>
@@ -695,7 +683,7 @@ async function syncPrivateMessage({
     );
   }
 
-  const { data: allOrderResponseElements} = await supabase
+  const { data: allOrderResponseElements } = await supabase
     .schema('medreport')
     .from('analysis_response_elements')
     .select('*')
@@ -784,10 +772,13 @@ export async function sendOrderToMedipost({
   await updateOrderStatus({ medusaOrderId, orderStatus: 'PROCESSING' });
 }
 
+type OrderItems = {
+  items: Pick<StoreOrderLineItem, 'product'>[];
+}
 export async function getOrderedAnalysisIds({
   medusaOrder,
 }: {
-  medusaOrder: StoreOrder;
+  medusaOrder: OrderItems;
 }): Promise<{
   analysisElementId?: number;
   analysisId?: number;
@@ -795,7 +786,7 @@ export async function getOrderedAnalysisIds({
   const countryCodes = await listRegions();
   const countryCode = countryCodes[0]!.countries![0]!.iso_2!;
 
-  async function getOrderedAnalysisElements(medusaOrder: StoreOrder) {
+  async function getOrderedAnalysisElements(medusaOrder: OrderItems) {
     const originalIds = (medusaOrder?.items ?? [])
       .map((a) => a.product?.metadata?.analysisIdOriginal)
       .filter((a) => typeof a === 'string') as string[];
@@ -803,7 +794,7 @@ export async function getOrderedAnalysisIds({
     return analysisElements.map(({ id }) => ({ analysisElementId: id }));
   }
 
-  async function getOrderedAnalyses(medusaOrder: StoreOrder) {
+  async function getOrderedAnalyses(medusaOrder: OrderItems) {
     const originalIds = (medusaOrder?.items ?? [])
       .map((a) => a.product?.metadata?.analysisIdOriginal)
       .filter((a) => typeof a === 'string') as string[];
@@ -811,7 +802,7 @@ export async function getOrderedAnalysisIds({
     return analyses.map(({ id }) => ({ analysisId: id }));
   }
 
-  async function getOrderedAnalysisPackages(medusaOrder: StoreOrder) {
+  async function getOrderedAnalysisPackages(medusaOrder: OrderItems) {
     const orderedPackages = (medusaOrder?.items ?? []).filter(({ product }) => product?.handle.startsWith(ANALYSIS_PACKAGE_HANDLE_PREFIX));
     const orderedPackageIds = orderedPackages.map(({ product }) => product?.id).filter(Boolean) as string[];
     if (orderedPackageIds.length === 0) {
@@ -868,10 +859,10 @@ export async function createMedipostActionLog({
   hasError = false,
 }: {
   action:
-    | 'send_order_to_medipost'
-    | 'sync_analysis_results_from_medipost'
-    | 'send_fake_analysis_results_to_medipost'
-    | 'send_analysis_results_to_medipost';
+  | 'send_order_to_medipost'
+  | 'sync_analysis_results_from_medipost'
+  | 'send_fake_analysis_results_to_medipost'
+  | 'send_analysis_results_to_medipost';
   xml: string;
   hasAnalysisResults?: boolean;
   medusaOrderId?: string | null;
@@ -892,3 +883,39 @@ export async function createMedipostActionLog({
     .select('id')
     .throwOnError();
 }
+
+async function getRelatedAnalysisElements({
+  analysisElements,
+  analyses,
+  currentGroup,
+}: {
+  analysisElements: AnalysisElement[];
+  analyses: AnalysesWithGroupsAndElements;
+  currentGroup: {
+    created_at: string;
+    id: number;
+    name: string;
+    order: number;
+    original_id: string;
+    updated_at: string | null;
+  };
+}) {
+  const relatedAnalysisElements: AnalysisElement[] = [];
+
+  const related1 = analysisElements?.filter(
+    (element) => element.analysis_groups.id === currentGroup.id,
+  );
+  if (related1) {
+    relatedAnalysisElements.push(...related1);
+  }
+
+  const related2 = analyses
+    ?.filter(({ analysis_elements }) => analysis_elements.analysis_groups.id === currentGroup.id)
+    ?.filter(({ analysis_elements }) => analysis_elements.analysis_groups.id === currentGroup.id)
+    ?.flatMap(({ analysis_elements }) => analysis_elements);
+  if (related2) {
+    relatedAnalysisElements.push(...related2);
+  }
+
+  return relatedAnalysisElements;
+}

lib/services/medusaCart.service.ts

@@ -110,7 +110,7 @@ export async function handleNavigateToPayment({
   const paymentLink =
     await new MontonioOrderHandlerService().getMontonioPaymentLink({
       notificationUrl: `${env().medusaBackendPublicUrl}/hooks/payment/montonio_montonio`,
-      returnUrl: `${env().siteUrl}/home/cart/montonio-callback`,
+      returnUrl: `${"https://webhook.site"}/home/cart/montonio-callback`,
       amount: cart.total,
       currency: cart.currency_code.toUpperCase(),
       description: `Order from Medreport`,