B2B-86: add function to save order response (#11)

* fix import

* B2B-86: add function to save order response

* fix private message parsing

* generate new types

* clean up

* remove comment

---------

Co-authored-by: Helena <helena@Helenas-MacBook-Pro.local>

lib/services/medipost.service.ts

@@ -20,8 +20,10 @@ import {
   GetMessageListResponse,
   MaterjalideGrupp,
   MedipostAction,
+  MedipostOrderResponse,
   MedipostPublicMessageResponse,
   Message,
+  ResponseUuringuGrupp,
   UuringuGrupp,
 } from '@/lib/types/medipost';
 import { toArray } from '@/lib/utils';
@@ -140,12 +142,14 @@ export async function getPrivateMessage(messageId: string) {
     },
   });
 
-  if (data.code && data.code !== 0) {
+  const parser = new XMLParser({ ignoreAttributes: false });
+  const parsed = parser.parse(data);
+
+  if (parsed.ANSWER?.CODE && parsed.ANSWER?.CODE !== 0) {
     throw new Error(`Failed to get private message (id: ${messageId})`);
   }
 
-  const parser = new XMLParser({ ignoreAttributes: false });
-  return parser.parse(data);
+  return parsed;
 }
 
 export async function deletePrivateMessage(messageId: string) {
@@ -175,8 +179,9 @@ export async function readPrivateMessageResponse() {
       privateMessage.messageId,
     );
 
-    if (privateMessageContent) {
-      // to be implemented: map and save, only delete if successful
+    const status = await syncPrivateMessage(privateMessageContent);
+
+    if (status === 'COMPLETED') {
       await deletePrivateMessage(privateMessage.messageId);
     }
   } catch (e) {
@@ -307,7 +312,6 @@ async function saveAnalysisGroup(
     .upsert(codes, { ignoreDuplicates: false });
 
   if (codesError?.code) {
-    console.error(codesError); // TODO remove this
     throw new Error(
       `Failed to insert codes (analysis group id: ${analysisGroup.UuringuGruppId})`,
     );
@@ -514,3 +518,113 @@ function getLatestMessage(messages?: Message[]) {
     Number(prev.messageId) > Number(current.messageId) ? prev : current,
   );
 }
+
+export async function syncPrivateMessage(
+  parsedMessage?: MedipostOrderResponse,
+) {
+  const supabase = createCustomClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_SERVICE_ROLE_KEY!,
+    {
+      auth: {
+        persistSession: false,
+        autoRefreshToken: false,
+        detectSessionInUrl: false,
+      },
+    },
+  );
+
+  const response = parsedMessage?.Saadetis?.Vastus;
+
+  if (!response) {
+    throw new Error(`Invalid data in private message response`);
+  }
+
+  const status = response.TellimuseOlek;
+
+  const { data: analysisOrder, error: analysisOrderError } = await supabase
+    .from('analysis_orders')
+    .select('user_id')
+    .eq('id', response.ValisTellimuseId);
+
+  if (analysisOrderError || !analysisOrder?.[0]?.user_id) {
+    throw new Error(
+      `Could not find analysis order with id ${response.ValisTellimuseId}`,
+    );
+  }
+
+  const { data: analysisResponse, error } = await supabase
+    .from('analysis_responses')
+    .upsert(
+      {
+        analysis_order_id: response.ValisTellimuseId,
+        order_number: response.TellimuseNumber,
+        order_status: AnalysisOrderStatus[status],
+        user_id: analysisOrder[0].user_id,
+      },
+      { onConflict: 'order_number', ignoreDuplicates: false },
+    )
+    .select('id');
+
+  if (error || !analysisResponse?.[0]?.id) {
+    throw new Error(
+      `Failed to insert or update analysis order response (external id: ${response?.TellimuseNumber})`,
+    );
+  }
+  const analysisGroups = toArray(response.UuringuGrupp);
+
+  const responses: Omit<
+    Tables<'analysis_response_elements'>,
+    'id' | 'created_at' | 'updated_at'
+  >[] = [];
+  for (const analysisGroup of analysisGroups) {
+    const groupItems = toArray(
+      analysisGroup.Uuring as ResponseUuringuGrupp['Uuring'],
+    );
+    for (const item of groupItems) {
+      const element = item.UuringuElement;
+      const elementAnalysisResponses = toArray(element.UuringuVastus);
+
+      responses.push(
+        ...elementAnalysisResponses.map((response) => ({
+          analysis_element_original_id: element.UuringId,
+          analysis_response_id: analysisResponse[0]!.id,
+          norm_lower: response.NormAlum?.['#text'] ?? null,
+          norm_lower_included:
+            response.NormAlum?.['@_kaasaarvatud'].toLowerCase() === 'jah',
+          norm_status: response.NormiStaatus,
+          norm_upper: response.NormYlem?.['#text'] ?? null,
+          norm_upper_included:
+            response.NormYlem?.['@_kaasaarvatud'].toLowerCase() === 'jah',
+          response_time: response.VastuseAeg ?? null,
+          response_value: response.VastuseVaartus,
+          unit: element.Mootyhik ?? null,
+          original_response_element: element,
+        })),
+      );
+    }
+  }
+
+  const { error: deleteError } = await supabase
+    .from('analysis_response_elements')
+    .delete()
+    .eq('analysis_response_id', analysisResponse[0].id);
+
+  if (deleteError) {
+    throw new Error(
+      `Failed to clean up response elements for response id ${analysisResponse[0].id}`,
+    );
+  }
+
+  const { error: elementInsertError } = await supabase
+    .from('analysis_response_elements')
+    .insert(responses);
+
+  if (elementInsertError) {
+    throw new Error(
+      `Failed to insert order response elements for response id ${analysisResponse[0].id}`,
+    );
+  }
+
+  return AnalysisOrderStatus[status];
+}