B2B-84: add public message sync function and audit schema (#5)

* B2B-84: add public message sync function and audit schema

* clean up unnecessary comment

* clean up unnecessary seed file

* address comments

---------

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

lib/services/medipost.service.ts

@@ -1,10 +1,16 @@
 import {
   GetMessageListResponse,
   MedipostAction,
+  MedipostPublicMessageResponse,
   Message,
+  UuringuGrupp,
 } from "@/lib/types/medipost";
+import { Tables } from "@/supabase/database.types";
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
 import axios from "axios";
-import { xml2json } from "xml-js";
+import { XMLParser } from "fast-xml-parser";
+import { SyncStatus } from "@/lib/types/audit";
+import { toArray } from "@/lib/utils";
 
 const BASE_URL = process.env.MEDIPOST_URL!;
 const USER = process.env.MEDIPOST_USER!;
@@ -15,9 +21,10 @@ export async function getMessages() {
     const publicMessage = await getLatestPublicMessageListItem();
 
     if (!publicMessage) {
-      return [];
+      return null;
     }
 
+    //Teenused tuleb mappida kokku MedReport teenustega. <UuringId> alusel
     return getPublicMessage(publicMessage.messageId);
   } catch (error) {
     console.error(error);
@@ -55,18 +62,13 @@ export async function getPublicMessage(messageId: string) {
       Accept: "application/xml",
     },
   });
+  const parser = new XMLParser({ ignoreAttributes: false });
+  const parsed: MedipostPublicMessageResponse = parser.parse(data);
 
-  if (data.code && data.code !== 0) {
+  if (parsed.ANSWER?.CODE && parsed.ANSWER?.CODE !== 0) {
     throw new Error(`Failed to get public message (id: ${messageId})`);
   }
 
-  const parsed = JSON.parse(
-    xml2json(data, {
-      compact: true,
-      spaces: 2,
-    })
-  );
-
   return parsed;
 }
 
@@ -124,14 +126,8 @@ export async function getPrivateMessage(messageId: string) {
     throw new Error(`Failed to get private message (id: ${messageId})`);
   }
 
-  const parsed = JSON.parse(
-    xml2json(data, {
-      compact: true,
-      spaces: 2,
-    })
-  );
-
-  return parsed;
+  const parser = new XMLParser({ ignoreAttributes: false });
+  return parser.parse(data);
 }
 
 export async function deletePrivateMessage(messageId: string) {
@@ -170,6 +166,187 @@ export async function readPrivateMessageResponse() {
   }
 }
 
