gcp-nrces-fhir/lib/hcx/Coverage.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.Coverage = void 0;
const ResourceMai_1 = __importDefault(require("../resources/ResourceMai"));
const CoverageStatus = [
    "active",
    "cancelled",
    "draft",
    "entered-in-error",
];
class Coverage extends ResourceMai_1.default {
    toHtml(option) {
        return __awaiter(this, void 0, void 0, function* () {
            const body = this.convertFhirToObject(option.body);
            let ret = yield this.coverageToHtml(option);
            return ret;
        });
    }
    getFHIR(options) {
        var _a;
        const getText = () => {
            let ret = "";
            ret = options.text;
            return ret;
        };
        const body = {
            id: options.id,
            resourceType: "Coverage",
            type: options.type,
            identifier: options.identifier,
            meta: {
                profile: options.hcx == "nhcx"
                    ? ["https://nrces.in/ndhm/fhir/r4/StructureDefinition/Coverage"]
                    : [
                        "https://ig.hcxprotocol.io/v0.7.1/StructureDefinition-Coverage.html",
                    ],
            },
            text: {
                status: "generated",
                div: getText(),
            },
            status: options.status,
            policyHolder: options.policyHolder
                ? {
                    reference: `${options.policyHolder.resource}/${options.policyHolder.id}`,
                }
                : undefined,
            subscriber: options.subscriber
                ? {
                    reference: `${options.subscriber.resource}/${options.subscriber.id}`,
                }
                : undefined,
            subscriberId: options.subscriberId,
            beneficiary: { reference: `Patient/${options.beneficiaryPatientId}` },
            dependent: options.dependent,
            relationship: options.relationship,
            payor: options.payor && options.payor.map((el) => {
                let ret = {};
                if (el.resource) {
                    ret.reference = `${el.resource}/${el.id}`;
                }
                if (el.identifier) {
                    ret.identifier = el.identifier;
                }
                if (el.type) {
                    ret.type = el.type;
                }
                if (el.display) {
                    ret.display = el.display;
                }
                return ret;
            }),
            period: options.period,
            insurer: options.insurerOrganizationId
                ? { reference: `Organization/${options.insurerOrganizationId}` }
                : undefined,
            class: options.class,
            order: options.order,
            network: options.network,
            costToBeneficiary: options.costToBeneficiary,
            subrogation: options.subrogation,
            contract: (_a = options.contractId) === null || _a === void 0 ? void 0 : _a.map((el) => {
                return { reference: `Contract/${options.contractId}` };
            }),
            insurancePlan: options.insurancePlanId
                ? { reference: `InsurancePlan/${options.insurancePlanId}` }
                : undefined,
        };
        return body;
    }
    convertFhirToObject(options) {
        const ret = {
            id: options.id,
            identifier: options.identifier,
            text: options.text && options.text.div,
            status: options.status,
            beneficiaryPatientId: options.beneficiary && this.getIdFromReference({
                ref: options.beneficiary.reference,
                resourceType: "Patient",
            }),
            payor: options.payor && options.payor.map((el) => {
                const ret = this.getFromMultResource(el);
                return ret;
            }),
            resourceType: "Coverage"
        };
        if (options.type) {
            ret.type = options.type;
        }
        if (options.policyHolder) {
            ret.policyHolder = this.getFromMultResource(options.policyHolder);
        }
        if (options.subscriber) {
            ret.subscriber = this.getFromMultResource(options.subscriber);
        }
        if (options.subscriberId) {
            ret.subscriberId = options.subscriberId;
        }
        if (options.dependent) {
            ret.dependent = options.dependent;
        }
        if (options.relationship) {
            ret.relationship = options.relationship;
        }
        if (options.period) {
            ret.period = options.period;
        }
        if (options.insurer) {
            ret.insurerOrganizationId = this.getIdFromReference({
                ref: options.insurer.reference,
                resourceType: "Organization",
            });
        }
        if (options.dependent) {
            ret.dependent = options.dependent;
        }
        if (options.class) {
            ret.class = options.class;
        }
        if (options.order) {
            ret.order = options.order;
        }
        if (options.network) {
            ret.network = options.network;
        }
        if (options.costToBeneficiary) {
            ret.costToBeneficiary = options.costToBeneficiary;
        }
        if (options.subrogation) {
            ret.subrogation = options.subrogation;
        }
        if (options.contract) {
            ret.contractId = options.contract.map((el) => {
                const ret = this.getIdFromReference({
                    ref: el.reference,
                    resourceType: "Contract",
                });
            });
        }
        return ret;
    }
}
exports.Coverage = Coverage;
//# sourceMappingURL=Coverage.js.map