k4rli/medreport_mrb2b
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: k4rli:269b4c3e27a04f5d6194944de0cf9e7217fc445b
Branches Tags
k4rli:main k4rli:develop k4rli:testing-1111 k4rli:MED-97 k4rli:keycloak-updates-v2 k4rli:keycloak2 k4rli:keycloak k4rli:feature/MED-100 k4rli:MED-122-v2 k4rli:MED-122
...
compare: k4rli:5ef7f58f5d803cbe149915fb18c99ac7bef9e2f1
Branches Tags
k4rli:develop k4rli:testing-1111 k4rli:MED-97 k4rli:keycloak-updates-v2 k4rli:keycloak2 k4rli:keycloak k4rli:feature/MED-100 k4rli:MED-122-v2 k4rli:MED-122 k4rli:main

3 Commits
269b4c3e27 ... 5ef7f58f5d

Author SHA1 Message Date
Karli
5ef7f58f5d Fix "ups" error for 1sec after logout 2025-11-12 08:53:21 +02:00
Karli
2cb6a0343a Make it clearer which date is shown inside tooltip 2025-11-12 08:53:05 +02:00
Karli
8f32fdf08d Move medipostPrivateMessage.service to separate classes, improve logging 2025-11-12 08:51:48 +02:00
20 changed files with 723 additions and 396 deletions
Expand all files Collapse all files

27
app/api/job/handler/sync-analysis-results.ts
View File

