feat(MED-105): update analysis results view to be by analysis order

lib/services/medipost.service.ts

@@ -36,7 +36,7 @@ import { uniqBy } from 'lodash';
 import { Tables } from '@kit/supabase/database';
 import { createAnalysisGroup } from './analysis-group.service';
 import { getSupabaseServerAdminClient } from '@/packages/supabase/src/clients/server-admin-client';
-import { getOrder, updateOrder } from './order.service';
+import { getOrder, updateOrderStatus } from './order.service';
 import { getAnalysisElements, getAnalysisElementsAdmin } from './analysis-element.service';
 import { getAnalyses } from './analyses.service';
 import { getAccountAdmin } from './account.service';
@@ -218,24 +218,30 @@ export async function readPrivateMessageResponse({
       privateMessage.messageId,
     );
     const messageResponse = privateMessageContent?.Saadetis?.Vastus;
+    const medusaOrderId = privateMessageContent?.Saadetis?.Tellimus?.ValisTellimuseId;
 
     if (!messageResponse) {
-      throw new Error(`Private message response has no results yet`);
+      if (medusaOrderId === 'order_01K2JSJXR5XVNRWEAGB199RCKP') {
+        console.info("messageResponse", JSON.stringify(privateMessageContent, null, 2));
+      }
+      throw new Error(`Private message response has no results yet for order=${medusaOrderId}`);
     }
-    console.info(`Private message content: ${JSON.stringify(privateMessageContent)}`);
 
     let order: Tables<{ schema: 'medreport' }, 'analysis_orders'>;
     try {
-      order = await getOrder({ medusaOrderId: messageResponse.ValisTellimuseId });
+      order = await getOrder({ medusaOrderId });
     } catch (e) {
       await deletePrivateMessage(privateMessage.messageId);
-      throw new Error(`Order not found by Medipost message ValisTellimuseId=${messageResponse.ValisTellimuseId}`);
+      throw new Error(`Order not found by Medipost message ValisTellimuseId=${medusaOrderId}`);
     }
 
     const status = await syncPrivateMessage({ messageResponse, order });
 
-    if (status === 'COMPLETED') {
-      await updateOrder({ orderId: order.id, orderStatus: 'FULL_ANALYSIS_RESPONSE' });
+    if (status.isPartial) {
+      await updateOrderStatus({ medusaOrderId, orderStatus: 'PARTIAL_ANALYSIS_RESPONSE' });
+      messageIdProcessed = privateMessage.messageId;
+    } else if (status.isCompleted) {
+      await updateOrderStatus({ medusaOrderId, orderStatus: 'FULL_ANALYSIS_RESPONSE' });
       await deletePrivateMessage(privateMessage.messageId);
       messageIdProcessed = privateMessage.messageId;
     }
@@ -559,11 +565,11 @@ function getLatestMessage({
   );
 }
 
-export async function syncPrivateMessage({
+async function syncPrivateMessage({
   messageResponse,
   order,
 }: {
-  messageResponse: MedipostOrderResponse['Saadetis']['Vastus'];
+  messageResponse: NonNullable<MedipostOrderResponse['Saadetis']['Vastus']>;
   order: Tables<{ schema: 'medreport' }, 'analysis_orders'>;
 }) {
   const supabase = getSupabaseServerAdminClient()
@@ -606,6 +612,9 @@ export async function syncPrivateMessage({
     Tables<{ schema: 'medreport' }, 'analysis_response_elements'>,
     'id' | 'created_at' | 'updated_at'
   >[] = [];
+
+  const analysisResponseId = analysisResponse[0]!.id;
+
   for (const analysisGroup of analysisGroups) {
     const groupItems = toArray(
       analysisGroup.Uuring as ResponseUuringuGrupp['Uuring'],
@@ -618,7 +627,7 @@ export async function syncPrivateMessage({
       responses.push(
         ...elementAnalysisResponses.map((response) => ({
           analysis_element_original_id: element.UuringId,
-          analysis_response_id: analysisResponse[0]!.id,
+          analysis_response_id: analysisResponseId,
           norm_lower: response.NormAlum?.['#text'] ?? null,
           norm_lower_included:
             response.NormAlum?.['@_kaasaarvatud'].toLowerCase() === 'jah',
@@ -640,11 +649,11 @@ export async function syncPrivateMessage({
     .schema('medreport')
     .from('analysis_response_elements')
     .delete()
-    .eq('analysis_response_id', analysisResponse[0].id);
+    .eq('analysis_response_id', analysisResponseId);
 
   if (deleteError) {
     throw new Error(
-      `Failed to clean up response elements for response id ${analysisResponse[0].id}`,
+      `Failed to clean up response elements for response id ${analysisResponseId}`,
     );
   }
 
@@ -655,12 +664,23 @@ export async function syncPrivateMessage({
 
   if (elementInsertError) {
     throw new Error(
-      `Failed to insert order response elements for response id ${analysisResponse[0].id}`,
+      `Failed to insert order response elements for response id ${analysisResponseId}`,
     );
   }
 
-  console.info("status", AnalysisOrderStatus[messageResponse.TellimuseOlek], messageResponse.TellimuseOlek);
-  return AnalysisOrderStatus[messageResponse.TellimuseOlek];
+  const { data: allOrderResponseElements} = await supabase
+    .schema('medreport')
+    .from('analysis_response_elements')
+    .select('*')
+    .eq('analysis_response_id', analysisResponseId)
+    .throwOnError();
+  const expectedOrderResponseElements = order.analysis_element_ids?.length ?? 0;
+  if (allOrderResponseElements.length !== expectedOrderResponseElements) {
+    return { isPartial: true };
+  }
+
+  const statusFromResponse = AnalysisOrderStatus[messageResponse.TellimuseOlek];
+  return { isCompleted: statusFromResponse === 'COMPLETED' };
 }
 
 export async function sendOrderToMedipost({
@@ -688,7 +708,7 @@ export async function sendOrderToMedipost({
   });
 
   await sendPrivateMessage(orderXml);
-  await updateOrder({ orderId: medreportOrder.id, orderStatus: 'PROCESSING' });
+  await updateOrderStatus({ medusaOrderId, orderStatus: 'PROCESSING' });
 }
 
 export async function getOrderedAnalysisElementsIds({
@@ -720,7 +740,7 @@ export async function getOrderedAnalysisElementsIds({
       countryCode,
       queryParams: { limit: 100, id: orderedPackageIds },
     });
-    console.info(`Order has ${orderedPackagesProducts.length} packages`);
+    console.info(`Order has ${orderedPackagesProducts.length} packages = ${JSON.stringify(orderedPackageIds, null, 2)}`);
     if (orderedPackagesProducts.length !== orderedPackageIds.length) {
       throw new Error(`Got ${orderedPackagesProducts.length} ordered packages products, expected ${orderedPackageIds.length}`);
     }

lib/services/order.service.ts

@@ -56,6 +56,30 @@ export async function updateOrder({
     .throwOnError();
 }
 
+export async function updateOrderStatus({
+  orderId,
+  medusaOrderId,
+  orderStatus,
+}: {
+  orderId?: number;
+  medusaOrderId?: string;
+  orderStatus: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status'];
+}) {
+  const orderIdParam = orderId;
+  const medusaOrderIdParam = medusaOrderId;
+  if (!orderIdParam && !medusaOrderIdParam) {
+    throw new Error('Either orderId or medusaOrderId must be provided');
+  }
+  await getSupabaseServerAdminClient()
+    .schema('medreport')
+    .rpc('update_analysis_order_status', {
+      order_id: orderIdParam ?? -1,
+      status_param: orderStatus,
+      medusa_order_id_param: medusaOrderIdParam ?? '',
+    })
+    .throwOnError();
+}
+
 export async function getOrder({
   medusaOrderId,
   orderId,
@@ -91,6 +115,6 @@ export async function getAnalysisOrders({
   if (orderStatus) {
     query.eq('status', orderStatus);
   }
-  const orders = await query.throwOnError();
+  const orders = await query.order('created_at', { ascending: false }).throwOnError();
   return orders.data;
 }

lib/types/medipost.ts

@@ -202,7 +202,7 @@ export type MedipostOrderResponse = IMedipostResponseXMLBase & {
       SaadetisId: string;
       Email: string;
     };
-    Vastus: {
+    Vastus?: {
       ValisTellimuseId: string;
       Asutus: {
         '@_tyyp': string; // TEOSTAJA
@@ -246,6 +246,9 @@ export type MedipostOrderResponse = IMedipostResponseXMLBase & {
       TellimuseOlek: keyof typeof AnalysisOrderStatus;
       UuringuGrupp?: ResponseUuringuGrupp | ResponseUuringuGrupp[];
     };
+    Tellimus?: {
+      ValisTellimuseId: string;
+    }
   };
 };
 

lib/utils.ts

@@ -18,3 +18,12 @@ export function toTitleCase(str?: string) {
       text.charAt(0).toUpperCase() + text.substring(1).toLowerCase(),
   );
 }
+
+export function sortByDate<T>(a: T[] | undefined, key: keyof T): T[] | undefined {
+  return a?.sort((a, b) => {
+    if (!a[key] || !b[key]) {
+      return 0;
+    }
+    return new Date(b[key] as string).getTime() - new Date(a[key] as string).getTime();
+  });
+}