6. Machine testing via the API

Authorization: Bearer npfs_xxxxxxxxxxxxxxxxxxxxxxxx

export NPFS_API_KEY="npfs_...your key..."
export NPFS_BASE="https://fhir-sandbox.sahasratech.com.np"

curl -sS -X POST "$NPFS_BASE/fhir/\$validate?profile=http://fhir.digitalhealth.gov.np/core/StructureDefinition/np-core-patient" \
  -H "Authorization: Bearer $NPFS_API_KEY" \
  -H "Content-Type: application/fhir+json" \
  --data-binary @patient.json

{
  "resourceType": "OperationOutcome",
  "issue": [ {
    "severity": "error",
    "code": "structure",
    "details": { "text": "Patient.identifier:healthId: minimum required = 1, but only found 0 (from …)" },
    "diagnostics": "Nepal Health ID is required for every Patient — Add an entry to identifier with system …",
    "expression": [ "Patient" ],
    "extension": [ {
      "url": "https://fhir-sandbox.mohp.gov.np/StructureDefinition/explanation",
      "extension": [ { "url": "title", "valueString": "…" }, { "url": "fix", "valueString": "…" } ]
    } ]
  } ]
}

# Create (validated first)
curl -sS -i -X POST "$NPFS_BASE/fhir/Patient" \
  -H "Authorization: Bearer $NPFS_API_KEY" \
  -H "Content-Type: application/fhir+json" \
  --data-binary @patient.json

# Read (use the id from the Location header)
curl -sS "$NPFS_BASE/fhir/Patient/<id>" -H "Authorization: Bearer $NPFS_API_KEY"

# Search by Nepal Health ID
curl -sS -G "$NPFS_BASE/fhir/Patient" -H "Authorization: Bearer $NPFS_API_KEY" \
  --data-urlencode "identifier=http://fhir.digitalhealth.gov.np/core/NamingSystem/nepal-health-id|12345678901"

# Update only if nobody changed it since version 1 (else 412)
curl -sS -X PUT "$NPFS_BASE/fhir/Patient/<id>" \
  -H "Authorization: Bearer $NPFS_API_KEY" -H "Content-Type: application/fhir+json" \
  -H 'If-Match: W/"1"' --data-binary @patient-with-id.json

# Delete
curl -sS -X DELETE "$NPFS_BASE/fhir/Patient/<id>" -H "Authorization: Bearer $NPFS_API_KEY"

{
  "resourceType": "Bundle",
  "type": "transaction",
  "entry": [
    {
      "fullUrl": "urn:uuid:6f1c2a52-6a3b-4d6e-9a43-0c7c2b6f8a01",
      "resource": { "resourceType": "Patient", "...": "NP Core Patient content" },
      "request": { "method": "POST", "url": "Patient" }
    },
    {
      "fullUrl": "urn:uuid:0b9e6f35-2a8e-4b8a-8a51-7d8f3c1e9d02",
      "resource": {
        "resourceType": "Encounter",
        "subject": { "reference": "urn:uuid:6f1c2a52-6a3b-4d6e-9a43-0c7c2b6f8a01" },
        "...": "NP Core Encounter content"
      },
      "request": { "method": "POST", "url": "Encounter" }
    }
  ]
}

curl -sS -X POST "$NPFS_BASE/fhir" \
  -H "Authorization: Bearer $NPFS_API_KEY" \
  -H "Content-Type: application/fhir+json" \
  --data-binary @bundle.json

import json, os, sys
import requests

BASE = os.environ["NPFS_BASE"] + "/fhir"
S = requests.Session()
S.headers.update({
    "Authorization": f"Bearer {os.environ['NPFS_API_KEY']}",
    "Content-Type": "application/fhir+json",
    "Accept": "application/fhir+json",
})


def show_issues(resp):
    for i in resp.json().get("issue", []):
        if i["severity"] in ("fatal", "error", "warning"):
            print(f"  [{i['severity']}] {', '.join(i.get('expression', []))}: {i.get('diagnostics')}")


patient = json.load(open("patient.json", encoding="utf-8"))

# $validate (nothing stored)
r = S.post(f"{BASE}/$validate", json=patient, params={"profile": "http://fhir.digitalhealth.gov.np/core/StructureDefinition/np-core-patient"}, timeout=120)
show_issues(r)

# Create
r = S.post(f"{BASE}/Patient", json=patient, timeout=120)
if r.status_code == 422:
    print("Not conformant:"); show_issues(r); sys.exit(1)
r.raise_for_status()
pid, etag = r.json()["id"], r.headers.get("ETag")
print("Created Patient", pid, etag)

