344 lines
12 KiB
TypeScript
344 lines
12 KiB
TypeScript
import { SupabaseClient } from '@supabase/supabase-js';
|
|
|
|
import { Database } from '@kit/supabase/database';
|
|
import type { UuringElement, UuringuVastus } from '@kit/shared/types/medipost-analysis';
|
|
|
|
import type { AnalysisResultDetails, AnalysisResultDetailsMapped, UserAnalysis } from '../types/analysis-results';
|
|
import type { AnalysisOrder } from '../types/analysis-orders';
|
|
|
|
/**
|
|
* Class representing an API for interacting with user accounts.
|
|
* @constructor
|
|
* @param {SupabaseClient<Database>} client - The Supabase client instance.
|
|
*/
|
|
class UserAnalysesApi {
|
|
constructor(private readonly client: SupabaseClient<Database>) { }
|
|
|
|
async getAnalysisOrder({
|
|
medusaOrderId,
|
|
analysisOrderId,
|
|
}: {
|
|
medusaOrderId?: string;
|
|
analysisOrderId?: number;
|
|
}) {
|
|
const query = this.client
|
|
.schema('medreport')
|
|
.from('analysis_orders')
|
|
.select('*')
|
|
if (medusaOrderId) {
|
|
query.eq('medusa_order_id', medusaOrderId);
|
|
} else if (analysisOrderId) {
|
|
query.eq('id', analysisOrderId);
|
|
} else {
|
|
throw new Error('Either medusaOrderId or orderId must be provided');
|
|
}
|
|
|
|
const { data: order, error } = await query.single();
|
|
if (error) {
|
|
throw new Error(`Failed to get order by medusaOrderId=${medusaOrderId} or analysisOrderId=${analysisOrderId}, message=${error.message}, data=${JSON.stringify(order)}`);
|
|
}
|
|
return order as AnalysisOrder;
|
|
}
|
|
|
|
async getUserAnalysis(
|
|
analysisOrderId: number,
|
|
): Promise<AnalysisResultDetailsMapped | null> {
|
|
const analysisOrder = await this.getAnalysisOrder({ analysisOrderId });
|
|
const orderedAnalysisElementIds = analysisOrder.analysis_element_ids ?? [];
|
|
if (orderedAnalysisElementIds.length === 0) {
|
|
console.error('No ordered analysis element ids found for analysis order id=', analysisOrderId);
|
|
return null;
|
|
}
|
|
const orderedAnalysisElements = await this.getOrderedAnalysisElements({ analysisOrderId, orderedAnalysisElementIds });
|
|
|
|
const orderedAnalysisElementOriginalIds = orderedAnalysisElements.map(({ analysis_id_original }) => analysis_id_original);
|
|
if (orderedAnalysisElementOriginalIds.length === 0) {
|
|
console.error('No ordered analysis element original ids found for analysis order id=', analysisOrderId);
|
|
return null;
|
|
}
|
|
|
|
const responseWithElements = await this.getAnalysisResponseWithElements({ analysisOrderId });
|
|
if (!responseWithElements) {
|
|
return null;
|
|
}
|
|
|
|
const mappedOrderedAnalysisElements = await this.getMappedOrderedAnalysisElements({
|
|
analysisResponseElements: responseWithElements.elements,
|
|
orderedAnalysisElements,
|
|
});
|
|
|
|
const feedback = responseWithElements.summary?.doctor_analysis_feedback?.[0];
|
|
return {
|
|
id: analysisOrderId,
|
|
order: {
|
|
status: analysisOrder.status,
|
|
medusaOrderId: analysisOrder.medusa_order_id,
|
|
createdAt: new Date(analysisOrder.created_at),
|
|
},
|
|
orderedAnalysisElementIds,
|
|
orderedAnalysisElements: mappedOrderedAnalysisElements,
|
|
summary:
|
|
feedback?.status === 'COMPLETED'
|
|
? (responseWithElements.summary?.doctor_analysis_feedback?.[0] ?? null)
|
|
: null,
|
|
};
|
|
}
|
|
|
|
async getAnalysisResponseWithElements({
|
|
analysisOrderId,
|
|
}: {
|
|
analysisOrderId: number;
|
|
}) {
|
|
const { data, error: userError } = await this.client.auth.getUser();
|
|
if (userError) {
|
|
throw userError;
|
|
}
|
|
const { user } = data;
|
|
|
|
const { data: analysisResponse } = await this.client
|
|
.schema('medreport')
|
|
.from('analysis_responses')
|
|
.select(
|
|
`*,
|
|
elements:analysis_response_elements(analysis_name,norm_status,response_value,unit,norm_lower_included,norm_upper_included,norm_lower,norm_upper,response_time,status,analysis_element_original_id,original_response_element,response_value_is_negative,response_value_is_within_norm),
|
|
summary:analysis_order_id(doctor_analysis_feedback(*))`,
|
|
)
|
|
.eq('user_id', user.id)
|
|
.eq('analysis_order_id', analysisOrderId)
|
|
.throwOnError();
|
|
|
|
return analysisResponse?.[0] as AnalysisResultDetails | null;
|
|
}
|
|
|
|
async getOrderedAnalysisElements({
|
|
analysisOrderId,
|
|
orderedAnalysisElementIds,
|
|
}: {
|
|
analysisOrderId: number;
|
|
orderedAnalysisElementIds: number[];
|
|
}) {
|
|
const { data: orderedAnalysisElements, error: orderedAnalysisElementsError } = await this.client
|
|
.schema('medreport')
|
|
.from('analysis_elements')
|
|
.select('analysis_id_original,analysis_name_lab')
|
|
.in('id', orderedAnalysisElementIds);
|
|
if (orderedAnalysisElementsError) {
|
|
console.error(`Failed to get ordered analysis elements for analysis order id=${analysisOrderId}`, orderedAnalysisElementsError);
|
|
throw orderedAnalysisElementsError;
|
|
}
|
|
return orderedAnalysisElements;
|
|
}
|
|
|
|
async getMappedOrderedAnalysisElements({
|
|
analysisResponseElements,
|
|
orderedAnalysisElements,
|
|
}: {
|
|
analysisResponseElements: AnalysisResultDetails['elements'];
|
|
orderedAnalysisElements: { analysis_id_original: string; analysis_name_lab: string }[];
|
|
}) {
|
|
const mappedOrderedAnalysisElements = orderedAnalysisElements.map(({ analysis_id_original, analysis_name_lab }) => {
|
|
return this.getOrderedAnalysisElement({
|
|
analysisIdOriginal: analysis_id_original,
|
|
analysisNameLab: analysis_name_lab,
|
|
analysisResponseElements,
|
|
});
|
|
}).sort((a, b) => a.analysisName.localeCompare(b.analysisName));
|
|
const nestedAnalysisElementIds = mappedOrderedAnalysisElements
|
|
.map(({ results }) => results?.nestedElements.map(({ analysisElementOriginalId }) => analysisElementOriginalId))
|
|
.flat().filter(Boolean);
|
|
if (nestedAnalysisElementIds.length > 0) {
|
|
const { data: nestedAnalysisElements, error: nestedAnalysisElementsError } = await this.client
|
|
.schema('medreport')
|
|
.from('analysis_elements')
|
|
.select('*')
|
|
.in('id', nestedAnalysisElementIds);
|
|
if (!nestedAnalysisElementsError && nestedAnalysisElements) {
|
|
for (const mappedOrderedAnalysisElement of mappedOrderedAnalysisElements) {
|
|
const { results } = mappedOrderedAnalysisElement;
|
|
if (!results) {
|
|
continue;
|
|
}
|
|
for (const nestedElement of results.nestedElements) {
|
|
const { analysisElementOriginalId } = nestedElement;
|
|
const nestedAnalysisElement = nestedAnalysisElements.find(({ id }) => id === analysisElementOriginalId);
|
|
if (!nestedAnalysisElement) {
|
|
continue;
|
|
}
|
|
results.nestedElements.push({
|
|
...nestedAnalysisElement,
|
|
analysisElementOriginalId,
|
|
analysisName: nestedAnalysisElement.analysis_name_lab,
|
|
});
|
|
}
|
|
}
|
|
|
|
mappedOrderedAnalysisElements.forEach(({ results }) => {
|
|
results?.nestedElements.forEach(({ analysisElementOriginalId }) => {
|
|
const nestedAnalysisElement = nestedAnalysisElements.find(({ id }) => id === analysisElementOriginalId);
|
|
if (nestedAnalysisElement) {
|
|
results?.nestedElements.push({
|
|
...nestedAnalysisElement,
|
|
analysisElementOriginalId,
|
|
analysisName: nestedAnalysisElement.analysis_name_lab,
|
|
});
|
|
} else {
|
|
console.error('Nested analysis element not found for analysis element original id=', analysisElementOriginalId);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
return mappedOrderedAnalysisElements;
|
|
}
|
|
|
|
getOrderedAnalysisElement({
|
|
analysisIdOriginal,
|
|
analysisNameLab,
|
|
analysisResponseElements,
|
|
}: {
|
|
analysisIdOriginal: string;
|
|
analysisNameLab: string;
|
|
analysisResponseElements: AnalysisResultDetails['elements'];
|
|
}) {
|
|
const elementResponse = analysisResponseElements.find((element) => element.analysis_element_original_id === analysisIdOriginal);
|
|
if (!elementResponse) {
|
|
return {
|
|
analysisIdOriginal,
|
|
isWaitingForResults: true,
|
|
analysisName: analysisNameLab,
|
|
};
|
|
}
|
|
const labComment = elementResponse.original_response_element?.UuringuKommentaar;
|
|
return {
|
|
analysisIdOriginal,
|
|
isWaitingForResults: false,
|
|
analysisName: analysisNameLab,
|
|
results: {
|
|
nestedElements: (() => {
|
|
const nestedElements = elementResponse.original_response_element?.UuringuElement as UuringElement[] | undefined;
|
|
if (!nestedElements) {
|
|
return [];
|
|
}
|
|
return nestedElements.map((element) => {
|
|
const elementVastus = element.UuringuVastus as UuringuVastus | undefined;
|
|
const responseValue = elementVastus?.VastuseVaartus;
|
|
const responseValueIsNumeric = !isNaN(Number(responseValue));
|
|
const responseValueIsNegative = responseValue === 'Negatiivne';
|
|
const responseValueIsWithinNorm = responseValue === 'Normi piires';
|
|
return {
|
|
status: element.UuringOlek,
|
|
unit: element.Mootyhik,
|
|
normLower: elementVastus?.NormAlum?.['#text'],
|
|
normUpper: elementVastus?.NormYlem?.['#text'],
|
|
normStatus: elementVastus?.NormiStaatus,
|
|
responseTime: elementVastus?.VastuseAeg,
|
|
response_value: responseValueIsNegative || !responseValueIsNumeric ? null : (responseValue ?? null),
|
|
response_value_is_negative: responseValueIsNumeric ? null : responseValueIsNegative,
|
|
response_value_is_within_norm: responseValueIsNumeric ? null : responseValueIsWithinNorm,
|
|
normLowerIncluded: elementVastus?.NormAlum?.['@_kaasaarvatud'] === 'JAH',
|
|
normUpperIncluded: elementVastus?.NormYlem?.['@_kaasaarvatud'] === 'JAH',
|
|
analysisElementOriginalId: element.UuringId,
|
|
};
|
|
});
|
|
})(),
|
|
labComment,
|
|
//originalResponseElement: elementResponse.original_response_element ?? null,
|
|
unit: elementResponse.unit,
|
|
normLower: elementResponse.norm_lower,
|
|
normUpper: elementResponse.norm_upper,
|
|
normStatus: elementResponse.norm_status,
|
|
responseTime: elementResponse.response_time,
|
|
responseValue: elementResponse.response_value,
|
|
responseValueIsNegative: elementResponse.response_value_is_negative === true,
|
|
responseValueIsWithinNorm: elementResponse.response_value_is_within_norm === true,
|
|
normLowerIncluded: elementResponse.norm_lower_included,
|
|
normUpperIncluded: elementResponse.norm_upper_included,
|
|
status: elementResponse.status,
|
|
analysisElementOriginalId: elementResponse.analysis_element_original_id,
|
|
}
|
|
};
|
|
}
|
|
|
|
// @TODO unused currently
|
|
async getUserAnalyses(): Promise<UserAnalysis | null> {
|
|
const authUser = await this.client.auth.getUser();
|
|
const { data, error: userError } = authUser;
|
|
|
|
if (userError) {
|
|
console.error('Failed to get user', userError);
|
|
throw userError;
|
|
}
|
|
|
|
const { user } = data;
|
|
|
|
const { data: analysisResponses } = await this.client
|
|
.schema('medreport')
|
|
.from('analysis_responses')
|
|
.select('*')
|
|
.eq('user_id', user.id);
|
|
|
|
if (!analysisResponses) {
|
|
return null;
|
|
}
|
|
|
|
const analysisResponseIds = analysisResponses.map((r) => r.id);
|
|
|
|
const { data: analysisResponseElements } = await this.client
|
|
.schema('medreport')
|
|
.from('analysis_response_elements')
|
|
.select('*')
|
|
.in('analysis_response_id', analysisResponseIds);
|
|
|
|
if (!analysisResponseElements) {
|
|
return null;
|
|
}
|
|
|
|
return analysisResponses.map((r) => ({
|
|
...r,
|
|
elements: analysisResponseElements.filter(
|
|
(e) => e.analysis_response_id === r.id,
|
|
),
|
|
}));
|
|
}
|
|
|
|
async hasAccountTeamMembership(accountId?: string) {
|
|
if (!accountId) {
|
|
return false;
|
|
}
|
|
|
|
const { count, error } = await this.client
|
|
.schema('medreport')
|
|
.from('accounts_memberships')
|
|
.select('account_id', { count: 'exact', head: true })
|
|
.eq('account_id', accountId);
|
|
|
|
if (error) {
|
|
throw error;
|
|
}
|
|
|
|
return (count ?? 0) > 0;
|
|
}
|
|
|
|
async fetchBmiThresholds() {
|
|
// Fetch BMI
|
|
const { data, error } = await this.client
|
|
.schema('medreport')
|
|
.from('bmi_thresholds')
|
|
.select(
|
|
'age_min,age_max,underweight_max,normal_min,normal_max,overweight_min,strong_min,obesity_min',
|
|
)
|
|
.order('age_min', { ascending: true });
|
|
|
|
if (error) {
|
|
console.error('Error fetching BMI thresholds:', error);
|
|
throw error;
|
|
}
|
|
return data;
|
|
}
|
|
}
|
|
|
|
export function createUserAnalysesApi(client: SupabaseClient<Database>) {
|
|
return new UserAnalysesApi(client);
|
|
}
|