gcp-nrces-fhir/lib/hcx/CoverageEligibilityResponse.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.CoverageEligibiltyResponse = void 0;
const ResourceMai_1 = __importDefault(require("../resources/ResourceMai"));
const TimeZone_1 = require("../TimeZone");
const CoverageEligibilityRequest_1 = require("./CoverageEligibilityRequest");
const CoverageEligibilityResponcePurpose = [
    "auth-requirements",
    "benefits",
    "discovery",
    "validation",
];
class CoverageEligibiltyResponse extends ResourceMai_1.default {
    toHtml(option) {
        return __awaiter(this, void 0, void 0, function* () {
            let ret = "";
            const body = this.convertFhirToObject(option.body);
            if (option.addResourceType) {
                ret += `<h1>Coverage Eligibility Response</h1>`;
            }
            // Date
            ret += `Date : ${new TimeZone_1.TimeZone().convertTZ(body.createdDate, "Asia/Kolkata", false)} <br/>`;
            // Error
            if (body.error) {
                ret +=
                    body.error &&
                        body.error.length > 0 &&
                        `<h3><b>Error</b> : ${body.error
                            .map((el) => this.codeableConceptToHtml(el))
                            .toString()}</h3>`;
            }
            if (body.status) {
                ret += `<b>Satus</b> : ${body.status}<br/>`;
            }
            if (body.outcome) {
                ret += `<h3><b>Outcome</b> : ${body.outcome}</h3>`;
            }
            // Text
            if (body.text) {
                ret += `<h2>Text</h2>`;
                ret += ` ${body.text}<br/>`;
            }
            ret += `<h2> Object to Text</h2>`;
            // disposition
            if (body.disposition) {
                ret += `<b>Disposition</b> : ${body.disposition} <br/>`;
            }
            // Purpose
            if (body.purpose) {
                ret += `<h3><b>Purpose</b> : ${body.purpose.toString()}</h3>`;
            }
            if (body.insurance) {
                ret += yield new CoverageEligibilityRequest_1.CoverageEligibilityRequest().insuranceToHtml({
                    "val": Array.isArray(body.insurance) ? body.insurance : [body.insurance],
                    "coverage": option.coverages || [],
                    "patient": option.patient,
                    "payerCode": option.payerCode,
                    "payerName": option.payerName
                });
            }
            return ret;
        });
    }
    getFHIR(options) {
        const body = {
            resourceType: "CoverageEligibilityResponse",
            id: options.id || undefined,
            meta: {
                profile: options.hcx == "nhcx"
                    ? [
                        "https://nrces.in/ndhm/fhir/r4/StructureDefinition/CoverageEligibilityResponse",
                    ]
                    : [
                        "https://ig.hcxprotocol.io/v0.7.1/StructureDefinition-CoverageEligibilityResponse.html",
                    ],
            },
            language: "en",
            text: {
                status: "generated",
                div: options.text,
            },
            status: options.status,
            purpose: options.purpose,
            patient: options.patient && {
                "reference": options.patient.resource && options.patient.id && `Patient/${options.patient.id}`,
                "display": options.patient.display,
                "identifier": options.patient.identifier,
                "type": options.patient.type
            },
            created: options.createdDate,
            requestor: options.requestor && {
                "reference": options.requestor.resource && options.requestor.id && `${options.requestor.resource}/${options.patient.id}`,
                "display": options.requestor.display,
                "identifier": options.requestor.identifier,
                "type": options.requestor.type
            },
            request: options.request && {
                "reference": options.request.resource && options.request.id && `CoverageEligibilityRequest/${options.patient.id}`,
                "display": options.request.display,
                "identifier": options.request.identifier,
                "type": options.request.type
            },
            outcome: options.outcome,
            disposition: options.disposition,
            insurer: options.insurer && {
                "reference": options.insurer.resource && options.insurer.id && `Organization/${options.patient.id}`,
                "display": options.insurer.display,
                "identifier": options.insurer.identifier,
                "type": options.insurer.type
            },
            insurance: options.insurance,
            error: options.error,
            identifier: options.identifiers,
        };
        return body;
    }
    convertFhirToObject(options) {
        const ret = {
            id: options.id,
            text: (options.text && options.text.div) || "",
            status: options.status,
            purpose: options.purpose,
            patient: options.patient && this.getFromMultResource({
                "reference": options.patient.reference,
                "display": options.patient.display,
                "type": options.patient.type,
                "identifier": options.patient.identifier
            }),
            createdDate: options.created,
            request: options.request && this.getFromMultResource({
                "reference": options.request.reference,
                "display": options.request.display,
                "type": options.request.type,
                "identifier": options.request.identifier
            }),
            outcome: options.outcome,
            insurer: options.insurer && this.getFromMultResource({
                "reference": options.insurer.reference,
                "display": options.insurer.display,
                "type": options.insurer.type,
                "identifier": options.insurer.identifier
            }),
            insurance: options.insurance,
            error: options.error,
            identifiers: options.identifier,
            requestor: options.requestor && this.getFromMultResource({
                "reference": options.requestor.reference,
                "display": options.requestor.display,
                "type": options.requestor.type,
                "identifier": options.requestor.identifier
            }),
            resourceType: "CoverageEligibilityResponse"
        };
        if (options.disposition) {
            ret.disposition = options.disposition;
        }
        return ret;
    }
}
exports.CoverageEligibiltyResponse = CoverageEligibiltyResponse;
//# sourceMappingURL=CoverageEligibilityResponse.js.map