feat(MED-161): delete unused functions

lib/services/medipost.service.ts

@@ -1,30 +1,17 @@
 'use server';
 
-import {
-  SupabaseClient,
-  createClient as createCustomClient,
-} from '@supabase/supabase-js';
-
-import { SyncStatus } from '@/lib/types/audit';
 import {
   GetMessageListResponse,
   MedipostAction,
-  MedipostPublicMessageResponse,
-  UuringuGrupp,
 } from '@/lib/types/medipost';
-import { toArray } from '@/lib/utils';
 import axios from 'axios';
 
-import { Tables } from '@kit/supabase/database';
-import { createAnalysisGroup } from './analysis-group.service';
 import { getAnalysisElements } from './analysis-element.service';
 import { getAnalyses } from './analyses.service';
 import { StoreOrder } from '@medusajs/types';
 import { listProducts } from '@lib/data/products';
 import { listRegions } from '@lib/data/regions';
 import { getAnalysisElementMedusaProductIds } from '@/utils/medusa-product';
-import { validateMedipostResponse } from './medipost/medipostValidate.service';
-import { parseXML } from './util/xml.service';
 import { getLatestMessage } from './medipost/medipostMessageBase.service';
 
 const BASE_URL = process.env.MEDIPOST_URL!;
@@ -34,21 +21,6 @@ const RECIPIENT = process.env.MEDIPOST_RECIPIENT!;
 
 const ANALYSIS_PACKAGE_HANDLE_PREFIX = 'analysis-package-';
 
-export async function getMessages() {
-  try {
-    const publicMessage = await getLatestPublicMessageListItem();
-
-    if (!publicMessage) {
-      return null;
-    }
-
-    //Teenused tuleb mappida kokku MedReport teenustega. <UuringId> alusel
-    return getPublicMessage(publicMessage.messageId);
-  } catch (error) {
-    console.error(error);
-  }
-}
-
 export async function getLatestPublicMessageListItem() {
   const { data } = await axios.get<GetMessageListResponse>(BASE_URL, {
     params: {
@@ -68,194 +40,6 @@ export async function getLatestPublicMessageListItem() {
   return getLatestMessage({ messages: data?.messages });
 }
 
-export async function getPublicMessage(messageId: string) {
-  const { data } = await axios.get(BASE_URL, {
-    params: {
-      Action: MedipostAction.GetPublicMessage,
-      User: USER,
-      Password: PASSWORD,
-      MessageId: messageId,
-    },
-    headers: {
-      Accept: 'application/xml',
-    },
-  });
-  await validateMedipostResponse(data);
-  return parseXML(data) as MedipostPublicMessageResponse;
-}
-
-async function saveAnalysisGroup(
-  analysisGroup: UuringuGrupp,
-  supabase: SupabaseClient,
-) {
-  const analysisGroupId = await createAnalysisGroup({
-    id: analysisGroup.UuringuGruppId,
-    name: analysisGroup.UuringuGruppNimi,
-    order: analysisGroup.UuringuGruppJarjekord,
-  });
-
-  const analysisGroupCodes = toArray(analysisGroup.Kood);
-  const codes: Partial<Tables<{ schema: 'medreport' }, '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
-      .schema('medreport')
-      .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
-          .schema('medreport')
-          .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
-    .schema('medreport')
-    .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 = createCustomClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.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',
-      });
-  }
-}
-
 export async function getOrderedAnalysisIds({
   medusaOrder,
 }: {