@@ -1,7 +1,4 @@
import { createUserAnalysesApi } from '@/packages/features/user-analyses/src/server/api'; import MedipostPrivateMessageSync from '~/lib/services/medipost/medipostPrivateMessageSync.service';
import { getSupabaseServerAdminClient } from '@/packages/supabase/src/clients/server-admin-client';
import { readPrivateMessageResponse } from '~/lib/services/medipost/medipostPrivateMessage.service';
type ProcessedMessage = { type ProcessedMessage = {
messageId: string; messageId: string;
@@ -19,30 +16,22 @@ type GroupedResults = {
export default async function syncAnalysisResults() { export default async function syncAnalysisResults() {
console.info('Syncing analysis results'); console.info('Syncing analysis results');
const supabase = getSupabaseServerAdminClient(); const sync = new MedipostPrivateMessageSync();
const api = createUserAnalysesApi(supabase);
const processedMessages: ProcessedMessage[] = []; const processedMessages: ProcessedMessage[] = [];
const excludedMessageIds: string[] = []; const excludedMessageIds: string[] = [];
while (true) { while (true) {
const result = await readPrivateMessageResponse({ excludedMessageIds }); const result = await sync.handleNextPrivateMessage({ excludedMessageIds });
if (result.messageId) {
processedMessages.push(result as ProcessedMessage);
}
await api.sendAnalysisResultsNotification({ const { messageId } = result;
hasFullAnalysisResponse: result.hasFullAnalysisResponse, if (!messageId) {
hasPartialAnalysisResponse: result.hasAnalysisResponse,
analysisOrderId: result.analysisOrderId,
});
if (!result.messageId) {
console.info('No more messages to process'); console.info('No more messages to process');
break; break;
} }
if (!excludedMessageIds.includes(result.messageId)) { processedMessages.push(result as ProcessedMessage);
excludedMessageIds.push(result.messageId); if (!excludedMessageIds.includes(messageId)) {
excludedMessageIds.push(messageId);
} else { } else {
break; break;
} }

1
app/api/order/medipost-test-response/route.ts
View File

@@ -54,6 +54,7 @@ export async function POST(request: Request) {
action: 'send_fake_analysis_results_to_medipost', action: 'send_fake_analysis_results_to_medipost',
xml: messageXml, xml: messageXml,
medusaOrderId, medusaOrderId,
medipostPrivateMessageId: `fake-response-${Date.now()}`,
}); });
await sendPrivateMessageTestResponse({ messageXml }); await sendPrivateMessageTestResponse({ messageXml });
} catch (error) { } catch (error) {

17
app/error.tsx
View File

@@ -1,5 +1,6 @@
'use client'; 'use client';
import { useEffect } from 'react';
import Link from 'next/link'; import Link from 'next/link';
import { ArrowLeft, MessageCircle } from 'lucide-react'; import { ArrowLeft, MessageCircle } from 'lucide-react';
@@ -20,6 +21,22 @@ const ErrorPage = ({
}) => { }) => {
useCaptureException(error); useCaptureException(error);
// Ignore next.js internal transient navigation errors that occur during auth state changes
const isTransientNavigationError =
error?.message?.includes('Error in input stream') ||
error?.message?.includes('AbortError') ||
(error?.name === 'ChunkLoadError');
useEffect(() => {
if (isTransientNavigationError && typeof window !== 'undefined') {
window.location.href = '/';
}
}, [isTransientNavigationError]);
if (isTransientNavigationError) {
return <div />;
}
return ( return (
<div className={'flex h-screen flex-1 flex-col'}> <div className={'flex h-screen flex-1 flex-col'}>
<SiteHeader /> <SiteHeader />

17
app/global-error.tsx
View File

@@ -1,5 +1,6 @@
'use client'; 'use client';
import { useEffect } from 'react';
import Link from 'next/link'; import Link from 'next/link';
import { ArrowLeft, MessageCircle } from 'lucide-react'; import { ArrowLeft, MessageCircle } from 'lucide-react';
@@ -21,6 +22,22 @@ const GlobalErrorPage = ({
}) => { }) => {
useCaptureException(error); useCaptureException(error);
// Ignore next.js internal transient navigation errors that occur during auth state changes
const isTransientNavigationError =
error?.message?.includes('Error in input stream') ||
error?.message?.includes('AbortError') ||
(error?.name === 'ChunkLoadError');
useEffect(() => {
if (isTransientNavigationError && typeof window !== 'undefined') {
window.location.href = '/';
}
}, [isTransientNavigationError]);
if (isTransientNavigationError) {
return <div />;
}
return ( return (
<html> <html>
<body> <body>

10
app/home/(user)/(dashboard)/analysis-results/[id]/page.tsx
View File

@@ -11,6 +11,7 @@ import { pathsConfig } from '@kit/shared/config';
import { Button } from '@kit/ui/button'; import { Button } from '@kit/ui/button';
import { PageBody, PageHeader } from '@kit/ui/page'; import { PageBody, PageHeader } from '@kit/ui/page';
import { Trans } from '@kit/ui/trans'; import { Trans } from '@kit/ui/trans';
import { formatDateAndTime } from '@kit/shared/utils';
import { loadCurrentUserAccount } from '~/home/(user)/_lib/server/load-user-account'; import { loadCurrentUserAccount } from '~/home/(user)/_lib/server/load-user-account';
import { loadUserAnalysis } from '~/home/(user)/_lib/server/load-user-analysis'; import { loadUserAnalysis } from '~/home/(user)/_lib/server/load-user-analysis';
@@ -103,7 +104,14 @@ export default async function AnalysisResultsPage({
<h6> <h6>
<Trans i18nKey={`orders:status.${analysisResponse.order.status}`} /> <Trans i18nKey={`orders:status.${analysisResponse.order.status}`} />
<ButtonTooltip <ButtonTooltip
content={`${analysisResponse.order.createdAt ? new Date(analysisResponse?.order?.createdAt).toLocaleString() : ''}`} content={
<Trans
i18nKey="analysis-results:orderCreatedAt"
values={{
createdAt: formatDateAndTime(analysisResponse.order.createdAt)
}}
/>
}
className="ml-6" className="ml-6"
/> />
</h6> </h6>

142
lib/services/medipost/medipostAnalysisResult.service.ts Normal file
View File

@@ -0,0 +1,142 @@
import type { PostgrestError } from "@supabase/supabase-js";
import { toArray } from '@kit/shared/utils';
import type { AnalysisOrder } from "~/lib/types/order";
import type { AnalysisResponseElement } from '~/lib/types/analysis-response-element';
import { AnalysisOrderStatus } from '@/packages/shared/src/types/medipost-analysis';
import type {
MedipostAnalysisResult,
ResponseUuringuGrupp,
} from '@/packages/shared/src/types/medipost-analysis';
import { getAnalysisResponseElementsForGroup } from "./medipostPrivateMessage.service";
import {
getExistingAnalysisResponseElements,
upsertAnalysisResponse,
upsertAnalysisResponseElement,
} from "../analysis-order.service";
import type { Logger } from './types';
type AnalysisResponseElementMapped = Omit<
AnalysisResponseElement,
'created_at' | 'updated_at' | 'id' | 'analysis_response_id'
>;
export type SyncResult =
| {
isCompleted: boolean;
isPartial?: undefined;
}
| {
isPartial: boolean;
isCompleted?: undefined;
};
export default class MedipostAnalysisResultService {
public async storeAnalysisResult({
messageResponse: {
TellimuseNumber: orderNumber,
TellimuseOlek,
UuringuGrupp,
},
analysisOrder,
log,
}: {
messageResponse: Pick<
NonNullable<MedipostAnalysisResult>,
'TellimuseNumber' | 'TellimuseOlek' | 'UuringuGrupp'
>;
analysisOrder: AnalysisOrder;
log: Logger;
}): Promise<SyncResult> {
const orderStatus = AnalysisOrderStatus[TellimuseOlek];
const { analysisResponseId } = await upsertAnalysisResponse({
analysisOrderId: analysisOrder.id,
orderNumber,
orderStatus,
userId: analysisOrder.user_id,
});
const existingElements = await getExistingAnalysisResponseElements({
analysisResponseId,
});
const analysisGroups = toArray(UuringuGrupp);
log(`Order has results for ${analysisGroups.length} analysis groups`);
const newElements = await this.getNewAnalysisResponseElements({
analysisGroups,
existingElements,
log,
});
for (const element of newElements) {
try {
await upsertAnalysisResponseElement({
element: {
...element,
analysis_response_id: analysisResponseId,
},
});
} catch (e) {
log(
`Failed to create order response element for response id ${analysisResponseId}, element id '${element.analysis_element_original_id}'`,
"error",
e as PostgrestError,
);
}
}
const hasAllResults = await this.hasAllAnalysisResponseElements({
analysisResponseId,
analysisOrder,
});
log(`Order has ${hasAllResults ? 'all' : 'some'} results, status is ${orderStatus}`);
return hasAllResults
? { isCompleted: orderStatus === 'COMPLETED' }
: { isPartial: true };
}
private async getNewAnalysisResponseElements({
analysisGroups,
existingElements,
log,
}: {
analysisGroups: ResponseUuringuGrupp[];
existingElements: AnalysisResponseElement[];
log: Logger;
}): Promise<AnalysisResponseElementMapped[]> {
const newElements: AnalysisResponseElementMapped[] = [];
for (const analysisGroup of analysisGroups) {
log(
`[${analysisGroups.indexOf(analysisGroup) + 1}/${analysisGroups.length}] Syncing analysis group '${analysisGroup.UuringuGruppNimi}'`,
);
const elements = await getAnalysisResponseElementsForGroup({
analysisGroup,
existingElements,
log,
});
newElements.push(...elements);
}
return newElements;
}
private async hasAllAnalysisResponseElements({
analysisResponseId,
analysisOrder,
}: {
analysisResponseId: number;
analysisOrder: Pick<AnalysisOrder, 'analysis_element_ids'>;
}): Promise<boolean> {
const allOrderResponseElements = await getExistingAnalysisResponseElements({
analysisResponseId,
});
const expectedOrderResponseElements = analysisOrder.analysis_element_ids?.length ?? 0;
return allOrderResponseElements.length >= expectedOrderResponseElements;
}
}

83
lib/services/medipost/medipostMessageBase.service.ts
View File

@@ -29,6 +29,19 @@ export async function getLatestMessage({
); );
} }
export async function getMedipostActionLog({
medipostPrivateMessageId,
}: {
medipostPrivateMessageId: string;
}) {
const { data: existingRecord } = await getSupabaseServerAdminClient()
.schema('medreport').from('medipost_actions')
.select('id')
.eq('medipost_private_message_id', medipostPrivateMessageId)
.single();
return existingRecord;
}
export async function upsertMedipostActionLog({ export async function upsertMedipostActionLog({
action, action,
xml, xml,
@@ -51,6 +64,10 @@ export async function upsertMedipostActionLog({
medipostExternalOrderId?: string | null; medipostExternalOrderId?: string | null;
medipostPrivateMessageId?: string | null; medipostPrivateMessageId?: string | null;
}) { }) {
if (typeof medipostPrivateMessageId !== 'string') {
throw new Error('medipostPrivateMessageId is required');
}
const recordData = { const recordData = {
action, action,
xml, xml,
@@ -62,18 +79,19 @@ export async function upsertMedipostActionLog({
medipost_private_message_id: medipostPrivateMessageId, medipost_private_message_id: medipostPrivateMessageId,
}; };
const query = getSupabaseServerAdminClient() const existingActionLog = await getMedipostActionLog({ medipostPrivateMessageId });
if (existingActionLog) {
console.info(`Medipost action log already exists for private message id: ${medipostPrivateMessageId}`);
return { medipostActionId: existingActionLog.id };
}
console.info(`Inserting medipost action log for private message id: ${medipostPrivateMessageId}`);
const { data } = await getSupabaseServerAdminClient()
.schema('medreport') .schema('medreport')
.from('medipost_actions'); .from('medipost_actions')
const { data } = medipostPrivateMessageId .insert(recordData)
? await query .select('id')
.upsert(recordData, { .throwOnError();
onConflict: 'medipost_private_message_id',
ignoreDuplicates: false,
})
.select('id')
.throwOnError()
: await query.insert(recordData).select('id').throwOnError();
const medipostActionId = data?.[0]?.id; const medipostActionId = data?.[0]?.id;
if (!medipostActionId) { if (!medipostActionId) {
@@ -84,3 +102,46 @@ export async function upsertMedipostActionLog({
return { medipostActionId }; return { medipostActionId };
} }
export async function createMedipostActionLogForError({
privateMessageXml,
medipostPrivateMessageId,
medusaOrderId,
medipostExternalOrderId,
}: {
privateMessageXml: string;
medipostPrivateMessageId: string;
medusaOrderId?: string;
medipostExternalOrderId: string;
}) {
await upsertMedipostActionLog({
action: 'sync_analysis_results_from_medipost',
xml: privateMessageXml,
hasAnalysisResults: false,
medipostPrivateMessageId,
medusaOrderId,
medipostExternalOrderId,
hasError: true,
});
}
export async function createMedipostActionLogForSuccess({
privateMessageXml,
medipostPrivateMessageId,
medusaOrderId,
medipostExternalOrderId,
}: {
privateMessageXml: string;
medipostPrivateMessageId: string;
medusaOrderId: string;
medipostExternalOrderId: string;
}) {
await upsertMedipostActionLog({
action: 'sync_analysis_results_from_medipost',
xml: privateMessageXml,
hasAnalysisResults: true,
medipostPrivateMessageId: medipostPrivateMessageId,
medusaOrderId,
medipostExternalOrderId,
});
}

87
lib/services/medipost/medipostMessageClient.service.ts Normal file
View File

@@ -0,0 +1,87 @@
import axios from 'axios';
import type { GetMessageListResponse } from '~/lib/types/medipost';
import { MedipostAction } from '~/lib/types/medipost';
import type { MedipostOrderResponse } from '@/packages/shared/src/types/medipost-analysis';
import { validateMedipostResponse } from './medipostValidate.service';
import { parseXML } from '../util/xml.service';
import { getLatestMessage } from './medipostMessageBase.service';
const BASE_URL = process.env.MEDIPOST_URL!;
const USER = process.env.MEDIPOST_USER!;
const PASSWORD = process.env.MEDIPOST_PASSWORD!;
const IS_ENABLED_DELETE_PRIVATE_MESSAGE =
process.env.MEDIPOST_ENABLE_DELETE_RESPONSE_PRIVATE_MESSAGE_ON_READ ===
'true';
export default class MedipostMessageClient {
public async getLatestPrivateMessageListItem({
excludedMessageIds,
}: {
excludedMessageIds: string[];
}) {
const { data } = await axios.get<GetMessageListResponse>(BASE_URL, {
params: {
Action: MedipostAction.GetPrivateMessageList,
User: USER,
Password: PASSWORD,
},
});
if (data.code && data.code !== 0) {
throw new Error('Failed to get private message list');
}
return await getLatestMessage({
messages: data?.messages,
excludedMessageIds,
});
}
public async getPrivateMessage(messageId: string) {
const { data } = await axios.get(BASE_URL, {
params: {
Action: MedipostAction.GetPrivateMessage,
User: USER,
Password: PASSWORD,
MessageId: messageId,
},
headers: {
Accept: 'application/xml',
},
});
await validateMedipostResponse(data, { canHaveEmptyCode: true });
return {
message: (await parseXML(data)) as MedipostOrderResponse,
xml: data as string,
};
}
public async deletePrivateMessage({
medipostPrivateMessageId,
}: {
medipostPrivateMessageId: string;
}) {
if (!IS_ENABLED_DELETE_PRIVATE_MESSAGE) {
console.info(`Skipping delete private message id=${medipostPrivateMessageId} because deleting is not enabled`);
return;
}
const { data } = await axios.get(BASE_URL, {
params: {
Action: MedipostAction.DeletePrivateMessage,
User: USER,
Password: PASSWORD,
MessageId: medipostPrivateMessageId,
},
});
if (data.code && data.code !== 0) {
throw new Error(`Failed to delete private message (id: ${medipostPrivateMessageId})`);
}
}
}

106
lib/services/medipost/medipostMessageParser.service.ts Normal file
View File

@@ -0,0 +1,106 @@
import type { MedipostOrderResponse, MedipostAnalysisResult } from '@/packages/shared/src/types/medipost-analysis';
interface ParsedMessageData {
analysisResult: NonNullable<MedipostAnalysisResult>;
orderNumber: string;
medipostExternalOrderId: number;
medipostExternalOrderIdRaw: string | number;
patientPersonalCode: string;
}
type ParseMessageResult =
| {
success: true;
data: ParsedMessageData;
}
| {
success: false;
reason: 'no_analysis_result' | 'invalid_order_id' | 'invalid_patient_code';
medipostExternalOrderIdRaw?: string | number;
medipostExternalOrderId?: number;
};
export default class MedipostMessageParser {
public extractAnalysisResult(
message: MedipostOrderResponse,
): ParsedMessageData['analysisResult'] | null {
return message?.Saadetis?.Vastus ?? null;
}
public extractOrderId(
message: MedipostOrderResponse,
analysisResult: ParsedMessageData['analysisResult'],
): { orderId: number; rawOrderId: string | number } | null {
const rawOrderId =
message.Saadetis?.Tellimus?.ValisTellimuseId ||
analysisResult.ValisTellimuseId;
if (!rawOrderId) {
return null;
}
const orderId = Number(rawOrderId);
if (isNaN(orderId)) {
return null;
}
return { orderId, rawOrderId };
}
public extractOrderNumber(
analysisResult: ParsedMessageData['analysisResult'],
): string {
return analysisResult.TellimuseNumber;
}
public extractPatientPersonalCode(
analysisResult: ParsedMessageData['analysisResult'],
): string | null {
return analysisResult.Patsient.Isikukood?.toString() ?? null;
}
public parseMessage(message: MedipostOrderResponse): ParseMessageResult {
const analysisResult = this.extractAnalysisResult(message);
if (!analysisResult) {
return {
success: false,
reason: 'no_analysis_result',
};
}
const orderIdResult = this.extractOrderId(message, analysisResult);
if (!orderIdResult) {
return {
success: false,
reason: 'invalid_order_id',
medipostExternalOrderIdRaw:
message.Saadetis?.Tellimus?.ValisTellimuseId ||
analysisResult.ValisTellimuseId,
};
}
const patientPersonalCode = this.extractPatientPersonalCode(analysisResult);
if (!patientPersonalCode) {
return {
success: false,
reason: 'invalid_patient_code',
medipostExternalOrderIdRaw: orderIdResult.rawOrderId,
medipostExternalOrderId: orderIdResult.orderId,
};
}
const orderNumber = this.extractOrderNumber(analysisResult);
return {
success: true,
data: {
analysisResult,
orderNumber,
medipostExternalOrderId: orderIdResult.orderId,
medipostExternalOrderIdRaw: orderIdResult.rawOrderId,
patientPersonalCode,
},
};
}
}

364
lib/services/medipost/medipostPrivateMessage.service.ts
View File

@@ -1,12 +1,8 @@
'use server'; 'use server';
import type { PostgrestError } from '@supabase/supabase-js'; import { MedipostAction } from '@/lib/types/medipost';
import { GetMessageListResponse, MedipostAction } from '@/lib/types/medipost';
import { createUserAnalysesApi } from '@/packages/features/user-analyses/src/server/api'; import { createUserAnalysesApi } from '@/packages/features/user-analyses/src/server/api';
import { AnalysisOrderStatus } from '@/packages/shared/src/types/medipost-analysis';
import type { import type {
MedipostOrderResponse,
ResponseUuringuGrupp, ResponseUuringuGrupp,
UuringElement, UuringElement,
} from '@/packages/shared/src/types/medipost-analysis'; } from '@/packages/shared/src/types/medipost-analysis';
@@ -14,77 +10,27 @@ import { getSupabaseServerAdminClient } from '@/packages/supabase/src/clients/se
import axios from 'axios'; import axios from 'axios';
import { toArray } from '@kit/shared/utils'; import { toArray } from '@kit/shared/utils';
import { Tables } from '@kit/supabase/database';
import type { AnalysisResponseElement } from '~/lib/types/analysis-response-element'; import type { AnalysisResponseElement } from '~/lib/types/analysis-response-element';
import type { AnalysisOrder } from '~/lib/types/order';
import { getAccountAdmin } from '../account.service'; import { getAccountAdmin } from '../account.service';
import { getAnalyses } from '../analyses.service'; import { getAnalyses } from '../analyses.service';
import { getAnalysisElementsAdmin } from '../analysis-element.service'; import { getAnalysisElementsAdmin } from '../analysis-element.service';
import {
getExistingAnalysisResponseElements,
upsertAnalysisResponse,
upsertAnalysisResponseElement,
} from '../analysis-order.service';
import { logMedipostDispatch } from '../audit.service'; import { logMedipostDispatch } from '../audit.service';
import { getAnalysisOrder } from '../order.service'; import { getAnalysisOrder } from '../order.service';
import { parseXML } from '../util/xml.service';
import { MedipostValidationError } from './MedipostValidationError'; import { MedipostValidationError } from './MedipostValidationError';
import { import {
getLatestMessage,
upsertMedipostActionLog, upsertMedipostActionLog,
} from './medipostMessageBase.service'; } from './medipostMessageBase.service';
import { validateMedipostResponse } from './medipostValidate.service'; import { validateMedipostResponse } from './medipostValidate.service';
import { OrderedAnalysisElement, composeOrderXML } from './medipostXML.service'; import { OrderedAnalysisElement, composeOrderXML } from './medipostXML.service';
import type { Logger } from './types';
const BASE_URL = process.env.MEDIPOST_URL!; const BASE_URL = process.env.MEDIPOST_URL!;
const USER = process.env.MEDIPOST_USER!; const USER = process.env.MEDIPOST_USER!;
const PASSWORD = process.env.MEDIPOST_PASSWORD!; const PASSWORD = process.env.MEDIPOST_PASSWORD!;
const RECIPIENT = process.env.MEDIPOST_RECIPIENT!; const RECIPIENT = process.env.MEDIPOST_RECIPIENT!;
const IS_ENABLED_DELETE_PRIVATE_MESSAGE =
process.env.MEDIPOST_ENABLE_DELETE_RESPONSE_PRIVATE_MESSAGE_ON_READ ===
'true';
export async function getLatestPrivateMessageListItem({
excludedMessageIds,
}: {
excludedMessageIds: string[];
}) {
const { data } = await axios.get<GetMessageListResponse>(BASE_URL, {
params: {
Action: MedipostAction.GetPrivateMessageList,
User: USER,
Password: PASSWORD,
},
});
if (data.code && data.code !== 0) {
throw new Error('Failed to get private message list');
}
return await getLatestMessage({
messages: data?.messages,
excludedMessageIds,
});
}
const logger =
(
analysisOrder: AnalysisOrder,
externalId: string,
analysisResponseId: string,
) =>
(message: string, error?: PostgrestError | null) => {
const messageFormatted = `[${analysisOrder.id}] [${externalId}] [${analysisResponseId}] ${message}`;
if (error) {
console.info(messageFormatted, error);
} else {
console.info(messageFormatted);
}
};
export async function canCreateAnalysisResponseElement({ export async function canCreateAnalysisResponseElement({
existingElements, existingElements,
groupUuring: { groupUuring: {
@@ -101,7 +47,7 @@ export async function canCreateAnalysisResponseElement({
UuringuElement: Pick<UuringElement, 'UuringOlek' | 'UuringId'>; UuringuElement: Pick<UuringElement, 'UuringOlek' | 'UuringId'>;
}; };
responseValue: number | null; responseValue: number | null;
log: ReturnType<typeof logger>; log: Logger;
}) { }) {
const existingAnalysisResponseElement = existingElements.find( const existingAnalysisResponseElement = existingElements.find(
({ analysis_element_original_id }) => ({ analysis_element_original_id }) =>
@@ -138,7 +84,7 @@ export async function getAnalysisResponseElementsForGroup({
AnalysisResponseElement, AnalysisResponseElement,
'analysis_element_original_id' | 'status' | 'response_value' 'analysis_element_original_id' | 'status' | 'response_value'
>[]; >[];
log: ReturnType<typeof logger>; log: Logger;
}) { }) {
const groupUuringItems = toArray( const groupUuringItems = toArray(
analysisGroup.Uuring as ResponseUuringuGrupp['Uuring'], analysisGroup.Uuring as ResponseUuringuGrupp['Uuring'],
@@ -211,284 +157,6 @@ export async function getAnalysisResponseElementsForGroup({
return results; return results;
} }
async function getNewAnalysisResponseElements({
analysisGroups,
existingElements,
log,
}: {
analysisGroups: ResponseUuringuGrupp[];
existingElements: AnalysisResponseElement[];
log: ReturnType<typeof logger>;
}) {
const newElements: Omit<
AnalysisResponseElement,
'created_at' | 'updated_at' | 'id' | 'analysis_response_id'
>[] = [];
for (const analysisGroup of analysisGroups) {
log(
`[${analysisGroups.indexOf(analysisGroup) + 1}/${analysisGroups.length}] Syncing analysis group '${analysisGroup.UuringuGruppNimi}'`,
);
const elements = await getAnalysisResponseElementsForGroup({
analysisGroup,
existingElements,
log,
});
newElements.push(...elements);
}
return newElements;
}
async function hasAllAnalysisResponseElements({
analysisResponseId,
order,
}: {
analysisResponseId: number;
order: Pick<AnalysisOrder, 'analysis_element_ids'>;
}) {
const allOrderResponseElements = await getExistingAnalysisResponseElements({
analysisResponseId,
});
const expectedOrderResponseElements = order.analysis_element_ids?.length ?? 0;
return allOrderResponseElements.length >= expectedOrderResponseElements;
}
export async function syncPrivateMessage({
messageResponse: {
ValisTellimuseId: externalId,
TellimuseNumber: orderNumber,
TellimuseOlek,
UuringuGrupp,
},
order,
}: {
messageResponse: Pick<
NonNullable<MedipostOrderResponse['Saadetis']['Vastus']>,
'ValisTellimuseId' | 'TellimuseNumber' | 'TellimuseOlek' | 'UuringuGrupp'
>;
order: Tables<{ schema: 'medreport' }, 'analysis_orders'>;
}) {
const supabase = getSupabaseServerAdminClient();
const orderStatus = AnalysisOrderStatus[TellimuseOlek];
const log = logger(order, externalId, orderNumber);
const { data: analysisOrder } = await supabase
.schema('medreport')
.from('analysis_orders')
.select('id, user_id')
.eq('id', order.id)
.single()
.throwOnError();
const { analysisResponseId } = await upsertAnalysisResponse({
analysisOrderId: order.id,
orderNumber,
orderStatus,
userId: analysisOrder.user_id,
});
const existingElements = await getExistingAnalysisResponseElements({
analysisResponseId,
});
const analysisGroups = toArray(UuringuGrupp);
log(`Order has results for ${analysisGroups.length} analysis groups`);
const newElements = await getNewAnalysisResponseElements({
analysisGroups,
existingElements,
log,
});
for (const element of newElements) {
try {
await upsertAnalysisResponseElement({
element: {
...element,
analysis_response_id: analysisResponseId,
},
});
} catch (e) {
log(
`Failed to create order response element for response id ${analysisResponseId}, element id '${element.analysis_element_original_id}' (order id: ${order.id})`,
e as PostgrestError,
);
}
}
return (await hasAllAnalysisResponseElements({ analysisResponseId, order }))
? { isCompleted: orderStatus === 'COMPLETED' }
: { isPartial: true };
}
export async function readPrivateMessageResponse({
excludedMessageIds,
}: {
excludedMessageIds: string[];
}): Promise<{
messageId: string | null;
hasAnalysisResponse: boolean;
hasPartialAnalysisResponse: boolean;
hasFullAnalysisResponse: boolean;
medusaOrderId: string | undefined;
analysisOrderId: number | undefined;
}> {
let messageId: string | null = null;
let hasAnalysisResponse = false;
let hasPartialAnalysisResponse = false;
let hasFullAnalysisResponse = false;
let medusaOrderId: string | undefined = undefined;
let analysisOrderId: number | undefined = undefined;
try {
const privateMessage = await getLatestPrivateMessageListItem({
excludedMessageIds,
});
messageId = privateMessage?.messageId ?? null;
if (!privateMessage || !messageId) {
return {
messageId: null,
hasAnalysisResponse: false,
hasPartialAnalysisResponse: false,
hasFullAnalysisResponse: false,
medusaOrderId: undefined,
analysisOrderId: undefined,
};
}
const { messageId: privateMessageId } = privateMessage;
const { message: privateMessageContent, xml: privateMessageXml } =
await getPrivateMessage(privateMessageId);
const messageResponse = privateMessageContent?.Saadetis?.Vastus;
const medipostExternalOrderId =
privateMessageContent?.Saadetis?.Tellimus?.ValisTellimuseId ||
messageResponse?.ValisTellimuseId;
const patientPersonalCode = messageResponse?.Patsient.Isikukood?.toString();
analysisOrderId = Number(medipostExternalOrderId);
const hasInvalidOrderId = isNaN(analysisOrderId);
if (hasInvalidOrderId || !messageResponse || !patientPersonalCode) {
console.log({
privateMessageContent,
saadetis: privateMessageContent?.Saadetis,
messageResponse,
});
console.error(
`Invalid order id or message response or patient personal code, medipostExternalOrderId=${medipostExternalOrderId}, privateMessageId=${privateMessageId}, patientPersonalCode=${patientPersonalCode}`,
);
await upsertMedipostActionLog({
action: 'sync_analysis_results_from_medipost',
xml: privateMessageXml,
hasAnalysisResults: false,
medipostPrivateMessageId: privateMessageId,
medusaOrderId,
medipostExternalOrderId,
hasError: true,
});
return {
messageId,
hasAnalysisResponse: false,
hasPartialAnalysisResponse: false,
hasFullAnalysisResponse: false,
medusaOrderId: hasInvalidOrderId ? undefined : medusaOrderId,
analysisOrderId: hasInvalidOrderId ? undefined : analysisOrderId,
};
}
let analysisOrder: AnalysisOrder;
try {
analysisOrder = await getAnalysisOrder({ analysisOrderId });
medusaOrderId = analysisOrder.medusa_order_id;
} catch {
if (IS_ENABLED_DELETE_PRIVATE_MESSAGE) {
await deletePrivateMessage(privateMessageId);
}
throw new Error(
`No analysis order found for Medipost message ValisTellimuseId=${medipostExternalOrderId}`,
);
}
const orderPerson = await getAccountAdmin({
primaryOwnerUserId: analysisOrder.user_id,
});
if (orderPerson.personal_code !== patientPersonalCode) {
throw new Error(
`Order person personal code does not match Medipost message Patsient.Isikukood=${patientPersonalCode}, orderPerson.personal_code=${orderPerson.personal_code}`,
);
}
const status = await syncPrivateMessage({
messageResponse,
order: analysisOrder,
});
console.info(
`Successfully synced analysis results from Medipost message privateMessageId=${privateMessageId}`,
);
await upsertMedipostActionLog({
action: 'sync_analysis_results_from_medipost',
xml: privateMessageXml,
hasAnalysisResults: true,
medipostPrivateMessageId: privateMessageId,
medusaOrderId,
medipostExternalOrderId,
});
if (status.isPartial) {
await createUserAnalysesApi(
getSupabaseServerAdminClient(),
).updateAnalysisOrderStatus({
medusaOrderId,
orderStatus: 'PARTIAL_ANALYSIS_RESPONSE',
});
hasAnalysisResponse = true;
hasPartialAnalysisResponse = true;
} else if (status.isCompleted) {
await createUserAnalysesApi(
getSupabaseServerAdminClient(),
).updateAnalysisOrderStatus({
medusaOrderId,
orderStatus: 'FULL_ANALYSIS_RESPONSE',
});
if (IS_ENABLED_DELETE_PRIVATE_MESSAGE) {
await deletePrivateMessage(privateMessageId);
}
hasAnalysisResponse = true;
hasFullAnalysisResponse = true;
}
} catch (e) {
console.warn(
`Failed to process private message id=${messageId}, message=${(e as Error).message}`,
);
}
return {
messageId,
hasAnalysisResponse,
hasPartialAnalysisResponse,
hasFullAnalysisResponse,
medusaOrderId,
analysisOrderId,
};
}
export async function deletePrivateMessage(messageId: string) {
const { data } = await axios.get(BASE_URL, {
params: {
Action: MedipostAction.DeletePrivateMessage,
User: USER,
Password: PASSWORD,
MessageId: messageId,
},
});
if (data.code && data.code !== 0) {
throw new Error(`Failed to delete private message (id: ${messageId})`);
}
}
export async function sendPrivateMessage(messageXml: string) { export async function sendPrivateMessage(messageXml: string) {
const body = new FormData(); const body = new FormData();
body.append('Action', MedipostAction.SendPrivateMessage); body.append('Action', MedipostAction.SendPrivateMessage);
@@ -508,27 +176,6 @@ export async function sendPrivateMessage(messageXml: string) {
await validateMedipostResponse(data); await validateMedipostResponse(data);
} }
export async function getPrivateMessage(messageId: string) {
const { data } = await axios.get(BASE_URL, {
params: {
Action: MedipostAction.GetPrivateMessage,
User: USER,
Password: PASSWORD,
MessageId: messageId,
},
headers: {
Accept: 'application/xml',
},
});
await validateMedipostResponse(data, { canHaveEmptyCode: true });
return {
message: (await parseXML(data)) as MedipostOrderResponse,
xml: data as string,
};
}
export async function sendOrderToMedipost({ export async function sendOrderToMedipost({
medusaOrderId, medusaOrderId,
orderedAnalysisElements, orderedAnalysisElements,
@@ -597,6 +244,7 @@ export async function sendOrderToMedipost({
medusaOrderId, medusaOrderId,
responseXml: e.response, responseXml: e.response,
hasError: true, hasError: true,
medipostPrivateMessageId: `send-order-to-medipost-${Date.now()}`,
}); });
} else { } else {
console.error( console.error(
@@ -613,6 +261,7 @@ export async function sendOrderToMedipost({
hasAnalysisResults: false, hasAnalysisResults: false,
medusaOrderId, medusaOrderId,
hasError: true, hasError: true,
medipostPrivateMessageId: `send-order-to-medipost-${Date.now()}`,
}); });
} }
@@ -631,6 +280,7 @@ export async function sendOrderToMedipost({
xml: orderXml, xml: orderXml,
hasAnalysisResults: false, hasAnalysisResults: false,
medusaOrderId, medusaOrderId,
medipostPrivateMessageId: `send-order-to-medipost-${Date.now()}`,
}); });
await createUserAnalysesApi( await createUserAnalysesApi(
getSupabaseServerAdminClient(), getSupabaseServerAdminClient(),

223
lib/services/medipost/medipostPrivateMessageSync.service.ts Normal file
View File

@@ -0,0 +1,223 @@
import type { SupabaseClient } from "@supabase/supabase-js";
import type { Database } from '@kit/supabase/database';
import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
import type { AnalysisOrder } from "~/lib/types/order";
import { createUserAnalysesApi } from "@/packages/features/user-analyses/src/server/api";
import { getAnalysisOrder } from "../order.service";
import { createMedipostActionLogForError, createMedipostActionLogForSuccess, getMedipostActionLog } from "./medipostMessageBase.service";
import type { Logger } from './types';
import MedipostMessageClient from './medipostMessageClient.service';
import MedipostMessageParser from './medipostMessageParser.service';
import MedipostAnalysisResultService from './medipostAnalysisResult.service';
import { validateOrderPerson } from "./medipostValidate.service";
interface IPrivateMessageSyncResult {
messageId: string | null;
hasAnalysisResponse: boolean;
hasPartialAnalysisResponse: boolean;
hasFullAnalysisResponse: boolean;
medusaOrderId: string | undefined;
analysisOrderId: number | undefined;
}
const NO_RESULT: IPrivateMessageSyncResult = {
messageId: null,
hasAnalysisResponse: false,
hasPartialAnalysisResponse: false,
hasFullAnalysisResponse: false,
medusaOrderId: undefined,
analysisOrderId: undefined,
};
export default class MedipostPrivateMessageSync {
private readonly client: SupabaseClient<Database>;
private readonly userAnalysesApi: ReturnType<typeof createUserAnalysesApi>;
private readonly messageClient: MedipostMessageClient;
private readonly messageParser: MedipostMessageParser;
private readonly analysisResultService: MedipostAnalysisResultService;
private loggerContext: {
analysisOrderId?: number;
orderNumber?: string;
medipostPrivateMessageId?: string;
} = {};
constructor() {
this.client = getSupabaseServerAdminClient();
this.userAnalysesApi = createUserAnalysesApi(this.client);
this.messageClient = new MedipostMessageClient();
this.messageParser = new MedipostMessageParser();
this.analysisResultService = new MedipostAnalysisResultService();
}
public async handleNextPrivateMessage({
excludedMessageIds,
}: {
excludedMessageIds: string[];
}): Promise<IPrivateMessageSyncResult> {
let medipostPrivateMessageId: string | null = null;
let hasAnalysisResponse = false;
let hasPartialAnalysisResponse = false;
let hasFullAnalysisResponse = false;
let medusaOrderId: string | undefined = undefined;
let medipostExternalOrderId: number | undefined = undefined;
try {
const privateMessage = await this.messageClient.getLatestPrivateMessageListItem({
excludedMessageIds,
});
medipostPrivateMessageId = privateMessage?.messageId ?? null;
if (!medipostPrivateMessageId) {
return NO_RESULT;
}
this.loggerContext.medipostPrivateMessageId = medipostPrivateMessageId;
if (await getMedipostActionLog({ medipostPrivateMessageId })) {
this.logger()(`Medipost action log already exists for private message`);
return { ...NO_RESULT, messageId: medipostPrivateMessageId };
}
const { message: privateMessageContent, xml: privateMessageXml } =
await this.messageClient.getPrivateMessage(medipostPrivateMessageId);
const parseResult = this.messageParser.parseMessage(privateMessageContent);
if (!parseResult.success) {
const createErrorLog = async () => createMedipostActionLogForError({
privateMessageXml,
medipostPrivateMessageId: medipostPrivateMessageId!,
medipostExternalOrderId: parseResult.medipostExternalOrderIdRaw?.toString() ?? '',
});
switch (parseResult.reason) {
case 'no_analysis_result':
console.info(`Missing results in private message, id=${medipostPrivateMessageId}`);
break;
case 'invalid_order_id':
console.error(`Invalid order id in private message, id=${medipostPrivateMessageId}`);
await createErrorLog();
break;
case 'invalid_patient_code':
console.error(`Invalid patient personal code in private message, id=${medipostPrivateMessageId}`);
await createErrorLog();
break;
}
return {
...NO_RESULT,
messageId: medipostPrivateMessageId,
analysisOrderId: parseResult.medipostExternalOrderId,
};
}
const {
analysisResult: analysisResultResponse,
orderNumber,
medipostExternalOrderIdRaw,
patientPersonalCode,
} = parseResult.data;
this.loggerContext.orderNumber = orderNumber;
medipostExternalOrderId = parseResult.data.medipostExternalOrderId;
this.loggerContext.analysisOrderId = medipostExternalOrderId;
let analysisOrder: AnalysisOrder;
try {
this.logger()(`Getting analysis order for message`);
analysisOrder = await getAnalysisOrder({ analysisOrderId: medipostExternalOrderId });
medusaOrderId = analysisOrder.medusa_order_id;
} catch (e) {
this.logger()("Get analysis order error", "error", e as Error);
await this.messageClient.deletePrivateMessage({ medipostPrivateMessageId });
throw new Error(
`No analysis order found for Medipost message ValisTellimuseId=${medipostExternalOrderIdRaw}`,
);
}
await validateOrderPerson({ analysisOrder, patientPersonalCode });
this.logger()('Storing analysis results');
const result = await this.analysisResultService.storeAnalysisResult({
messageResponse: analysisResultResponse,
analysisOrder,
log: this.logger(),
});
this.logger()('Creating medipost action log for success');
await createMedipostActionLogForSuccess({
privateMessageXml,
medipostPrivateMessageId,
medusaOrderId,
medipostExternalOrderId: medipostExternalOrderIdRaw.toString(),
});
if (result.isPartial) {
this.logger()('Updating analysis order status to PARTIAL_ANALYSIS_RESPONSE');
await this.userAnalysesApi.updateAnalysisOrderStatus({
medusaOrderId,
orderStatus: 'PARTIAL_ANALYSIS_RESPONSE',
});
hasAnalysisResponse = true;
hasPartialAnalysisResponse = true;
} else if (result.isCompleted) {
this.logger()('Updating analysis order status to FULL_ANALYSIS_RESPONSE');
await this.userAnalysesApi.updateAnalysisOrderStatus({
medusaOrderId,
orderStatus: 'FULL_ANALYSIS_RESPONSE',
});
await this.messageClient.deletePrivateMessage({ medipostPrivateMessageId });
hasAnalysisResponse = true;
hasFullAnalysisResponse = true;
}
this.logger()('Sending analysis results notification');
await this.userAnalysesApi.sendAnalysisResultsNotification({
hasFullAnalysisResponse,
hasPartialAnalysisResponse,
analysisOrderId: medipostExternalOrderId,
});
this.logger()('Successfully synced analysis results');
} catch (e) {
console.warn(
`Failed to process private message id=${medipostPrivateMessageId}, message=${(e as Error).message}`,
);
} finally {
this.clearLoggerContext();
}
return {
messageId: medipostPrivateMessageId,
hasAnalysisResponse,
hasPartialAnalysisResponse,
hasFullAnalysisResponse,
medusaOrderId,
analysisOrderId: medipostExternalOrderId,
};
}
private logger(): Logger {
const { analysisOrderId, orderNumber, medipostPrivateMessageId } = this.loggerContext;
return (message, level = 'info', error) => {
const messageFormatted = `[${analysisOrderId ?? ''}] [${orderNumber ?? '-'}] [${medipostPrivateMessageId ?? '-'}] ${message}`;
const logFn = console[level];
if (error) {
logFn(messageFormatted, error);
} else {
logFn(messageFormatted);
}
};
}
private clearLoggerContext(): void {
this.loggerContext = {};
}
}

19
lib/services/medipost/medipostValidate.service.ts
View File

@@ -1,9 +1,11 @@
'use server'; 'use server';
import type { IMedipostResponseXMLBase } from '@/packages/shared/src/types/medipost-analysis'; import type { IMedipostResponseXMLBase } from '@/packages/shared/src/types/medipost-analysis';
import type { AnalysisOrder } from '~/lib/types/order';
import { parseXML } from '../util/xml.service'; import { parseXML } from '../util/xml.service';
import { MedipostValidationError } from './MedipostValidationError'; import { MedipostValidationError } from './MedipostValidationError';
import { getAccountAdmin } from '../account.service';
export async function validateMedipostResponse( export async function validateMedipostResponse(
response: string, response: string,
@@ -24,3 +26,20 @@ export async function validateMedipostResponse(
throw new MedipostValidationError(response); throw new MedipostValidationError(response);
} }
} }
export async function validateOrderPerson({
analysisOrder,
patientPersonalCode,
}: {
analysisOrder: AnalysisOrder;
patientPersonalCode: string;
}) {
const orderPerson = await getAccountAdmin({
primaryOwnerUserId: analysisOrder.user_id,
});
if (orderPerson.personal_code !== patientPersonalCode) {
throw new Error(
`Order person personal code does not match Medipost message Patsient.Isikukood=${patientPersonalCode}, orderPerson.personal_code=${orderPerson.personal_code}`,
);
}
}

1
lib/services/medipost/types.ts Normal file
View File

@@ -0,0 +1 @@
export type Logger = (message: string, level?: 'info' | 'error' | 'warn', error?: Error | null) => void;

6
lib/services/order.service.ts
View File

@@ -1,6 +1,5 @@
import type { StoreOrder } from '@medusajs/types'; import type { StoreOrder } from '@medusajs/types';
import type { Tables } from '@kit/supabase/database';
import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client'; import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
import { getSupabaseServerClient } from '@kit/supabase/server-client'; import { getSupabaseServerClient } from '@kit/supabase/server-client';
@@ -72,6 +71,7 @@ export async function getAnalysisOrder({
const { data: order, error } = await query.single(); const { data: order, error } = await query.single();
if (error) { if (error) {
console.error("Get analysis order error", error);
throw new Error( throw new Error(
`Failed to get order by medusaOrderId=${medusaOrderId} or analysisOrderId=${analysisOrderId}, message=${error.message}, data=${JSON.stringify(order)}`, `Failed to get order by medusaOrderId=${medusaOrderId} or analysisOrderId=${analysisOrderId}, message=${error.message}, data=${JSON.stringify(order)}`,
); );
@@ -82,7 +82,7 @@ export async function getAnalysisOrder({
export async function getAnalysisOrders({ export async function getAnalysisOrders({
orderStatus, orderStatus,
}: { }: {
orderStatus?: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status']; orderStatus?: AnalysisOrder['status'];
} = {}) { } = {}) {
const client = getSupabaseServerClient(); const client = getSupabaseServerClient();
@@ -111,7 +111,7 @@ export async function getAnalysisOrdersAdmin({
orderStatus, orderStatus,
medusaOrderId, medusaOrderId,
}: { }: {
orderStatus?: Tables<{ schema: 'medreport' }, 'analysis_orders'>['status']; orderStatus?: AnalysisOrder['status'];
medusaOrderId?: string | null; medusaOrderId?: string | null;
} = {}) { } = {}) {
const query = getSupabaseServerAdminClient() const query = getSupabaseServerAdminClient()

2
packages/shared/src/components/ui/button-tooltip.tsx
View File

@@ -12,7 +12,7 @@ export function ButtonTooltip({
content, content,
className, className,
}: { }: {
content?: string; content?: string | React.ReactNode;
className?: string; className?: string;
}) { }) {
if (!content) return null; if (!content) return null;

1
packages/shared/src/types/medipost-analysis.ts
View File

@@ -130,3 +130,4 @@ export type MedipostOrderResponse = IMedipostResponseXMLBase & {
}; };
}; };
}; };
export type MedipostAnalysisResult = MedipostOrderResponse['Saadetis']['Vastus'];

4
packages/supabase/src/hooks/use-auth-change-listener.ts
View File

@@ -65,7 +65,9 @@ export function useAuthChangeListener({
return; return;
} }
window.location.reload(); // Redirect to home instead of reloading to avoid state mismatch errors
// during the transition
window.location.assign('/');
} }
}); });

3
public/locales/en/analysis-results.json
View File

@@ -24,5 +24,6 @@
"view": "View results", "view": "View results",
"notification": { "notification": {
"body": "You have new analysis results" "body": "You have new analysis results"
} },
"orderCreatedAt": "Order created at: {{createdAt}}"
} }

3
public/locales/et/analysis-results.json
View File

@@ -24,5 +24,6 @@
"view": "Vaata tulemusi", "view": "Vaata tulemusi",
"notification": { "notification": {
"body": "Teil on valmis uued analüüsi tulemused" "body": "Teil on valmis uued analüüsi tulemused"
} },
"orderCreatedAt": "Tellimus loodud: {{createdAt}}"
} }

3
public/locales/ru/analysis-results.json
View File

@@ -23,5 +23,6 @@
"orderTitle": "Заказ {{orderNumber}}", "orderTitle": "Заказ {{orderNumber}}",
"notification": { "notification": {
"body": "Teil on valmis uued analüüsi tulemused" "body": "Teil on valmis uued analüüsi tulemused"
} },
"orderCreatedAt": "Заказ создан: {{createdAt}}"
} }