+async function saveAnalysisGroup(
+  analysisGroup: UuringuGrupp,
+  supabase: SupabaseClient
+) {
+  const { data: insertedAnalysisGroup, error } = await supabase
+    .from("analysis_groups")
+    .upsert(
+      {
+        original_id: analysisGroup.UuringuGruppId,
+        name: analysisGroup.UuringuGruppNimi,
+        order: analysisGroup.UuringuGruppJarjekord,
+      },
+      { onConflict: "original_id", ignoreDuplicates: false }
+    )
+    .select("id");
+
+  if (error || !insertedAnalysisGroup[0]?.id) {
+    throw new Error(
+      `Failed to insert analysis group (id: ${analysisGroup.UuringuGruppId}), error: ${error?.message}`
+    );
+  }
+  const analysisGroupId = insertedAnalysisGroup[0].id;
+
+  const analysisGroupCodes = toArray(analysisGroup.Kood);
+  const codes: Partial<Tables<"codes">>[] = analysisGroupCodes.map((kood) => ({
+    hk_code: kood.HkKood,
+    hk_code_multiplier: kood.HkKoodiKordaja,
+    coefficient: kood.Koefitsient,
+    price: kood.Hind,
+    analysis_group_id: analysisGroupId,
+  }));
+
+  const analysisGroupItems = toArray(analysisGroup.Uuring);
+
+  for (const item of analysisGroupItems) {
+    const analysisElement = item.UuringuElement;
+
+    const { data: insertedAnalysisElement, error } = await supabase
+      .from("analysis_elements")
+      .upsert(
+        {
+          analysis_id_oid: analysisElement.UuringIdOID,
+          analysis_id_original: analysisElement.UuringId,
+          tehik_short_loinc: analysisElement.TLyhend,
+          tehik_loinc_name: analysisElement.KNimetus,
+          analysis_name_lab: analysisElement.UuringNimi,
+          order: analysisElement.Jarjekord,
+          parent_analysis_group_id: analysisGroupId,
+          material_groups: toArray(item.MaterjalideGrupp),
+        },
+        { onConflict: "analysis_id_original", ignoreDuplicates: false }
+      )
+      .select('id');
+
+    if (error || !insertedAnalysisElement[0]?.id) {
+      throw new Error(
+        `Failed to insert analysis element (id: ${analysisElement.UuringId}), error: ${error?.message}`
+      );
+    }
+
+    const insertedAnalysisElementId = insertedAnalysisElement[0].id;
+
+    if (analysisElement.Kood) {
+      const analysisElementCodes = toArray(analysisElement.Kood);
+      codes.push(
+        ...analysisElementCodes.map((kood) => ({
+          hk_code: kood.HkKood,
+          hk_code_multiplier: kood.HkKoodiKordaja,
+          coefficient: kood.Koefitsient,
+          price: kood.Hind,
+          analysis_element_id: insertedAnalysisElementId,
+        }))
+      );
+    }
+
+    const analyses = analysisElement.UuringuElement;
+    if (analyses?.length) {
+      for (const analysis of analyses) {
+        const { data: insertedAnalysis, error } = await supabase
+          .from("analyses")
+          .upsert(
+            {
+              analysis_id_oid: analysis.UuringIdOID,
+              analysis_id_original: analysis.UuringId,
+              tehik_short_loinc: analysis.TLyhend,
+              tehik_loinc_name: analysis.KNimetus,
+              analysis_name_lab: analysis.UuringNimi,
+              order: analysis.Jarjekord,
+              parent_analysis_element_id: insertedAnalysisElementId,
+            },
+            { onConflict: "analysis_id_original", ignoreDuplicates: false }
+          )
+          .select('id');
+
+        if (error || !insertedAnalysis[0]?.id) {
+          throw new Error(
+            `Failed to insert analysis (id: ${analysis.UuringId}) error: ${error?.message}`
+          );
+        }
+
+        const insertedAnalysisId = insertedAnalysis[0].id;
+        if (analysisElement.Kood) {
+          const analysisCodes = toArray(analysis.Kood);
+
+          codes.push(
+            ...analysisCodes.map((kood) => ({
+              hk_code: kood.HkKood,
+              hk_code_multiplier: kood.HkKoodiKordaja,
+              coefficient: kood.Koefitsient,
+              price: kood.Hind,
+              analysis_id: insertedAnalysisId,
+            }))
+          );
+        }
+      }
+    }
+  }
+
+  const { error: codesError } = await supabase
+    .from("codes")
+    .upsert(codes, { ignoreDuplicates: false });
+
+  if (codesError?.code) {
+    throw new Error(
+      `Failed to insert codes (analysis group id: ${analysisGroup.UuringuGruppId})`
+    );
+  }
+}
+
+export async function syncPublicMessage(
+  message?: MedipostPublicMessageResponse | null
+) {
+  const supabase = createClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_SERVICE_ROLE_KEY!,
+    {
+      auth: {
+        persistSession: false,
+        autoRefreshToken: false,
+        detectSessionInUrl: false,
+      },
+    }
+  );
+
+  try {
+    const providers = toArray(message?.Saadetis?.Teenused.Teostaja);
+    const analysisGroups = providers.flatMap((provider) =>
+      toArray(provider.UuringuGrupp)
+    );
+    if (!message || !analysisGroups.length) {
+      return supabase.schema("audit").from("sync_entries").insert({
+        operation: "ANALYSES_SYNC",
+        comment: "No data received",
+        status: SyncStatus.Fail,
+        changed_by_role: "service_role",
+      });
+    }
+
+    for (const analysisGroup of analysisGroups) {
+      await saveAnalysisGroup(analysisGroup, supabase);
+    }
+
+    await supabase.schema("audit").from("sync_entries").insert({
+      operation: "ANALYSES_SYNC",
+      status: SyncStatus.Success,
+      changed_by_role: "service_role",
+    });
+  } catch (e) {
+    console.error(e);
+    await supabase
+      .schema("audit")
+      .from("sync_entries")
+      .insert({
+        operation: "ANALYSES_SYNC",
+        status: SyncStatus.Fail,
+        comment: JSON.stringify(e),
+        changed_by_role: "service_role",
+      });
+  }
+}
+
 function getLatestMessage(messages?: Message[]) {
   if (!messages?.length) {
     return null;