# Read and search
p = S.get(f"{BASE}/Patient/{pid}", timeout=60).json()
hid = next(i for i in p["identifier"] if i["system"] == "http://fhir.digitalhealth.gov.np/core/NamingSystem/nepal-health-id")
bundle = S.get(f"{BASE}/Patient", params={"identifier": f"{hid['system']}|{hid['value']}"}, timeout=60).json()
print("Found", bundle.get("total"), "patient(s)")

# Update with optimistic locking
p["active"] = True
r = S.put(f"{BASE}/Patient/{pid}", json=p, headers={"If-Match": etag}, timeout=120)
if r.status_code == 412:
    print("Changed by someone else - read again and retry")

# Unsupported search parameter -> 400
r = S.get(f"{BASE}/Patient", params={"name:contains": "Shr"}, timeout=60)
if r.status_code == 400:
    show_issues(r)

# Transaction
tx = json.load(open("bundle.json", encoding="utf-8"))
r = S.post(BASE, json=tx, timeout=180)
if r.status_code in (400, 422):
    show_issues(r); sys.exit(1)
for e in r.json()["entry"]:
    print(e["response"]["status"], e["response"].get("location"))

import { readFile } from "node:fs/promises";

const BASE = `${process.env.NPFS_BASE}/fhir`;
const headers = {
  Authorization: `Bearer ${process.env.NPFS_API_KEY}`,
  "Content-Type": "application/fhir+json",
  Accept: "application/fhir+json",
};

function printIssues(oo) {
  for (const i of oo.issue ?? []) {
    if (i.severity !== "information") console.error(`[${i.severity}] ${(i.expression ?? []).join(", ")}: ${i.diagnostics}`);
  }
}

const patient = await readFile("patient.json", "utf8");

// Create
let res = await fetch(`${BASE}/Patient`, { method: "POST", headers, body: patient });
if (res.status === 422) { printIssues(await res.json()); process.exit(1); }
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const created = await res.json();
const etag = res.headers.get("etag");
console.log("Created", created.id, etag);

// Read
res = await fetch(`${BASE}/Patient/${created.id}`, { headers });
const current = await res.json();

// Search, newest first
res = await fetch(`${BASE}/Patient?_sort=-_lastUpdated&_count=10`, { headers });
console.log("Patients:", (await res.json()).entry?.length ?? 0);

// Update with If-Match (412 if the version changed)
res = await fetch(`${BASE}/Patient/${created.id}`, {
  method: "PUT", headers: { ...headers, "If-Match": etag }, body: JSON.stringify({ ...current, active: true }),
});
if (res.status === 412) console.warn("Version conflict - read again and retry");

// Transaction
res = await fetch(BASE, { method: "POST", headers, body: await readFile("bundle.json", "utf8") });
if (res.status === 400 || res.status === 422) { printIssues(await res.json()); process.exit(1); }
for (const e of (await res.json()).entry) console.log(e.response.status, e.response.location);

import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.rest.api.MethodOutcome;
import ca.uhn.fhir.rest.client.api.IGenericClient;
import ca.uhn.fhir.rest.client.interceptor.BearerTokenAuthInterceptor;
import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
import ca.uhn.fhir.rest.server.exceptions.PreconditionFailedException;
import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException;
import org.hl7.fhir.r4.model.*;

import java.nio.file.Files;
import java.nio.file.Path;

public class NpCoreSandboxTest {
  public static void main(String[] args) throws Exception {
    FhirContext ctx = FhirContext.forR4();
    ctx.getRestfulClientFactory().setSocketTimeout(120_000);
    IGenericClient client = ctx.newRestfulGenericClient(System.getenv("NPFS_BASE") + "/fhir");
    client.registerInterceptor(new BearerTokenAuthInterceptor(System.getenv("NPFS_API_KEY")));

    Patient patient = ctx.newJsonParser().parseResource(Patient.class, Files.readString(Path.of("patient.json")));
    try {
      // Create
      MethodOutcome out = client.create().resource(patient).execute();
      IdType id = (IdType) out.getId();
      System.out.println("Created " + id.toUnqualifiedVersionless());

      // Read
      Patient p = client.read().resource(Patient.class).withId(id.getIdPart()).execute();

      // Search by Health ID
      Bundle found = client.search().forResource(Patient.class)
          .where(Patient.IDENTIFIER.exactly().systemAndCode(
              "http://fhir.digitalhealth.gov.np/core/NamingSystem/nepal-health-id", "12345678901"))
          .returnBundle(Bundle.class).execute();
      System.out.println("Found " + found.getTotal());

      // Update with If-Match: 412 if someone changed it since we read it
      p.setActive(true);
      client.update().resource(p).withId(p.getIdElement().toUnqualifiedVersionless())
          .withAdditionalHeader("If-Match", "W/\"" + p.getMeta().getVersionId() + "\"").execute();

      // Transaction
      Bundle tx = ctx.newJsonParser().parseResource(Bundle.class, Files.readString(Path.of("bundle.json")));
      Bundle resp = client.transaction().withBundle(tx).execute();
      resp.getEntry().forEach(e -> System.out.println(e.getResponse().getStatus() + " " + e.getResponse().getLocation()));
    } catch (UnprocessableEntityException e) {          // 422: not NP Core conformant
      printIssues((OperationOutcome) e.getOperationOutcome());
      System.exit(1);
    } catch (InvalidRequestException e) {               // 400: bad request / unsupported search parameter
      printIssues((OperationOutcome) e.getOperationOutcome());
      System.exit(1);
    } catch (PreconditionFailedException e) {           // 412: If-Match version conflict
      System.err.println("Version conflict - read again and retry");
    }
  }

