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

feat(MED-131): update analyses sync to medusa store

Browse Source
This commit is contained in:
Karli
2025-08-04 11:52:09 +03:00
parent b665678dbb
commit ee60a78335
8 changed files with 460 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
app/api/job/handler/sync-analysis-groups.ts
View File

@@ -1,95 +1,42 @@
import { createClient as createCustomClient } from '@supabase/supabase-js';
import axios from 'axios';
import { format } from 'date-fns';
import { XMLParser } from 'fast-xml-parser';
import { IMedipostResponse_GetPublicMessageList } from './types';
function getLatestMessage(messages: IMedipostResponse_GetPublicMessageList['messages']): IMedipostResponse_GetPublicMessageList['messages'][number] | null {
if (!messages?.length) {
return null;
}
return messages.reduce((prev, current) =>
Number(prev.messageId) > Number(current.messageId) ? prev : current,
);
}
import fs from 'fs';
import { createAnalysisGroup } from '~/lib/services/analysis-group.service';
import { IMedipostPublicMessageDataParsed } from '~/lib/services/medipost.types';
import { createAnalysis, createNoDataReceivedEntry, createNoNewDataReceivedEntry, createSyncFailEntry, createSyncSuccessEntry } from '~/lib/services/analyses.service';
import { getLastCheckedDate } from '~/lib/services/sync-entries.service';
import { createAnalysisElement } from '~/lib/services/analysis-element.service';
import { createCodes } from '~/lib/services/codes.service';
import { getLatestPublicMessageListItem } from '~/lib/services/medipost.service';
import type { ICode } from '~/lib/types/code';
function toArray<T>(input?: T | T[] | null): T[] {
if (!input) return [];
return Array.isArray(input) ? input : [input];
}
const WRITE_XML_TO_FILE = false as boolean;
export default async function syncAnalysisGroups() {
const baseUrl = process.env.MEDIPOST_URL;
const user = process.env.MEDIPOST_USER;
const password = process.env.MEDIPOST_PASSWORD;
const sender = process.env.MEDIPOST_MESSAGE_SENDER;
const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
const supabaseServiceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
if (
!baseUrl ||
!supabaseUrl ||
!supabaseServiceRoleKey ||
!user ||
!password ||
!sender
) {
if (!baseUrl || !user || !password || !sender) {
throw new Error('Could not access all necessary environment variables');
}
const supabase = createCustomClient(supabaseUrl, supabaseServiceRoleKey, {
auth: {
persistSession: false,
autoRefreshToken: false,
detectSessionInUrl: false,
},
});
try {
console.info('Getting latest public message id');
const { data: lastChecked } = await supabase
.schema('audit')
.from('sync_entries')
.select('created_at')
.eq('status', 'SUCCESS')
.order('created_at')
.limit(1);
const lastEntry = lastChecked?.[0];
const lastCheckedDate = lastEntry
? format(lastEntry.created_at, 'yyyy-MM-dd HH:mm:ss')
: null;
const lastCheckedDate = await getLastCheckedDate();
console.info('Getting public message list');
const { data, status } = await axios.get<IMedipostResponse_GetPublicMessageList>(baseUrl, {
params: {
Action: 'GetPublicMessageList',
User: user,
Password: password,
//Sender: sender,
// ...(lastCheckedDate && { LastChecked: lastCheckedDate }),
MessageType: 'Teenus',
},
});
if (!data || status !== 200 || data.code !== 0) {
console.error("Failed to get public message list, status: ", status, data);
throw new Error('Failed to get public message list');
}
if (!data.messages?.length) {
const latestMessage = await getLatestPublicMessageListItem();
if (!latestMessage) {
console.info('No new data received');
return supabase.schema('audit').from('sync_entries').insert({
operation: 'ANALYSES_SYNC',
comment: 'No new data received',
status: 'SUCCESS',
changed_by_role: 'service_role',
});
await createNoNewDataReceivedEntry();
return;
}
// GET PUBLIC MESSAGE WITH GIVEN ID
const latestMessage = getLatestMessage(data?.messages)!;
console.info('Getting public message with id: ', latestMessage.messageId);
const { data: publicMessageData } = await axios.get(baseUrl, {
@@ -104,8 +51,12 @@ export default async function syncAnalysisGroups() {
},
});
if (WRITE_XML_TO_FILE) {
fs.writeFileSync('public-messages-list-response.xml', publicMessageData);
}
const parser = new XMLParser({ ignoreAttributes: false });
const parsed = parser.parse(publicMessageData);
const parsed: IMedipostPublicMessageDataParsed = parser.parse(publicMessageData);
if (parsed.ANSWER?.CODE && parsed.ANSWER?.CODE !== 0) {
throw new Error(
@@ -121,36 +72,19 @@ export default async function syncAnalysisGroups() {
);
if (!parsed || !analysisGroups.length) {
return supabase.schema('audit').from('sync_entries').insert({
operation: 'ANALYSES_SYNC',
comment: 'No data received',
status: 'FAIL',
changed_by_role: 'service_role',
});
console.info('No analysis groups data received');
await createNoDataReceivedEntry();
return;
}
const codes: any[] = [];
const codes: ICode[] = [];
for (const analysisGroup of analysisGroups) {
// SAVE ANALYSIS GROUP
const { data: insertedAnalysisGroup, error } = await supabase
.schema('medreport')
.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 analysisGroupId = await createAnalysisGroup({
id: analysisGroup.UuringuGruppId,
name: analysisGroup.UuringuGruppNimi,
order: analysisGroup.UuringuGruppJarjekord,
});
const analysisGroupCodes = toArray(analysisGroup.Kood);
codes.push(
@@ -170,31 +104,11 @@ export default async function syncAnalysisGroups() {
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;
const insertedAnalysisElementId = await createAnalysisElement({
analysisElement,
analysisGroupId,
materialGroups: toArray(item.MaterjalideGrupp),
});
if (analysisElement.Kood) {
const analysisElementCodes = toArray(analysisElement.Kood);
@@ -214,30 +128,8 @@ export default async function syncAnalysisGroups() {
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');
const insertedAnalysisId = await createAnalysis(analysis, analysisGroupId);
if (error || !insertedAnalysis[0]?.id) {
throw new Error(
`Failed to insert analysis (id: ${analysis.UuringId}) error: ${error?.message}`,
);
}
const insertedAnalysisId = insertedAnalysis[0].id;
if (analysis.Kood) {
const analysisCodes = toArray(analysis.Kood);
@@ -259,24 +151,12 @@ export default async function syncAnalysisGroups() {
}
console.info('Inserting codes');
await supabase.schema('medreport').from('codes').upsert(codes);
await createCodes(codes);
console.info('Inserting sync entry');
await supabase.schema('audit').from('sync_entries').insert({
operation: 'ANALYSES_SYNC',
status: 'SUCCESS',
changed_by_role: 'service_role',
});
await createSyncSuccessEntry();
} catch (e) {
await supabase
.schema('audit')
.from('sync_entries')
.insert({
operation: 'ANALYSES_SYNC',
status: 'FAIL',
comment: JSON.stringify(e),
changed_by_role: 'service_role',
});
await createSyncFailEntry(JSON.stringify(e));
console.error(e);
throw new Error(
`Failed to sync public message data, error: ${JSON.stringify(e)}`,