gcp-nrces-fhir/lib/resources/Procedure.js

Google cloud healthcare api NRCES FHIR implimenataion

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Procedure = exports.procedureStatusArray = void 0;
const ResourceMai_1 = __importDefault(require("./ResourceMai"));
const html_to_text_1 = require("html-to-text");
exports.procedureStatusArray = [
    "preparation",
    "in-progress",
    "not-done",
    "on-hold",
    "stopped",
    "completed",
    "entered-in-error",
    "unknown",
];
class Procedure extends ResourceMai_1.default {
    constructor() {
        super(...arguments);
        this.statusArray = () => {
            return exports.procedureStatusArray.map((el) => el);
        };
    }
    toHtml() {
        return __awaiter(this, void 0, void 0, function* () {
            throw new Error("Method not implemented.");
        });
    }
    getFHIR(options) {
        const getText = () => {
            let ret = "";
            if (options.text == "" || options.text == undefined) {
                return "";
            }
            if (options.primaryOperator) {
                ret += `
        <table data-pdfmake="{'widths':['33%%','33%','33%%']}"> 
          <tr>
            <td>
              Primary Operator : ${(options.primaryOperator && options.primaryOperator.display) ||
                    ""}
            </td>
            <td>
              Assistants : ${(options.assistants &&
                    options.assistants.length > 0 &&
                    options.assistants.map((el) => el.display).join(", ")) ||
                    ""}
            </td>
            <td>
              Technicians : ${(options.technicians &&
                    options.technicians.length > 0 &&
                    options.technicians.map((el) => el.display).join(", ")) ||
                    ""}
            </td>
  
          </tr>
          <tr>
              <td>
               Anesthetists : ${(options.anesthetists &&
                    options.anesthetists.length > 0 &&
                    options.anesthetists.map((el) => el.display).join(", ")) ||
                    ""}
            </td>
            <td>
              Asserter : ${(options.asserter && options.asserter.display) || ""}
            </td>
            <td>
               Recorder : ${(options.recorder && options.recorder.display) || ""}
            </td>
  
          </tr>
        </table>
        `;
            }
            ret = `${ret}${options.text}`;
            if (options.outcome) {
                ret = `${ret}<div>Outcome</div>`;
                ret = `${ret}<div>${options.outcome.text}</div>`;
            }
            if (options.followUp) {
                ret = `${ret}<div>Follow Up</div>`;
                options.followUp.forEach((el) => {
                    ret = `${ret} <div>${el}</div>`;
                });
            }
            ret = ret.trim().replace(/\n/g, "");
            return ret;
        };
        options.code = {
            coding: options.code.coding,
            text: (0, html_to_text_1.htmlToText)(options.text),
        };
        const body = {
            resourceType: "Procedure",
            id: options.id || undefined,
            meta: {
                profile: [
                    "https://nrces.in/ndhm/fhir/r4/StructureDefinition/Procedure",
                ],
            },
            text: {
                status: "generated",
                div: getText(),
            },
            status: options.status,
            code: options.code,
            subject: { reference: `Patient/${options.patientID}` },
            performedDateTime: options.procedureDate,
            encounter: {
                reference: `Encounter/${options.encounterId}`,
            },
            note: [{ text: options.text }],
            outcome: options.outcome,
        };
        let performers = [];
        if (options.primaryOperator) {
            performers.push({
                function: {
                    coding: [
                        {
                            system: "http://terminology.hl7.org/CodeSystem/performer-role",
                            code: "primary-Operator",
                            display: "Primary-Operator",
                        },
                    ],
                },
                actor: options.primaryOperator,
            });
        }
        if (options.assistants && options.assistants.length > 0) {
            options.assistants.forEach((el) => {
                performers.push({
                    function: {
                        coding: [
                            {
                                system: "http://terminology.hl7.org/CodeSystem/performer-role",
                                code: "assistant",
                                display: "Assistant",
                            },
                        ],
                    },
                    actor: el,
                });
            });
        }
        if (options.anesthetists && options.anesthetists.length > 0) {
            options.anesthetists.forEach((el) => {
                performers.push({
                    function: {
                        coding: [
                            {
                                system: "http://terminology.hl7.org/CodeSystem/performer-role",
                                code: "anesthetists",
                                display: "Anesthetists",
                            },
                        ],
                    },
                    actor: el,
                });
            });
        }
        if (options.technicians && options.technicians.length > 0) {
            options.technicians.forEach((el) => {
                performers.push({
                    function: {
                        coding: [
                            {
                                system: "http://terminology.hl7.org/CodeSystem/performer-role",
                                code: "technicians",
                                display: "Technicians",
                            },
                        ],
                    },
                    actor: el,
                });
            });
        }
        if (performers.length > 0) {
            body.performer = performers;
        }
        if (options.recorder) {
            body.recorder = options.recorder;
        }
        if (options.asserter) {
            body.asserter = options.asserter;
        }
        if (options.report && options.report.length > 0) {
            body.report = options.report.map((el) => {
                return { reference: `DiagnosticReport/${el}` };
            });
        }
        if (options.followUp) {
            body.followUp = options.followUp.map((el) => {
                return {
                    text: el,
                };
            });
        }
        return body;
    }
    convertFhirToObject(options) {
        let ret = {
            status: options.status,
            text: options.text.div,
            code: options.code,
            patientID: `${options.subject.reference}`.substring(8),
            procedureDate: options.performedDateTime,
            id: options.id,
            encounterId: this.getIdFromReference({
                ref: options.encounter.reference,
                resourceType: "Encounter",
            }),
            note: options.note.map((el) => {
                return el.text;
            }),
        };
        if (options.performer) {
            ret.primaryOperator = options.performer.find((el) => el.function.coding[0].code == "primary-Operator").actor;
            ret.anesthetists = options.performer
                .filter((el) => el.function.coding[0].code == "anesthetists")
                .map((el) => el.actor);
            ret.technicians = options.performer
                .filter((el) => el.function.coding[0].code == "technicians")
                .map((el) => el.actor);
            ret.assistants = options.performer
                .filter((el) => el.function.coding[0].code == "assistant")
                .map((el) => el.actor);
        }
        if (options.followUp) {
            ret.followUp = options.followUp.map((el) => el.text);
        }
        if (options.outcome) {
            ret.outcome = options.outcome;
        }
        if (options.report) {
            ret.report = options.report.map((el) => {
                return this.getIdFromReference({
                    ref: el.reference,
                    resourceType: "DiagnosticReport",
                });
            });
        }
        if (options.asserter) {
            ret.asserter = options.asserter.actor;
        }
        if (options.recorder) {
            ret.recorder = options.recorder.actor;
        }
        return ret;
    }
}
exports.Procedure = Procedure;
//# sourceMappingURL=Procedure.js.map