  static void printIssues(OperationOutcome oo) {
    if (oo == null) return;
    for (OperationOutcome.OperationOutcomeIssueComponent i : oo.getIssue()) {
      System.err.printf("[%s] %s: %s%n", i.getSeverity().toCode(), i.getExpression(), i.getDiagnostics());
    }
  }
}

using System.Net;
using System.Net.Http.Headers;
using Hl7.Fhir.Model;
using Hl7.Fhir.Rest;
using Hl7.Fhir.Serialization;

var http = new HttpClient { Timeout = TimeSpan.FromSeconds(120) };
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("NPFS_API_KEY"));
var client = new FhirClient(Environment.GetEnvironmentVariable("NPFS_BASE") + "/fhir", http,
    new FhirClientSettings { PreferredFormat = ResourceFormat.Json });
var parser = new FhirJsonParser();

try
{
    // $validate (nothing stored)
    var patient = parser.Parse<Patient>(await File.ReadAllTextAsync("patient.json"));
    var outcome = await client.ValidateResourceAsync(patient);
    PrintIssues(outcome);

    // Create, read, search
    var created = await client.CreateAsync(patient);
    var read = await client.ReadAsync<Patient>($"Patient/{created.Id}");
    var found = await client.SearchAsync<Patient>(new[] {
        "identifier=http://fhir.digitalhealth.gov.np/core/NamingSystem/nepal-health-id|12345678901" });
    Console.WriteLine($"Created {created.Id}, found {found.Total}");

    // Update: Firely sends If-Match when versionAware is true (412 on conflict)
    read.Active = true;
    await client.UpdateAsync(read, versionAware: true);

    // Transaction
    var tx = parser.Parse<Bundle>(await File.ReadAllTextAsync("bundle.json"));
    var resp = await client.TransactionAsync(tx);
    foreach (var e in resp.Entry) Console.WriteLine($"{e.Response.Status} {e.Response.Location}");
}
catch (FhirOperationException ex) when (ex.Status == (HttpStatusCode)422 || ex.Status == HttpStatusCode.BadRequest)
{
    PrintIssues(ex.Outcome);
    Environment.Exit(1);
}
catch (FhirOperationException ex) when (ex.Status == HttpStatusCode.PreconditionFailed)
{
    Console.Error.WriteLine("Version conflict - read again and retry");
}

static void PrintIssues(OperationOutcome? oo)
{
    foreach (var i in oo?.Issue ?? new())
        Console.Error.WriteLine($"[{i.Severity}] {string.Join(", ", i.Expression)}: {i.Diagnostics}");
}

curl -sS -X POST "$NPFS_BASE/api/validate" \
  -H "Authorization: Bearer $NPFS_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"profile\": \"http://fhir.digitalhealth.gov.np/core/StructureDefinition/np-core-patient\", \"resource\": $(cat patient.json)}"

{
  "id": "…", "valid": false, "resourceType": "Patient",
  "profile": "http://fhir.digitalhealth.gov.np/core/StructureDefinition/np-core-patient",
  "summary": { "fatal": 0, "error": 1, "warning": 0, "information": 0 },
  "issues": [ {
    "severity": "error", "location": "Patient", "line": 1, "col": 2,
    "message": "Patient.identifier:healthId: minimum required = 1, but only found 0 (…)",
    "explanation": { "title": "…", "what": "…", "why": "…", "fix": "…", "example": "…", "igLink": "…", "category": "identifier" }
  } ]
}