@openhealth/oht-custom-parser-lib 0.1.11 → 0.1.12

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { postDataImportFileUploadToCore, makeApiCallWithRetry, parseErrorObj } from './service/reportCreator.service';
+export { parseExternalPatientId, parseGender, isPatientAgeValid, handleRejection, queryFileUploadsWithFilters, postFileUploadSetStatus } from './service/auxiliaryFunctions.service';
+export { ohtMeasurementsExtractor, checkValueForPlausibleValues, extractReferenceRanges, extractReferenceAnnotation, parseExamValue, getRangeFromPositionAndRegex, extractUnit, extractValueFromGreaterLowerThan } from './service/ohtMeasurementsExtractor.service';
+export { getSlackFileIssueNotificationMessage, sendMessageToSlack, aggregateMessages } from './service/slackMessages.service';
+export { LabToOhtContract, LabToOhtMapper, UnknownMeasurementExtraction, ReferenceAsAnnotation, UnitExtraction, RangeExtraction, RangeExtractionResponse, ValueExtraction, unitSynonyms, } from './types/custom-parser.types';
+export { AcfBiomarkerRangeAnnotationCheck, AcfBiomarkerGenericDisclaimerLogic, ManualCheck, BiomarkerCompatibility, ReferenceRangeType, AcfReferenceRange, VisualRange, NameAlias, AlternativeUnit, BiomarkerAcf, Biomarker, PipelineStep, DigitizationStatus, MeasurementValueComparator, BiomarkerValueType, DataImportFileUploadStatus, Sex, Digitization, PatientInfo, UnknownMeasurement, Measurement, DataImportFileUpload, MessagePayload, SignedUpload, ReportStyleConfig, LanguageCode, BiomarkerCustomisation, PartnerCustomPanel, ReportDisplaySettings, ReportCustomisation, OHTPartner, } from './types/oht.types';
+export { SlackMessage } from './types/slackMessages.types';
+export { extractValue, isBiomarkerValueNumerical, isBiomarkerExternalNoVisualRange } from './util-ts/dataUtils';
+export { readFileFromBucket, uploadFileBufferToGCS } from './util-ts/googleStorageUtils';
+export { default as pinoLogger } from './util-ts/pinoLogger';
+export { getGreaterThanPatterns, getLowerThanPatterns } from './util-ts/regexUtils';

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLowerThanPatterns = exports.getGreaterThanPatterns = exports.pinoLogger = exports.uploadFileBufferToGCS = exports.readFileFromBucket = exports.isBiomarkerExternalNoVisualRange = exports.isBiomarkerValueNumerical = exports.extractValue = exports.Sex = exports.DataImportFileUploadStatus = exports.BiomarkerValueType = exports.MeasurementValueComparator = exports.DigitizationStatus = exports.PipelineStep = exports.ReferenceRangeType = exports.BiomarkerCompatibility = exports.ManualCheck = exports.AcfBiomarkerGenericDisclaimerLogic = exports.AcfBiomarkerRangeAnnotationCheck = exports.unitSynonyms = exports.aggregateMessages = exports.sendMessageToSlack = exports.getSlackFileIssueNotificationMessage = exports.extractValueFromGreaterLowerThan = exports.extractUnit = exports.getRangeFromPositionAndRegex = exports.parseExamValue = exports.extractReferenceAnnotation = exports.extractReferenceRanges = exports.checkValueForPlausibleValues = exports.ohtMeasurementsExtractor = exports.postFileUploadSetStatus = exports.queryFileUploadsWithFilters = exports.handleRejection = exports.isPatientAgeValid = exports.parseGender = exports.parseExternalPatientId = exports.parseErrorObj = exports.makeApiCallWithRetry = exports.postDataImportFileUploadToCore = void 0;
+// ### SERVICES ###
+var reportCreator_service_1 = require("./service/reportCreator.service");
+Object.defineProperty(exports, "postDataImportFileUploadToCore", { enumerable: true, get: function () { return reportCreator_service_1.postDataImportFileUploadToCore; } });
+Object.defineProperty(exports, "makeApiCallWithRetry", { enumerable: true, get: function () { return reportCreator_service_1.makeApiCallWithRetry; } });
+Object.defineProperty(exports, "parseErrorObj", { enumerable: true, get: function () { return reportCreator_service_1.parseErrorObj; } });
+var auxiliaryFunctions_service_1 = require("./service/auxiliaryFunctions.service");
+Object.defineProperty(exports, "parseExternalPatientId", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.parseExternalPatientId; } });
+Object.defineProperty(exports, "parseGender", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.parseGender; } });
+Object.defineProperty(exports, "isPatientAgeValid", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.isPatientAgeValid; } });
+Object.defineProperty(exports, "handleRejection", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.handleRejection; } });
+Object.defineProperty(exports, "queryFileUploadsWithFilters", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.queryFileUploadsWithFilters; } });
+Object.defineProperty(exports, "postFileUploadSetStatus", { enumerable: true, get: function () { return auxiliaryFunctions_service_1.postFileUploadSetStatus; } });
+var ohtMeasurementsExtractor_service_1 = require("./service/ohtMeasurementsExtractor.service");
+Object.defineProperty(exports, "ohtMeasurementsExtractor", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.ohtMeasurementsExtractor; } });
+Object.defineProperty(exports, "checkValueForPlausibleValues", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.checkValueForPlausibleValues; } });
+Object.defineProperty(exports, "extractReferenceRanges", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.extractReferenceRanges; } });
+Object.defineProperty(exports, "extractReferenceAnnotation", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.extractReferenceAnnotation; } });
+Object.defineProperty(exports, "parseExamValue", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.parseExamValue; } });
+Object.defineProperty(exports, "getRangeFromPositionAndRegex", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.getRangeFromPositionAndRegex; } });
+Object.defineProperty(exports, "extractUnit", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.extractUnit; } });
+Object.defineProperty(exports, "extractValueFromGreaterLowerThan", { enumerable: true, get: function () { return ohtMeasurementsExtractor_service_1.extractValueFromGreaterLowerThan; } });
+var slackMessages_service_1 = require("./service/slackMessages.service");
+Object.defineProperty(exports, "getSlackFileIssueNotificationMessage", { enumerable: true, get: function () { return slackMessages_service_1.getSlackFileIssueNotificationMessage; } });
+Object.defineProperty(exports, "sendMessageToSlack", { enumerable: true, get: function () { return slackMessages_service_1.sendMessageToSlack; } });
+Object.defineProperty(exports, "aggregateMessages", { enumerable: true, get: function () { return slackMessages_service_1.aggregateMessages; } });
+// ### TYPES ###
+var custom_parser_types_1 = require("./types/custom-parser.types");
+Object.defineProperty(exports, "unitSynonyms", { enumerable: true, get: function () { return custom_parser_types_1.unitSynonyms; } });
+var oht_types_1 = require("./types/oht.types");
+Object.defineProperty(exports, "AcfBiomarkerRangeAnnotationCheck", { enumerable: true, get: function () { return oht_types_1.AcfBiomarkerRangeAnnotationCheck; } });
+Object.defineProperty(exports, "AcfBiomarkerGenericDisclaimerLogic", { enumerable: true, get: function () { return oht_types_1.AcfBiomarkerGenericDisclaimerLogic; } });
+Object.defineProperty(exports, "ManualCheck", { enumerable: true, get: function () { return oht_types_1.ManualCheck; } });
+Object.defineProperty(exports, "BiomarkerCompatibility", { enumerable: true, get: function () { return oht_types_1.BiomarkerCompatibility; } });
+Object.defineProperty(exports, "ReferenceRangeType", { enumerable: true, get: function () { return oht_types_1.ReferenceRangeType; } });
+Object.defineProperty(exports, "PipelineStep", { enumerable: true, get: function () { return oht_types_1.PipelineStep; } });
+Object.defineProperty(exports, "DigitizationStatus", { enumerable: true, get: function () { return oht_types_1.DigitizationStatus; } });
+Object.defineProperty(exports, "MeasurementValueComparator", { enumerable: true, get: function () { return oht_types_1.MeasurementValueComparator; } });
+Object.defineProperty(exports, "BiomarkerValueType", { enumerable: true, get: function () { return oht_types_1.BiomarkerValueType; } });
+Object.defineProperty(exports, "DataImportFileUploadStatus", { enumerable: true, get: function () { return oht_types_1.DataImportFileUploadStatus; } });
+Object.defineProperty(exports, "Sex", { enumerable: true, get: function () { return oht_types_1.Sex; } });
+// ### UTIL-TS ###
+var dataUtils_1 = require("./util-ts/dataUtils");
+Object.defineProperty(exports, "extractValue", { enumerable: true, get: function () { return dataUtils_1.extractValue; } });
+Object.defineProperty(exports, "isBiomarkerValueNumerical", { enumerable: true, get: function () { return dataUtils_1.isBiomarkerValueNumerical; } });
+Object.defineProperty(exports, "isBiomarkerExternalNoVisualRange", { enumerable: true, get: function () { return dataUtils_1.isBiomarkerExternalNoVisualRange; } });
+var googleStorageUtils_1 = require("./util-ts/googleStorageUtils");
+Object.defineProperty(exports, "readFileFromBucket", { enumerable: true, get: function () { return googleStorageUtils_1.readFileFromBucket; } });
+Object.defineProperty(exports, "uploadFileBufferToGCS", { enumerable: true, get: function () { return googleStorageUtils_1.uploadFileBufferToGCS; } });
+var pinoLogger_1 = require("./util-ts/pinoLogger");
+Object.defineProperty(exports, "pinoLogger", { enumerable: true, get: function () { return __importDefault(pinoLogger_1).default; } });
+var regexUtils_1 = require("./util-ts/regexUtils");
+Object.defineProperty(exports, "getGreaterThanPatterns", { enumerable: true, get: function () { return regexUtils_1.getGreaterThanPatterns; } });
+Object.defineProperty(exports, "getLowerThanPatterns", { enumerable: true, get: function () { return regexUtils_1.getLowerThanPatterns; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;;AAAA,mBAAmB;AACnB,yEAEyC;AADvC,uIAAA,8BAA8B,OAAA;AAAE,6HAAA,oBAAoB,OAAA;AAAE,sHAAA,aAAa,OAAA;AAErE,mFAO8C;AAN5C,oIAAA,sBAAsB,OAAA;AACtB,yHAAA,WAAW,OAAA;AACX,+HAAA,iBAAiB,OAAA;AACjB,6HAAA,eAAe,OAAA;AACf,yIAAA,2BAA2B,OAAA;AAC3B,qIAAA,uBAAuB,OAAA;AAEzB,+FASoD;AARlD,4IAAA,wBAAwB,OAAA;AACxB,gJAAA,4BAA4B,OAAA;AAC5B,0IAAA,sBAAsB,OAAA;AACtB,8IAAA,0BAA0B,OAAA;AAC1B,kIAAA,cAAc,OAAA;AACd,gJAAA,4BAA4B,OAAA;AAC5B,+HAAA,WAAW,OAAA;AACX,oJAAA,gCAAgC,OAAA;AAElC,yEAEyC;AADvC,6IAAA,oCAAoC,OAAA;AAAE,2HAAA,kBAAkB,OAAA;AAAE,0HAAA,iBAAiB,OAAA;AAG7E,gBAAgB;AAChB,mEAUqC;AADnC,mHAAA,YAAY,OAAA;AAEd,+CAgC2B;AA/BzB,6HAAA,gCAAgC,OAAA;AAChC,+HAAA,kCAAkC,OAAA;AAClC,wGAAA,WAAW,OAAA;AACX,mHAAA,sBAAsB,OAAA;AACtB,+GAAA,kBAAkB,OAAA;AAOlB,yGAAA,YAAY,OAAA;AACZ,+GAAA,kBAAkB,OAAA;AAClB,uHAAA,0BAA0B,OAAA;AAC1B,+GAAA,kBAAkB,OAAA;AAClB,uHAAA,0BAA0B,OAAA;AAC1B,gGAAA,GAAG,OAAA;AAkBL,kBAAkB;AAClB,iDAA8G;AAAtG,yGAAA,YAAY,OAAA;AAAE,sHAAA,yBAAyB,OAAA;AAAE,6HAAA,gCAAgC,OAAA;AACjF,mEAAyF;AAAhF,wHAAA,kBAAkB,OAAA;AAAE,2HAAA,qBAAqB,OAAA;AAClD,mDAA2D;AAAnD,yHAAA,OAAO,OAAc;AAC7B,mDAAkF;AAA1E,oHAAA,sBAAsB,OAAA;AAAE,kHAAA,oBAAoB,OAAA"}

package/dist/service/auxiliaryFunctions.service.d.ts

@@ -0,0 +1,19 @@
+import { SlackMessage } from '../types/slackMessages.types';
+import { DataImportFileUpload, DataImportFileUploadStatus, Sex } from "../types/oht.types";
+declare function isPatientAgeValid(documentDate?: Date, patientBirthdate?: Date): boolean;
+declare function parseExternalPatientId(patientExternalId?: string): boolean;
+declare function parseGender(patientGender?: string): {
+    sex: Sex;
+    isGenderCorrectlyParsed: boolean;
+};
+declare function handleRejection(parseType: string, slackMessages: SlackMessage[], type?: string): {
+    rejectedStatus: string;
+    rejectReason: string;
+};
+export interface FileUploadFilter {
+    field: string;
+    search: string;
+}
+declare function queryFileUploadsWithFilters(filters: FileUploadFilter[], ohtCoreApiKey: string): Promise<DataImportFileUpload[]>;
+declare function postFileUploadSetStatus(status: DataImportFileUploadStatus, fileUploadId: string, filename: string, ohtCoreApiKey: string): Promise<DataImportFileUpload>;
+export { parseExternalPatientId, parseGender, isPatientAgeValid, handleRejection, queryFileUploadsWithFilters, postFileUploadSetStatus };

package/dist/service/auxiliaryFunctions.service.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExternalPatientId = parseExternalPatientId;
+exports.parseGender = parseGender;
+exports.isPatientAgeValid = isPatientAgeValid;
+exports.handleRejection = handleRejection;
+exports.queryFileUploadsWithFilters = queryFileUploadsWithFilters;
+exports.postFileUploadSetStatus = postFileUploadSetStatus;
+const moment_1 = __importDefault(require("moment/moment"));
+const reportCreator_service_1 = require("./reportCreator.service");
+const pinoLogger_1 = __importDefault(require("../util-ts/pinoLogger"));
+const oht_types_1 = require("../types/oht.types");
+const logger = (0, pinoLogger_1.default)();
+function isPatientAgeValid(documentDate, patientBirthdate) {
+    if (!patientBirthdate || !documentDate)
+        return false;
+    const patientAge = (0, moment_1.default)(documentDate).diff(patientBirthdate, 'years');
+    return patientAge >= 18 && patientAge <= 130;
+}
+function parseExternalPatientId(patientExternalId) {
+    return patientExternalId !== undefined && patientExternalId.length > 0;
+}
+function parseGender(patientGender) {
+    const gender = patientGender?.toLowerCase();
+    switch (gender) {
+        case 'masculino':
+        case 'male':
+            return { sex: oht_types_1.Sex.MALE, isGenderCorrectlyParsed: true };
+        case 'feminino':
+        case 'female':
+            return { sex: oht_types_1.Sex.FEMALE, isGenderCorrectlyParsed: true };
+        default:
+            return { sex: oht_types_1.Sex.OTHER, isGenderCorrectlyParsed: false };
+    }
+}
+function handleRejection(parseType, slackMessages, type = 'ERROR') {
+    let rejectedStatus = 'REJECTED';
+    let rejectReason = `Could not parse ${parseType}`;
+    slackMessages.push({
+        type: type,
+        message: `File REJECTED, ${parseType} not parsed correctly:`,
+    });
+    return { rejectedStatus, rejectReason };
+}
+async function queryFileUploadsWithFilters(filters, ohtCoreApiKey) {
+    const OHT_CORE_URL = process.env.OHT_CORE_URL;
+    const ohtCoreUrl = `${OHT_CORE_URL}/v1/file-uploads/query`;
+    const queryData = {
+        "filters": [...filters]
+    };
+    const queryResponse = await (0, reportCreator_service_1.makeApiCallWithRetry)('post', ohtCoreUrl, queryData, ohtCoreApiKey);
+    return queryResponse?.data?.items;
+}
+async function postFileUploadSetStatus(status, fileUploadId, filename, ohtCoreApiKey) {
+    const OHT_CORE_URL = process.env.OHT_CORE_URL;
+    const ohtCoreFileUploadSetStatusUrl = `${OHT_CORE_URL}/v1/file-uploads/status/set/${fileUploadId}`;
+    const processingResponse = await (0, reportCreator_service_1.makeApiCallWithRetry)('post', ohtCoreFileUploadSetStatusUrl, { status }, ohtCoreApiKey);
+    logger.info({ resp: processingResponse?.data }, `Resp: POST status: ${status} /file-uploads/${fileUploadId}, filename: ${filename}`);
+    return processingResponse?.data;
+}
+//# sourceMappingURL=auxiliaryFunctions.service.js.map

package/dist/service/auxiliaryFunctions.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auxiliaryFunctions.service.js","sourceRoot":"","sources":["../../service/auxiliaryFunctions.service.ts"],"names":[],"mappings":"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"}

package/dist/service/ohtMeasurementsExtractor.service.d.ts

@@ -0,0 +1,31 @@
+import { LabToOhtContract, LabToOhtMapper, RangeExtraction, RangeExtractionResponse, UnitExtraction, ValueExtraction } from "../types/custom-parser.types";
+import { Biomarker, BiomarkerValueType, Measurement, MeasurementValueComparator, PatientInfo, UnknownMeasurement } from "../types/oht.types";
+declare function extractUnit(unitExtraction: UnitExtraction | undefined, rawData: any, ohtBiomarker: Biomarker): {
+    unit: string;
+    isUnitParsedCorrectly: boolean;
+};
+declare function extractReferenceAnnotation(labToOhtMapper: LabToOhtMapper, rawExam: any, patientInfo: PatientInfo, documentDate?: Date): any;
+declare const getRangeFromPositionAndRegex: (rangeExtraction: RangeExtraction, rawData: any) => {
+    from: number | undefined;
+    to: number | undefined;
+};
+declare function extractReferenceRanges(labToOhtMapper: LabToOhtMapper, rawData: any, patientInfo: PatientInfo, documentDate?: Date): RangeExtractionResponse;
+declare function extractValueFromGreaterLowerThan(value: string): {
+    extractedValue: number | null;
+    extractedValueComparator: MeasurementValueComparator | null;
+    valueParsedCorrectly: boolean;
+};
+declare function parseExamValue(rawExamObj: any, valueExtraction: ValueExtraction | undefined, ohtBiomarker: Biomarker): {
+    valueType: BiomarkerValueType;
+    alphanumericalValue: string | null;
+    numberValue: number | null;
+    valueComparator: MeasurementValueComparator;
+    isValueParsedCorrectly: boolean;
+};
+declare function checkValueForPlausibleValues(labToOhtMapper: LabToOhtMapper, ohtBiomarker: Biomarker, unit: string, value: number, isUnitParsedCorrectly: boolean): boolean;
+declare function ohtMeasurementsExtractor(labToOhtContract: LabToOhtContract, ohtCoreApiKey: string): Promise<{
+    measurements: Measurement[];
+    unknownMeasurements: UnknownMeasurement[];
+    isReportCorrectlyParsed: boolean;
+}>;
+export { ohtMeasurementsExtractor, checkValueForPlausibleValues, extractReferenceRanges, extractReferenceAnnotation, parseExamValue, getRangeFromPositionAndRegex, extractUnit, extractValueFromGreaterLowerThan };

package/dist/service/ohtMeasurementsExtractor.service.js

@@ -0,0 +1,403 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRangeFromPositionAndRegex = void 0;
+exports.ohtMeasurementsExtractor = ohtMeasurementsExtractor;
+exports.checkValueForPlausibleValues = checkValueForPlausibleValues;
+exports.extractReferenceRanges = extractReferenceRanges;
+exports.extractReferenceAnnotation = extractReferenceAnnotation;
+exports.parseExamValue = parseExamValue;
+exports.extractUnit = extractUnit;
+exports.extractValueFromGreaterLowerThan = extractValueFromGreaterLowerThan;
+const custom_parser_types_1 = require("../types/custom-parser.types");
+const dataUtils_1 = require("../util-ts/dataUtils");
+const regexUtils_1 = require("../util-ts/regexUtils");
+const pinoLogger_1 = __importDefault(require("../util-ts/pinoLogger"));
+const reportCreator_service_1 = require("./reportCreator.service");
+const oht_types_1 = require("../types/oht.types");
+const logger = (0, pinoLogger_1.default)();
+const OHT_CORE_URL = process.env.OHT_CORE_URL;
+let filename = '';
+function extractUnit(unitExtraction, rawData, ohtBiomarker) {
+    if (!(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)) {
+        return { unit: "None", isUnitParsedCorrectly: true };
+    }
+    // If there's a function to extract the unit, use it
+    if (unitExtraction && unitExtraction?.extractionFunc) {
+        const extractedUnitExtraction = unitExtraction.extractionFunc(rawData);
+        return { unit: extractedUnitExtraction ?? '', isUnitParsedCorrectly: !!extractedUnitExtraction };
+    }
+    const unit = (0, dataUtils_1.extractValue)(rawData, unitExtraction?.unitPosition);
+    let unitLowerCase = unit?.toLowerCase();
+    unitLowerCase = unitLowerCase?.replaceAll(/ /g, '') ?? '';
+    const standardUnit = ohtBiomarker.acf.standardUnit;
+    const allBmOhtUnits = [
+        standardUnit?.toLowerCase(),
+        ...ohtBiomarker.acf?.alternativeUnits
+            ?.map((bmAlternative) => bmAlternative.name.toLowerCase()) ?? []
+    ];
+    // First test if the biomarker has the unit explicit in the 'unity' field
+    const allUnitContainsJsonUnit = allBmOhtUnits.includes(unitLowerCase);
+    if (unitLowerCase?.length > 0 && allUnitContainsJsonUnit) {
+        return {
+            unit: unit?.replaceAll(/ /g, ''),
+            isUnitParsedCorrectly: true
+        };
+    }
+    // Check if there are any Synonym configured
+    const allUnitContainsJsonUnitSynonyms = allBmOhtUnits.includes(custom_parser_types_1.unitSynonyms[unitLowerCase]?.toLowerCase());
+    if (unitLowerCase?.length > 0 && allUnitContainsJsonUnitSynonyms) {
+        return { unit: custom_parser_types_1.unitSynonyms[unitLowerCase], isUnitParsedCorrectly: true };
+    }
+    if (unitExtraction?.predefinedUnit) {
+        const allUnitContainsUnitFromOhtMap = allBmOhtUnits.includes(unitExtraction.predefinedUnit.toLowerCase());
+        // If the 'unity' field is not present, try to get the unit from the biomarker map
+        return { unit: unitExtraction?.predefinedUnit, isUnitParsedCorrectly: allUnitContainsUnitFromOhtMap };
+    }
+    if (unitExtraction?.extractionRegex) {
+        const regex = new RegExp(unitExtraction.extractionRegex);
+        const match = rawData.match(regex);
+        const allUnitContainsUnitMatch = allBmOhtUnits.includes(match?.[1]?.toLowerCase());
+        if (match?.[1] && allUnitContainsUnitMatch) {
+            return { unit: match?.[1], isUnitParsedCorrectly: true };
+        }
+    }
+    return { unit: '', isUnitParsedCorrectly: false };
+}
+function extractReferenceAnnotation(labToOhtMapper, rawExam, patientInfo, documentDate) {
+    const annotationExtractionFunc = labToOhtMapper?.referenceAsAnnotation?.extractionFunc;
+    if (annotationExtractionFunc) {
+        return annotationExtractionFunc(rawExam, labToOhtMapper, patientInfo, documentDate);
+    }
+    else {
+        const extractedReference = (0, dataUtils_1.extractValue)(rawExam, labToOhtMapper?.referenceAsAnnotation?.position);
+        const reference = extractedReference?.valor?.trim();
+        return reference?.length > 0 ? reference : extractedReference?.val?.trim();
+    }
+}
+const getRangeFromPositionAndRegex = (rangeExtraction, rawData) => {
+    const extractionRegex = rangeExtraction.extractionRegex;
+    const rangePosition = rangeExtraction.rangePosition;
+    const regex = typeof extractionRegex === 'string' ? new RegExp(extractionRegex) : extractionRegex;
+    const value = (0, dataUtils_1.extractValue)(rawData, rangePosition);
+    if (regex) {
+        let match = regex.exec(value);
+        if (match) {
+            // Check length of match
+            // If length is 2, it means that the range is a single value
+            // If length is 3, it means that the range has two values
+            const inferior = parseFloat(match[1].replaceAll('.', '').replaceAll(',', '.'));
+            const superior = parseFloat(match[match.length - 1].replaceAll('.', '').replaceAll(',', '.'));
+            return {
+                from: inferior,
+                to: superior,
+            };
+        }
+    }
+    return {
+        from: undefined,
+        to: undefined,
+    };
+};
+exports.getRangeFromPositionAndRegex = getRangeFromPositionAndRegex;
+function extractReferenceRanges(labToOhtMapper, rawData, patientInfo, documentDate) {
+    // WIP
+    const nullRangeNotParsedCorrectly = { from: null, to: null, isRangeParsedCorrectly: false };
+    const nullRangeParsedCorrectly = { from: null, to: null, isRangeParsedCorrectly: true };
+    // if internalRange return null, but is parsed correctly
+    if (labToOhtMapper?.rangeExtraction?.useInternalRange) {
+        //logger.info(`Using internalRange for biomarker ${ohtBiomarkerMap.ohtBmId}, key: ${ohtBiomarkerMap.labiKey}, filename: ${filename}`)
+        return nullRangeParsedCorrectly;
+    } // if internalRange return null
+    // Each lab has a "default" range structure.
+    // We need a default extraction function for each lab
+    // Here we receive from the custom parser a function inside the RangeExtraction object
+    let rangeExtractionResult = labToOhtMapper?.rangeExtraction?.defaultRangeExtractionFunc
+        ? labToOhtMapper.rangeExtraction.defaultRangeExtractionFunc(labToOhtMapper, rawData)
+        : nullRangeNotParsedCorrectly;
+    if (rangeExtractionResult.isRangeParsedCorrectly) {
+        return rangeExtractionResult;
+    }
+    // if there's a function to extract the range, use it
+    if (labToOhtMapper.rangeExtraction?.extractionFunc) {
+        rangeExtractionResult = labToOhtMapper.rangeExtraction.extractionFunc(rawData, labToOhtMapper, patientInfo, documentDate);
+        if (rangeExtractionResult.isRangeParsedCorrectly) {
+            return rangeExtractionResult;
+        }
+    }
+    // if there's a position and regex to extract the range, use it
+    if (labToOhtMapper.rangeExtraction?.extractionRegex) {
+        let { from, to, } = getRangeFromPositionAndRegex(labToOhtMapper.rangeExtraction, rawData);
+        if (labToOhtMapper.rangeExtraction?.rangePosition
+            && (labToOhtMapper.rangeExtraction?.extractionRegex)
+            && from != null // if from is 0 is valid, but fails the if condition because it's falsy
+            && to != null // same as from
+        ) {
+            const isRangeParsedCorrectly = !Number.isNaN(from) && !Number.isNaN(to);
+            return { from, to, isRangeParsedCorrectly };
+        }
+    }
+    return nullRangeNotParsedCorrectly;
+}
+function extractValueFromGreaterLowerThan(value) {
+    // Checks first if any greater than pattern is present
+    const greaterThanPatterns = (0, regexUtils_1.getGreaterThanPatterns)();
+    const lowerThanPatterns = (0, regexUtils_1.getLowerThanPatterns)();
+    value = value.toLowerCase();
+    for (const pattern of greaterThanPatterns) {
+        const match = pattern.exec(value);
+        if (match) {
+            const value = parseFloat(match?.[1].replaceAll(',', '.'));
+            const valueComparator = oht_types_1.MeasurementValueComparator.GREATER_THAN;
+            return {
+                extractedValue: value,
+                extractedValueComparator: valueComparator,
+                valueParsedCorrectly: !Number.isNaN(value)
+            };
+        }
+    }
+    // Checks if any lower than pattern is present
+    for (const pattern of lowerThanPatterns) {
+        const match = pattern.exec(value);
+        if (match) {
+            const value = parseFloat(match?.[1].replaceAll(',', '.'));
+            const valueComparator = oht_types_1.MeasurementValueComparator.LESS_THAN;
+            return {
+                extractedValue: value,
+                extractedValueComparator: valueComparator,
+                valueParsedCorrectly: !Number.isNaN(value)
+            };
+        }
+    }
+    // If no pattern is found, return the value as is and the comparator as EQUAL and isValueParsedCorrectly as false
+    return { extractedValue: null, extractedValueComparator: null, valueParsedCorrectly: false };
+}
+function parseExamValue(rawExamObj, valueExtraction, ohtBiomarker) {
+    let value = (0, dataUtils_1.extractValue)(rawExamObj, valueExtraction?.valuePosition);
+    value = valueExtraction.defaultValueExtractionFunc ? valueExtraction.defaultValueExtractionFunc(value) : value;
+    // If is parse float nan, the value is alphanumerical
+    const valueType = (0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)
+        ? oht_types_1.BiomarkerValueType.NUMERICAL
+        : oht_types_1.BiomarkerValueType.ALPHANUMERICAL;
+    let alphanumericalValue = Number.isNaN(parseFloat(value))
+        ? value
+        : null;
+    if (valueType === oht_types_1.BiomarkerValueType.ALPHANUMERICAL
+        && !Number.isNaN(parseFloat(value))) {
+        // convert numberValue to string
+        alphanumericalValue = value.toString();
+    }
+    if (valueType === oht_types_1.BiomarkerValueType.NUMERICAL
+        && Number.isNaN(parseFloat(value))) {
+        // convert numberValue to string
+        const { extractedValue, extractedValueComparator, valueParsedCorrectly } = extractValueFromGreaterLowerThan(value);
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: extractedValue,
+            valueComparator: extractedValueComparator ?? oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: valueParsedCorrectly
+        };
+    }
+    if (valueType === 'NUMERICAL') {
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: parseFloat(value),
+            valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: !Number.isNaN(parseFloat(value))
+        };
+    }
+    if (valueType === 'ALPHANUMERICAL') {
+        return {
+            valueType,
+            alphanumericalValue,
+            numberValue: parseFloat(value),
+            valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+            isValueParsedCorrectly: alphanumericalValue !== null
+        };
+    }
+    return {
+        valueType,
+        alphanumericalValue,
+        numberValue: null,
+        valueComparator: oht_types_1.MeasurementValueComparator.EQUAL,
+        isValueParsedCorrectly: false
+    };
+}
+function checkValueForPlausibleValues(labToOhtMapper, ohtBiomarker, unit, value, isUnitParsedCorrectly) {
+    if (!(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) && isUnitParsedCorrectly) {
+        return true;
+    }
+    const standardUnit = ohtBiomarker.acf.standardUnit;
+    const plausibleLowerValue = ohtBiomarker.acf.plausibilityRangeCheck;
+    const plausibleUpperValue = ohtBiomarker.acf.plausibilityRangeCheckHigh;
+    const biomarkerStdValueDecimals = ohtBiomarker.acf?.displayDecimals ?? 2;
+    if (unit !== standardUnit) {
+        const alternativeUnit = (Array.isArray(ohtBiomarker.acf?.alternativeUnits)
+            ? ohtBiomarker.acf?.alternativeUnits
+            : [])?.find((altUnit) => altUnit.name === unit);
+        if (alternativeUnit) {
+            const conversionFactor = alternativeUnit.conversionFactor;
+            value = +(value * conversionFactor).toFixed(biomarkerStdValueDecimals);
+        }
+    }
+    const isPlausibleValue = value >= plausibleLowerValue && value <= plausibleUpperValue;
+    // Log if the value is not plausible
+    if (!isPlausibleValue) {
+        logger.warn({ labToOhtMapper, value, standardUnit, plausibleLowerValue, plausibleUpperValue, filename }, `Value "${value} ${standardUnit}" not plausible "${plausibleLowerValue} to ${plausibleUpperValue}" for "${labToOhtMapper.ohtBmId}" | "${labToOhtMapper.labKey}", filename: ${filename}`);
+    }
+    return isPlausibleValue;
+}
+async function ohtMeasurementsExtractor(labToOhtContract, ohtCoreApiKey) {
+    filename = labToOhtContract.sourceFilename;
+    const measurements = [];
+    const unknownMeasurements = [];
+    let isReportCorrectlyParsed = true;
+    const allPossibleOHTBmIds = [];
+    [
+        ...Object.values(labToOhtContract.labToOhtList)
+    ].forEach(labToOhtMapper => {
+        if (labToOhtMapper.ohtBmId) {
+            allPossibleOHTBmIds.push(labToOhtMapper.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, reportCreator_service_1.makeApiCallWithRetry)('post', `${OHT_CORE_URL}/v1/biomarker/biomarkers`, requestData, ohtCoreApiKey);
+    for (const labToOhtMapper of labToOhtContract.labToOhtList) {
+        if (!labToOhtMapper.rawExam) {
+            labToOhtContract.slackMessages.push({
+                type: 'ERROR',
+                message: `Missing rawExam for labKey: ${labToOhtMapper.labKey} filename: ${filename}`,
+            });
+            continue;
+        }
+        const rawExamObj = JSON.parse(labToOhtMapper.rawExam);
+        if (labToOhtMapper?.ohtBmId) {
+            // if BM is already in measurements, continue to the next one
+            if (measurements.some(measurement => measurement.biomarkerId === labToOhtMapper.ohtBmId)) {
+                logger.warn({ labToOhtMapper }, `Biomarker already in measurements array, should investigate, filename: ${filename}`);
+                labToOhtContract.slackMessages.push({
+                    type: 'ERROR',
+                    message: `Biomarkers Duplicated keys: [PLACEHOLDER]`,
+                    item: `bmId:${labToOhtMapper.ohtBmId}, labKey:${labToOhtMapper.labKey}`
+                });
+                continue;
+            }
+            const ohtBiomarker = biomarkers?.data?.items.find((bm) => bm.id === labToOhtMapper.ohtBmId);
+            const { unit, isUnitParsedCorrectly } = extractUnit(labToOhtMapper.unitExtraction, rawExamObj, ohtBiomarker);
+            if (!isUnitParsedCorrectly) {
+                logger.warn({ labToOhtMapper }, `Unit not extracted correctly for "${labToOhtMapper.ohtBmId}|${labToOhtMapper.labKey}", filename: ${filename}`);
+                labToOhtContract.slackMessages.push({
+                    type: 'ERROR',
+                    message: `Unit not extracted correctly for keys: [PLACEHOLDER]`,
+                    item: `bmId:${labToOhtMapper.ohtBmId}, labKey:${labToOhtMapper.labKey}`
+                });
+            }
+            isReportCorrectlyParsed = isReportCorrectlyParsed && isUnitParsedCorrectly;
+            let { valueType, alphanumericalValue, numberValue, valueComparator, isValueParsedCorrectly } = parseExamValue(rawExamObj, labToOhtMapper.valueExtraction, ohtBiomarker);
+            if (!isValueParsedCorrectly) {
+                logger.warn({ labToOhtMapper }, `Value not extracted correctly for "${labToOhtMapper.ohtBmId}|${labToOhtMapper.labKey}", filename: ${filename}`);
+                labToOhtContract.slackMessages.push({
+                    type: 'ERROR',
+                    message: `Value not extracted correctly for keys: [PLACEHOLDER]`,
+                    item: `bmId:${labToOhtMapper.ohtBmId}, labKey:${labToOhtMapper.labKey}`
+                });
+            }
+            if (valueType === 'NUMERICAL') {
+                const isPlausibleValue = numberValue !== null && checkValueForPlausibleValues(labToOhtMapper, ohtBiomarker, unit, numberValue, isUnitParsedCorrectly);
+                if (!isPlausibleValue) {
+                    logger.warn({ labToOhtMapper }, `Value [${numberValue} ${unit}] is not plausible for "${labToOhtMapper.ohtBmId}|${labToOhtMapper.labKey}", filename: ${filename}`);
+                    labToOhtContract.slackMessages.push({
+                        type: 'ERROR',
+                        message: `Value is not plausible for: [PLACEHOLDER]`,
+                        item: `bmId:${labToOhtMapper.ohtBmId}, labKey:${labToOhtMapper.labKey}, value: ${numberValue}${unit}`
+                    });
+                }
+                isReportCorrectlyParsed = isReportCorrectlyParsed && isPlausibleValue;
+            }
+            isReportCorrectlyParsed = isReportCorrectlyParsed && isValueParsedCorrectly;
+            let from = null, to = null;
+            let isRangeParsedCorrectly = true;
+            if ((0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker)) {
+                const extractedRange = extractReferenceRanges(labToOhtMapper, rawExamObj, labToOhtContract.patientInfo, labToOhtContract.documentDate);
+                from = extractedRange.from ?? null;
+                to = extractedRange.to ?? null;
+                isRangeParsedCorrectly = extractedRange.isRangeParsedCorrectly;
+                if (!isRangeParsedCorrectly) {
+                    logger.warn({ labToOhtMapper }, `Range not extracted correctly for "${labToOhtMapper.ohtBmId}|${labToOhtMapper.labKey}", filename: ${filename}`);
+                    labToOhtContract.slackMessages.push({
+                        type: 'ERROR',
+                        message: `Range not extracted correctly for keys: [PLACEHOLDER]`,
+                        item: `bmId:${labToOhtMapper.ohtBmId}, labKey:${labToOhtMapper.labKey}`
+                    });
+                }
+                isReportCorrectlyParsed = isReportCorrectlyParsed && isRangeParsedCorrectly;
+            }
+            let extractedAnnotation;
+            if (labToOhtMapper?.referenceAsAnnotation?.use) {
+                extractedAnnotation = extractReferenceAnnotation(labToOhtMapper, rawExamObj, labToOhtContract.patientInfo, labToOhtContract.documentDate);
+            }
+            const material = (0, dataUtils_1.extractValue)(rawExamObj, labToOhtMapper.material);
+            const method = (0, dataUtils_1.extractValue)(rawExamObj, labToOhtMapper.method);
+            let alphaValue = !(0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) && alphanumericalValue
+                ? alphanumericalValue.trim()
+                : null;
+            // adding unit for alphanumerical values as number.
+            if (!Number.isNaN(parseFloat(alphaValue))) {
+                let originalUnit = (0, dataUtils_1.extractValue)(rawExamObj, labToOhtMapper?.unitExtraction?.unitPosition);
+                originalUnit = originalUnit?.replaceAll(/ /g, '') ?? '';
+                alphaValue = alphaValue && unit?.length > 0 ? `${alphaValue} ${originalUnit}`.trim() : alphaValue;
+            }
+            let measurement = {
+                biomarkerId: ohtBiomarker.id,
+                valueType,
+                value: (0, dataUtils_1.isBiomarkerValueNumerical)(ohtBiomarker) ? numberValue : null,
+                alphanumericValue: alphaValue,
+                rangeAnnotation: labToOhtMapper?.referenceAsAnnotation?.use && extractedAnnotation ? extractedAnnotation : null,
+                showVisualisationIfAnnotated: !!labToOhtMapper?.referenceAsAnnotation?.use,
+                comparator: valueComparator ?? oht_types_1.MeasurementValueComparator.EQUAL,
+                minNormalValue: from,
+                maxNormalValue: to,
+                unit,
+                material,
+                method,
+                isDigitalizationApproved: true,
+            };
+            measurements.push(measurement);
+        }
+        else {
+            logger.warn(`Created an ungroupedBiomarker for id: ${labToOhtMapper.labKey}, filename: ${filename}`);
+            labToOhtContract.slackMessages.push({
+                type: 'ERROR',
+                message: `Created ungroupedBiomarkers for: [PLACEHOLDER]`,
+                item: `labKey: ${labToOhtMapper.labKey}`
+            });
+            const biomarkerName = labToOhtMapper?.unknownMeasurement?.biomarkerName ?? '';
+            const value = labToOhtMapper?.unknownMeasurement?.value ?? '';
+            const unit = labToOhtMapper?.unknownMeasurement?.unit ?? '';
+            const annotation = labToOhtMapper?.unknownMeasurement?.annotation ?? '';
+            const unknownMeasurement = {
+                biomarkerName: biomarkerName,
+                value: value,
+                unit: unit,
+                annotation: annotation
+            };
+            unknownMeasurements.push(unknownMeasurement);
+        }
+    }
+    return {
+        measurements,
+        unknownMeasurements,
+        isReportCorrectlyParsed
+    };
+}
+//# sourceMappingURL=ohtMeasurementsExtractor.service.js.map