@openhealth/oht-custom-parser-lib 0.2.81 → 0.3.1

package/dist/service/ohtReportMeasurementsExtractor.service.js

@@ -0,0 +1,693 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ohtReportMeasurementsExtractor = ohtReportMeasurementsExtractor;
+const dataUtils_1 = require("../util-ts/dataUtils");
+const extractionUtils_1 = require("../util-ts/extractionUtils");
+const pinoLogger_1 = __importDefault(require("../util-ts/pinoLogger"));
+const apiUtils_1 = require("../util-ts/apiUtils");
+const oht_types_1 = require("../types/oht.types");
+const transformationRules_service_1 = require("./transformationRules.service");
+const auxiliaryFunctions_service_1 = require("./auxiliaryFunctions.service");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Logger instance for the application
+ */
+const logger = (0, pinoLogger_1.default)();
+// Import version from package.json file
+// Handle multiple possible paths: compiled (dist/service/), development (service/), or when used as dependency
+function getPackageJsonVersion() {
+    const possiblePaths = [
+        path.resolve(__dirname, '../../package.json'), // Compiled: dist/service/ -> dist/ -> root
+        path.resolve(__dirname, '../package.json'), // Development: service/ -> root
+        path.resolve(__dirname, '../../../package.json'), // When used as dependency from node_modules
+        path.resolve(process.cwd(), 'package.json'), // From current working directory
+    ];
+    for (const packagePath of possiblePaths) {
+        if (fs.existsSync(packagePath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+                if (packageJson.name === '@openhealth/oht-custom-parser-lib' && packageJson.version) {
+                    return packageJson.version;
+                }
+            }
+            catch (error) {
+                // Continue to next path if this one fails
+                continue;
+            }
+        }
+    }
+    // Fallback to a default version if package.json cannot be found
+    logger.warn('Could not find package.json, using default version');
+    return '0.0.0';
+}
+const ohtCustomParserLibVersion = getPackageJsonVersion();
+/**
+ * Environment variable for OHT Core
+ */
+const OHT_CORE_URL = process.env.OHT_CORE_URL;
+/**
+ * Current filename being processed (global state for error reporting)
+ */
+let filename = '';
+/**
+ * Error messages for parser operations
+ */
+const ERROR_MESSAGES = {
+    NO_LAB_KEYS_FOUND: 'No lab keys found',
+    NO_MAPPING_FOUND: 'No Mapping found for labKey',
+};
+/**
+ * Apply transformation rules to exams
+ * This function applies transformation rules chain to each exam, passing all exams as context
+ *
+ * @param exams - Array of original exam objects
+ * @param transformationRules - Mapping of labKey to transformation rule chains
+ * @param patientInfo - Patient information
+ * @param documentDate - Document date
+ * @returns Promise<ApplyTransformationRulesResult> - Array of transformed exams and error messages
+ */
+async function applyTransformationRulesToExams(exams, transformationRules, patientInfo, documentDate) {
+    if (transformationRules.size === 0) {
+        return {
+            transformedExams: exams,
+            applicationErrorMessages: []
+        };
+    }
+    const transformedExams = [];
+    // Prepare context for transformation rules
+    const reportContext = {
+        patient: {
+            sex: patientInfo.sex,
+            birthdate: patientInfo.birthdate,
+            age: (0, auxiliaryFunctions_service_1.getPatientAge)(documentDate, patientInfo.birthdate),
+        }
+    };
+    // Prepare the OHT exam data
+    const ohtReport = {
+        exams: exams.map(e => e.ohtExam),
+    };
+    logger.info({ examsCount: exams.length, chainsCount: transformationRules.size, filename }, 'Applying transformation rules to exams...');
+    let labKeysWithRulesCount = 0;
+    let transformedLabKeysCount = 0;
+    const applicationErrorMessages = [];
+    for (const exam of exams) {
+        const labKey = exam.ohtExam.labKey;
+        const rulesChain = transformationRules.get(labKey);
+        if (!rulesChain || rulesChain.length === 0) {
+            transformedExams.push(exam);
+            continue;
+        }
+        labKeysWithRulesCount++;
+        try {
+            const result = await (0, transformationRules_service_1.applyRules)(rulesChain, exam.ohtExam, {
+                ohtReportJson: ohtReport,
+                contextJson: reportContext,
+            });
+            if (result.errors.length > 0) {
+                logger.warn({ labKey, errors: result.errors, filename }, 'Errors applying transformation rule(s) for labKey.');
+                applicationErrorMessages.push(`${labKey}: ${result.errors.map(e => `(rule ID ${e.ruleId}) ${e.error}`).join('; ')}`);
+            }
+            else {
+                if (result.appliedRules.length > 0) {
+                    transformedLabKeysCount++;
+                }
+                logger.info({ labKey, appliedRules: result.appliedRules.length, filename }, 'Done applying transformation rule(s) for labKey.');
+                // Add the transformed exam to the result array only if there are no errors in the chain
+                transformedExams.push({
+                    ohtExam: result.data,
+                    originalExam: exam.originalExam
+                });
+            }
+        }
+        catch (error) {
+            logger.error({ labKey, error, filename }, 'Failed to apply transformation rules for labKey.');
+            applicationErrorMessages.push(`${labKey}: Unhandled error occurred.`);
+        }
+    }
+    logger.info({
+        filename,
+        examsCount: exams.length,
+        chainsCount: transformationRules.size,
+        transformedLabKeysCount,
+        labKeysWithRulesCount,
+    }, 'Done applying the transformation rules to exams.');
+    return {
+        transformedExams,
+        applicationErrorMessages
+    };
+}
+/**
+ * Extracts measurements from OHT report exams by processing each exam through biomarker mapping,
+ * transformation rules, and value extraction.
+ *
+ * This function is the main entry point for converting raw exam data into standardized OHT measurements.
+ * It handles biomarker mapping, unit extraction, value parsing, range extraction, and error reporting.
+ *
+ * ## Processing Flow:
+ *
+ * ### Step 1: Initialization and Validation
+ * - Validates that exams array is not empty
+ * - Initializes result arrays (measurements, unknownMeasurements, unknownUnits, unmappedLabKeys)
+ * - Sets up error tracking and transformation rules error tracking
+ *
+ * ### Step 2: Fetch Biomarker Mappings
+ * - Calls `getMappedBiomarkers()` to retrieve biomarker mappings from OHT Core backend
+ * - Maps labKeys to OHT biomarker IDs (ohtBmId) for the given partner
+ * - Logs the number of mappings retrieved
+ *
+ * ### Step 3: Apply Transformation Rules
+ * - Applies transformation rules to all exams using `applyTransformationRulesToExams()`
+ * - Transformation rules can modify exam data before processing (e.g., normalize units, fix values)
+ * - Creates a map of transformed exams for quick lookup during processing
+ * - Collects and reports any transformation rule errors
+ *
+ * ### Step 4: Collect Biomarker IDs and Fetch Biomarker Details
+ * - Iterates through all exams to collect unique OHT biomarker IDs from mappings
+ * - Filters out ignored biomarkers and unmapped biomarkers (ohtBmId === -1)
+ * - Makes API call to OHT Core to fetch full biomarker details (standard units, ranges, etc.)
+ * - Fetches synonym units from API if partnerId is provided (for unit resolution)
+ *
+ * ### Step 5: Process Each Exam
+ * For each exam in the input array:
+ *
+ * #### 5.1: Create UnmappedLabKey (Always)
+ * - **Always** creates an `unmappedLabKey` entry for every exam, regardless of mapping status
+ * - This ensures all labKeys are tracked for unmapped biomarker analysis
+ * - Includes exam metadata: labKey, biomarkerName, value, unit, annotation, originalName, dataOrigin
+ *
+ * #### 5.2: Check Biomarker Mapping Status
+ * - Retrieves backend mapping for the exam's labKey
+ * - Skips processing if biomarker is marked as `isIgnored === true`
+ * - Uses `handleBiomarkerId()` to determine final `ohtBmId` and `annotationConfig`
+ *   - Handles unmapped biomarkers (ohtBmId === -1)
+ *   - Handles `keepAsUnmapped` flag override
+ *
+ * #### 5.3: Process Mapped Biomarkers (ohtBmId !== -1 and !== undefined)
+ *
+ * ##### 5.3.1: Duplicate Check
+ * - Checks if biomarker ID already exists in measurements array
+ * - If duplicate, logs warning and adds error message, then continues to next exam
+ *
+ * ##### 5.3.2: Fetch Biomarker Details
+ * - Finds biomarker object from API response using `ohtBmId`
+ * - If not found, logs warning, adds error, and continues to next exam
+ *
+ * ##### 5.3.3: Extract Unit
+ * - Calls `ohtReportExtractUnit()` to extract and validate unit
+ * - Handles arbitrary units, standard units, alternative units, and synonym units
+ * - If unit cannot be resolved, adds to `unknownUnits` array
+ * - Logs warning and marks measurement as incorrectly parsed if unit extraction fails
+ *
+ * ##### 5.3.4: Parse Exam Value
+ * - Calls `ohtReportParseExamValue()` to extract value from exam
+ * - Determines value type (NUMERICAL or ALPHANUMERICAL) based on biomarker configuration
+ * - Handles greater than/less than comparators (e.g., ">10", "<5")
+ * - Logs warning and marks measurement as incorrectly parsed if value extraction fails
+ *
+ * ##### 5.3.5: Handle Numerical Without Valid Result
+ * - Checks if value is numerical but cannot be parsed as a valid number
+ * - If true, creates `unknownMeasurement` and continues to next exam
+ *
+ * ##### 5.3.6: Validate Plausible Values (for NUMERICAL biomarkers)
+ * - Calls `ohtReportCheckValueForPlausibleValues()` to validate value is within expected range
+ * - Converts value to standard unit if necessary using conversion factors
+ * - Logs warning and marks measurement as incorrectly parsed if value is not plausible
+ *
+ * ##### 5.3.7: Extract Reference Ranges (for NUMERICAL biomarkers)
+ * - Calls `ohtReportExtractReferenceRanges()` which uses `parseRange()` internally
+ * - Extracts min/max normal values based on patient age, sex, and range data
+ * - Filters ranges by patient demographics and selects most appropriate range
+ * - Logs warning and marks measurement as incorrectly parsed if range extraction fails
+ *
+ * ##### 5.3.8: Extract Reference Annotation
+ * - Calls `ohtReportExtractReferenceAnnotation()` to extract annotation text
+ * - Handles appended mappings (combines values from multiple related biomarkers)
+ * - Merges annotation from exam data with appended mapping results
+ *
+ * ##### 5.3.9: Build Measurement Object
+ * - Constructs complete `Measurement` object with all extracted data:
+ *   - Biomarker ID, value type, value, alphanumeric value
+ *   - Unit, original unit, arbitrary unit flag
+ *   - Reference range (min/max normal values)
+ *   - Range annotation
+ *   - Material, method
+ *   - Collection dates (collectionDate, effectiveDate, examCollectionDate, examEffectiveDate)
+ *   - Original name for document search
+ *   - Digitalization approval flags
+ * - Adds measurement to `measurements` array
+ *
+ * #### 5.4: Process Unmapped Biomarkers (no mapping or ohtBmId === -1)
+ * - Creates `unknownMeasurement` object with:
+ *   - LabKey, biomarker name (mnemonic:examName), value, unit, annotation
+ *   - Data origin information
+ *   - Original exam data for reference
+ * - Adds to `unknownMeasurements` array
+ *
+ * ### Step 6: Summary and Return
+ * - Logs processing summary (total labKeys, mapped biomarkers, unmapped biomarkers, errors)
+ * - Returns result object containing:
+ *   - `measurements`: Array of successfully parsed and mapped measurements
+ *   - `unknownMeasurements`: Array of measurements that could not be mapped or parsed
+ *   - `unknownUnits`: Array of units that could not be resolved
+ *   - `unmappedLabKeys`: Array of all labKeys (always created for every exam)
+ *   - `isReportCorrectlyParsed`: Boolean indicating if all measurements were parsed correctly
+ *   - `transformationRulesErrors`: Array of errors from transformation rules application
+ *
+ * ## Error Handling:
+ * - All errors are added to the `errorMessages` array passed as parameter
+ * - Errors are categorized by destination (slack, notes, bi)
+ * - Processing continues even if individual exams fail
+ * - Errors are logged with context (filename, labKey, ohtBmId, etc.)
+ *
+ * ## Key Behaviors:
+ * - **UnmappedLabKeys**: Always created for ALL exams, regardless of mapping status
+ * - **UnknownMeasurements**: Created when:
+ *   - No backend mapping exists for labKey
+ *   - ohtBmId === -1 (explicitly unmapped)
+ *   - Value is numerical but cannot be parsed as valid number
+ * - **Measurements**: Created only when biomarker is successfully mapped and all extraction steps succeed
+ *
+ * @param exams - Array of Exam objects containing ohtExam and originalExam data
+ * @param sourceFilename - Name of the source file being processed (for error reporting)
+ * @param patientInfo - Patient information (sex, birthdate) for range extraction
+ * @param documentDate - Document date for age calculation and range extraction
+ * @param transformationRules - Map of labKey to transformation rule chains to apply
+ * @param ohtCoreApiKey - API key for OHT Core API calls
+ * @param partnerId - Partner ID for fetching biomarker mappings and synonym units
+ * @param errorMessages - Array to accumulate error messages (modified in-place)
+ * @returns Promise resolving to extraction result with measurements, unknownMeasurements, unknownUnits, unmappedLabKeys, parsing status, and transformation errors
+ */
+async function ohtReportMeasurementsExtractor(exams, sourceFilename, patientInfo, documentDate, transformationRules, ohtCoreApiKey, partnerId, errorMessages) {
+    filename = sourceFilename;
+    const measurements = [];
+    const unknownMeasurements = [];
+    const unknownUnits = [];
+    const unmappedLabKeys = [];
+    let isReportCorrectlyParsed = true;
+    let transformationRulesErrors = [];
+    // Check if we have exams
+    const labKeys = exams.map(e => e.ohtExam.labKey);
+    if (labKeys.length === 0) {
+        const errorMsg = `No lab keys found, filename: ${filename}`;
+        logger.error(errorMsg);
+        errorMessages.push({
+            destination: { slack: true, notes: false, bi: false },
+            message: errorMsg,
+        });
+        return {
+            measurements,
+            unknownMeasurements,
+            unknownUnits,
+            unmappedLabKeys,
+            isReportCorrectlyParsed: false,
+            transformationRulesErrors,
+        };
+    }
+    logger.info(`Processing lab file with ${labKeys.length} keys, filename: ${filename}`);
+    // Call getMappedBiomarkers to get the biomarker mapping for the partner
+    const mappedBiomarkers = await (0, dataUtils_1.getMappedBiomarkers)(partnerId, ohtCoreApiKey);
+    // add  "GROUPED_" bms for appended mappings
+    if (mappedBiomarkers) {
+        const groupedLabKeys = Object.keys(mappedBiomarkers).filter(labKey => labKey.startsWith('GROUPED_'));
+        for (const groupedLabKey of groupedLabKeys) {
+            const emptyOhtExam = {
+                labKey: groupedLabKey,
+                value: mappedBiomarkers[groupedLabKey]?.syntheticValue ?? '',
+                unit: '',
+                documentDate: documentDate ? documentDate.toISOString() : '',
+                description: '',
+                mnemonic: '',
+                examName: '',
+                range: [],
+                annotation: '',
+            };
+            const emptyExam = {
+                ohtExam: emptyOhtExam,
+                originalExam: {
+                    contentType: 'application/json',
+                    exam: JSON.stringify(emptyOhtExam),
+                },
+            };
+            exams.push(emptyExam);
+        }
+        if (groupedLabKeys.length > 0) {
+            logger.info(`Added ${groupedLabKeys.length} empty OhtExam objects for GROUPED_ biomarkers to check for appended mappings`);
+        }
+    }
+    if (mappedBiomarkers) {
+        logger.info(`Retrieved ${Object.keys(mappedBiomarkers).length} biomarker mappings from backend for partner: ${partnerId}`);
+    }
+    else {
+        logger.info(`No biomarker mappings found in backend for partner: ${partnerId}`);
+    }
+    // Apply transformation rules to all exams
+    let transformedExamsResult = { transformedExams: [], applicationErrorMessages: [] };
+    try {
+        transformedExamsResult = await applyTransformationRulesToExams(exams, transformationRules, patientInfo, documentDate);
+    }
+    catch (error) {
+        logger.error({ error, filename }, 'Unhandled error while applying transformation rules to exams.');
+        errorMessages.push({
+            destination: { slack: true, notes: true, bi: false },
+            message: `Failed applying the transformation rules for filename ${filename}. ${error instanceof Error ? error.message : error}`,
+        });
+    }
+    if (transformedExamsResult.applicationErrorMessages.length > 0) {
+        transformationRulesErrors = transformedExamsResult.applicationErrorMessages;
+        errorMessages.push({
+            destination: { slack: false, notes: true, bi: false },
+            message: `Failed applying some transformation rules:\n${transformedExamsResult.applicationErrorMessages.map((e) => `  - ${e}`).join("\n\n")}`,
+        });
+    }
+    const transformedExams = transformedExamsResult.transformedExams;
+    const transformedExamsMap = transformedExams.reduce((map, exam) => map.set(exam.ohtExam.labKey, exam), new Map());
+    // Collect all possible OHT biomarker IDs from mapped biomarkers
+    const allPossibleOHTBmIds = [];
+    for (const exam of exams) {
+        const labKey = exam.ohtExam.labKey;
+        const backendMapping = mappedBiomarkers?.[labKey];
+        if (backendMapping && !backendMapping.isIgnored) {
+            const { ohtBmId } = (0, extractionUtils_1.handleBiomarkerId)(backendMapping, labKey);
+            if (ohtBmId && ohtBmId !== -1) {
+                allPossibleOHTBmIds.push(ohtBmId);
+            }
+        }
+    }
+    // data to request api
+    const requestData = {
+        "biomarkerIds": allPossibleOHTBmIds,
+        "page": 1,
+        "pageSize": allPossibleOHTBmIds.length
+    };
+    // api call to ohtCore to find biomarkers.
+    const biomarkers = await (0, apiUtils_1.makeApiCallWithRetry)('post', `${OHT_CORE_URL}/v1/biomarker/biomarkers`, requestData, ohtCoreApiKey);
+    // Fetch synonym units from API if enabled
+    let synonymUnits = null;
+    if (partnerId) {
+        synonymUnits = await (0, dataUtils_1.fetchSynonymUnits)(partnerId, ohtCoreApiKey);
+        // If API fetch failed or returned empty, set to null to use hardcoded fallback
+        if (synonymUnits.length === 0) {
+            synonymUnits = null;
+        }
+    }
+    // Process each exam directly
+    for (const exam of exams) {
+        const labKey = exam.ohtExam.labKey;
+        const examObj = exam.ohtExam;
+        const originalExam = exam.originalExam;
+        // Get the transformed exam for this labKey, or use the original ohtExam
+        const transformedExam = transformedExamsMap.get(labKey);
+        const transformedExamObj = transformedExam ? transformedExam.ohtExam : examObj;
+        // ALWAYS create unmappedLabKey for all exams
+        const unmappedLabKey = {
+            labKey: labKey,
+            biomarkerName: `${examObj.mnemonic}`,
+            value: examObj.value || '',
+            unit: examObj.unit || '',
+            annotation: examObj.annotation || '',
+            originalName: `${examObj.examName}`,
+            dataOrigin: [
+                {
+                    itemExtracted: 'measurement',
+                    method: 'custom-parser',
+                    methodVersion: `oht-custom-parser-lib-v${ohtCustomParserLibVersion}`,
+                    path: 'exams',
+                },
+            ],
+            originalExam: originalExam ? originalExam : undefined,
+            ohtExam: examObj,
+        };
+        unmappedLabKeys.push(unmappedLabKey);
+        // Get backend mapping for this labKey
+        const backendMapping = mappedBiomarkers?.[labKey];
+        // Skip processing if biomarker is marked as ignored
+        if (backendMapping?.isIgnored === true) {
+            logger.info(`Skipping ignored biomarker: ${labKey}`);
+            continue;
+        }
+        // Handle biomarker id
+        let finalOhtBmId;
+        let annotationConfig;
+        if (backendMapping) {
+            const { ohtBmId, annotationConfig: config } = (0, extractionUtils_1.handleBiomarkerId)(backendMapping, labKey);
+            finalOhtBmId = ohtBmId;
+            annotationConfig = {
+                enabled: config.enabled,
+                labKeys: backendMapping.annotationConfig?.labKeys || [],
+                maxLength: backendMapping.annotationConfig?.maxLength,
+                fallbackValue: backendMapping.annotationConfig?.fallbackValue,
+                separator: backendMapping.annotationConfig?.separator,
+            };
+            logger.info(`Using mappings from custom parser studio (oht-core backend) for labKey: ${labKey} (ohtBmId: ${backendMapping.ohtBmId})`);
+        }
+        else {
+            logger.debug(`No backend mapping found for labKey: ${labKey}, will process as unmapped`);
+        }
+        // Process as mapped biomarker if ohtBmId is valid
+        if (finalOhtBmId !== undefined && finalOhtBmId !== -1) {
+            let isMeasurementCorrectlyParsed = true;
+            // if BM is already in measurements, continue to the next one
+            if (measurements.some(measurement => measurement.biomarkerId === finalOhtBmId)) {
+                logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Biomarker already in measurements array, should investigate, filename: ${filename}`);
+                errorMessages.push({
+                    destination: { slack: false, notes: false, bi: true },
+                    message: `Biomarkers Duplicated keys:[PLACEHOLDER]`,
+                    item: `bmId:${finalOhtBmId}, labKey:${transformedExamObj.labKey}`
+                });
+                continue;
+            }
+            const ohtBiomarker = biomarkers?.data?.items.find((bm) => bm.id === finalOhtBmId);
+            if (!ohtBiomarker) {
+                logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Biomarker not found in API response for ohtBmId: ${finalOhtBmId}, labKey: ${transformedExamObj.labKey}, filename: ${filename}`);
+                errorMessages.push({
+                    destination: { slack: true, notes: true, bi: true },
+                    message: `Biomarker not found for:[PLACEHOLDER]`,
+                    item: `bmId:${finalOhtBmId}, labKey:${transformedExamObj.labKey}`
+                });
+                continue;
+            }
+            // Used for error messages
+            const bmInfo = ohtBiomarker?.acf?.shortName ?
+                `name:${ohtBiomarker.acf.shortName}, bmId:${finalOhtBmId}, labKey:${transformedExamObj.labKey}` :
+                `bmId:${finalOhtBmId}, labKey:${transformedExamObj.labKey}`;
+            const { unit, isUnitParsedCorrectly, originalUnit, isArbitraryUnit, unknownUnit } = (0, extractionUtils_1.ohtReportExtractUnit)(transformedExamObj, ohtBiomarker, synonymUnits, partnerId);
+            if (unknownUnit.length > 0) {
+                unknownUnits.push({
+                    biomarkerId: ohtBiomarker.id,
+                    unit: unknownUnit,
+                    partnerId: partnerId || '',
+                    labKey: transformedExamObj.labKey,
+                    ohtExam: examObj,
+                    originalExam: originalExam,
+                    biomarkerName: transformedExamObj.mnemonic || '',
+                    dataImportFileUploadId: null, // is null it will be set later in the structParser.service.ts
+                });
+            }
+            if (!isUnitParsedCorrectly) {
+                logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Unit not extracted correctly for "${finalOhtBmId}|${transformedExamObj.labKey}", filename: ${filename}`);
+                errorMessages.push({
+                    destination: { slack: true, notes: true, bi: true },
+                    message: `Unit not extracted correctly for:[PLACEHOLDER]`,
+                    item: `${bmInfo}`
+                });
+                isMeasurementCorrectlyParsed = false;
+            }
+            let { valueType, alphanumericalValue, numberValue, valueComparator, isValueParsedCorrectly } = (0, extractionUtils_1.ohtReportParseExamValue)(transformedExamObj, ohtBiomarker);
+            if (!isValueParsedCorrectly) {
+                logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Value not extracted correctly for "${finalOhtBmId}|${transformedExamObj.labKey}", filename: ${filename}`);
+                errorMessages.push({
+                    destination: { slack: true, notes: true, bi: true },
+                    message: `Value not extracted correctly for:[PLACEHOLDER]`,
+                    item: `${bmInfo}`
+                });
+                isMeasurementCorrectlyParsed = false;
+            }
+            if ((0, dataUtils_1.isNumericalWithoutValidResult)(valueType, numberValue, alphanumericalValue)) {
+                const alphanumericalValueTrimmed = alphanumericalValue?.trim() ?? '';
+                const unknownMeasurement = {
+                    biomarkerName: transformedExamObj.description ?? '',
+                    value: alphanumericalValueTrimmed,
+                    unit: unit ?? '',
+                    annotation: transformedExamObj.annotation ?? '',
+                    dataOrigin: [{
+                            itemExtracted: 'measurement',
+                            method: 'custom-parser',
+                            methodVersion: 'oht-custom-parser-lib',
+                            path: 'exams',
+                        }],
+                    originalName: transformedExamObj.examName ?? '',
+                    originalExam: {
+                        contentType: 'application/json',
+                        exam: JSON.stringify(transformedExamObj)
+                    },
+                    ohtExam: transformedExamObj
+                };
+                unknownMeasurements.push(unknownMeasurement);
+                continue;
+            }
+            // Check if the value is plausible
+            if (isValueParsedCorrectly && valueType === 'NUMERICAL') {
+                const isPlausibleValue = numberValue !== null && (0, extractionUtils_1.ohtReportCheckValueForPlausibleValues)(finalOhtBmId, transformedExamObj.labKey, ohtBiomarker, unit, numberValue, isUnitParsedCorrectly, filename);
+                if (!isPlausibleValue) {
+                    logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Value [${numberValue} ${unit}] is not plausible for "${finalOhtBmId}|${transformedExamObj.labKey}", filename: ${filename}`);
+                    errorMessages.push({
+                        destination: { slack: true, notes: true, bi: true },
+                        message: `Value is not plausible for:[PLACEHOLDER]`,
+                        item: `${bmInfo}, value:${numberValue}${unit}`
+                    });
+                    isMeasurementCorrectlyParsed = false;
+                }
+            }
+            let from = null, to = null;
+            let isRangeParsedCorrectly = true;
+            // If the biomarker is numerical, extract the reference range
+            if ((0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)) {
+                const extractedRange = (0, extractionUtils_1.ohtReportExtractReferenceRanges)(transformedExamObj, patientInfo);
+                from = extractedRange.from ?? null;
+                to = extractedRange.to ?? null;
+                isRangeParsedCorrectly = extractedRange.isRangeParsedCorrectly;
+                if (!isRangeParsedCorrectly) {
+                    logger.warn({ ohtBmId: finalOhtBmId, labKey }, `Range not extracted correctly for "${finalOhtBmId}|${transformedExamObj.labKey}", filename: ${filename}`);
+                    errorMessages.push({
+                        destination: { slack: true, notes: true, bi: true },
+                        message: `Range not extracted correctly for:[PLACEHOLDER]`,
+                        item: `${bmInfo}`
+                    });
+                    isMeasurementCorrectlyParsed = false;
+                }
+            }
+            let extractedAnnotation;
+            // TODO: always extract annotation? or only if annotationConfig.enabled is true?
+            extractedAnnotation = (0, extractionUtils_1.ohtReportExtractReferenceAnnotation)(annotationConfig, transformedExamObj, patientInfo, documentDate, transformedExams, filename);
+            // Use material and method directly from ohtExam
+            const material = transformedExamObj?.material ?? '';
+            const method = transformedExamObj?.method ?? '';
+            let alphaValue = !(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) && alphanumericalValue
+                ? alphanumericalValue.trim()
+                : '';
+            // adding unit for alphanumerical values as number.
+            if (!Number.isNaN(parseFloat(alphaValue))) {
+                // Use unit directly from ohtExam
+                let originalUnitFromExam = transformedExamObj?.unit ?? '';
+                originalUnitFromExam = originalUnitFromExam?.replaceAll(/ /g, '') ?? '';
+                alphaValue = alphaValue && unit?.length > 0 ? `${alphaValue} ${originalUnitFromExam}`.trim() : alphaValue;
+            }
+            // adding dates for measurements in ISO 8601 format
+            const collectionDate = transformedExamObj.collectionDate ? new Date(transformedExamObj.collectionDate).toISOString() : null;
+            const effectiveDate = transformedExamObj.effectiveDate ? new Date(transformedExamObj.effectiveDate).toISOString() : null;
+            const examCollectionDate = transformedExamObj.examCollectionDate ? new Date(transformedExamObj.examCollectionDate).toISOString() : null;
+            const examEffectiveDate = transformedExamObj.examEffectiveDate ? new Date(transformedExamObj.examEffectiveDate).toISOString() : null;
+            // add original name for document search
+            const originalName = transformedExamObj.examName ?? '';
+            // if the biomarker is a grouped biomarker and the annotation is empty, ignore it and continue to the next one
+            if (labKey.startsWith('GROUPED_') && !extractedAnnotation) {
+                continue;
+            }
+            let measurement = {
+                biomarkerId: ohtBiomarker.id,
+                valueType,
+                value: (0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) ? numberValue : null,
+                alphanumericValue: alphaValue,
+                rangeAnnotation: extractedAnnotation ? extractedAnnotation : null,
+                showVisualisationIfAnnotated: backendMapping?.referenceAsAnnotation?.enabled ?? false,
+                comparator: valueComparator ?? oht_types_1.MeasurementValueComparator.EQUAL,
+                minNormalValue: from,
+                maxNormalValue: to,
+                unit,
+                originalUnit,
+                isArbitraryUnit,
+                material,
+                method,
+                isDigitalizationApproved: isMeasurementCorrectlyParsed,
+                isManualChecked: isMeasurementCorrectlyParsed,
+                collectionDate: collectionDate,
+                effectiveDate: effectiveDate,
+                examCollectionDate: examCollectionDate,
+                examEffectiveDate: examEffectiveDate,
+                originalName: originalName,
+            };
+            measurements.push(measurement);
+            isReportCorrectlyParsed = isReportCorrectlyParsed && isMeasurementCorrectlyParsed;
+        }
+        else {
+            // No mapping or ohtBmId === -1: create unknownMeasurement
+            const labkey = transformedExamObj?.labKey?.trim() || labKey.split(':')[0];
+            const unknownMeasurementName = `${transformedExamObj.mnemonic}:${transformedExamObj.examName}`;
+            const originalName = labKey.split(':')[1] || transformedExamObj.examName;
+            const annotation = `${transformedExamObj.annotation || ''}`;
+            const dataOrigin = {
+                itemExtracted: 'measurement',
+                method: 'custom-parser',
+                methodVersion: `oht-custom-parser-lib-v${ohtCustomParserLibVersion}`,
+                path: 'exams',
+            };
+            const unknownMeasurement = {
+                biomarkerName: unknownMeasurementName,
+                value: transformedExamObj.value || '',
+                unit: transformedExamObj.unit || '',
+                annotation: annotation,
+                dataOrigin: [dataOrigin],
+                originalName: originalName,
+                originalExam: originalExam ? originalExam : undefined,
+                ohtExam: transformedExamObj,
+            };
+            unknownMeasurements.push(unknownMeasurement);
+        }
+    }
+    // Log summary of processing
+    const backendMappedCount = measurements.length;
+    const unmappedCount = unknownMeasurements.length;
+    logger.info(`Processing completed for ${filename}:`, {
+        totalLabKeys: labKeys.length,
+        backendMappedBiomarkers: backendMappedCount,
+        unmappedBiomarkers: unmappedCount,
+        totalProcessed: exams.length,
+        errors: errorMessages.length,
+    });
+    return {
+        measurements,
+        unknownMeasurements,
+        unknownUnits,
+        unmappedLabKeys,
+        isReportCorrectlyParsed,
+        transformationRulesErrors,
+    };
+}
+//# sourceMappingURL=ohtReportMeasurementsExtractor.service.js.map