use fhir_types::codec::Json;
use fhir_types::codec::Object;
use fhir_types::codec::Path;
use fhir_types::codec::Value;
use fhir_types::r4::bundle::Bundle;
use fhir_types::r4::bundle::BundleEntry;
use fhir_types::r4::primitives::Code;
use fhir_types::r4::resource::Resource;
use openehr_mapping_core::composition::CanonicalComposition;
use openehr_mapping_core::index::WebTemplateIndex;
use crate::engine::context::CallContext;
use crate::engine::identity;
use crate::engine::origin::Origin;
use crate::engine::origin::SourceItem;
use crate::engine::outcome::Location;
use crate::engine::outcome::Warning;
use crate::engine::seam::BundleReferences;
use crate::engine::seam::Seams;
use crate::engine::seam::identity::ResourceRequest;
use crate::engine::traverse;
use crate::engine::traverse::defaults::Defaults;
use crate::operations::contract::CompositionPayload;
use crate::operations::contract::Format;
use crate::operations::contract::ToFhirRequest;
use crate::operations::contract::ToFhirResponse;
use crate::operations::contract::ToOpenehrRequest;
use crate::operations::contract::ToOpenehrResponse;
use crate::operations::error::OperationError;
use crate::operations::issues;
use crate::operations::occurrences;
use crate::operations::programs::ProgramSet;
use crate::operations::provenance;
use crate::operations::provenance::CompositionSource;
use crate::operations::subjects;
use crate::resolve::program::Program;
use crate::resolve::program::binding::TemplateId;
use crate::resolve::select::select_by_profile;
use crate::resolve::select::select_by_template;
use crate::tree::element::Table;
pub const BUNDLE_TYPE: &str = "collection";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Settings {
device: String,
now: String,
defaults: Defaults,
}
impl Settings {
#[must_use]
pub fn new(device: impl Into<String>, now: impl Into<String>) -> Self {
let now = now.into();
Self {
device: device.into(),
defaults: Defaults::at(now.clone()),
now,
}
}
#[must_use]
pub fn with_defaults(mut self, defaults: Defaults) -> Self {
self.defaults = defaults;
self
}
#[must_use]
pub fn device(&self) -> &str {
&self.device
}
#[must_use]
pub fn now(&self) -> &str {
&self.now
}
#[must_use]
pub const fn defaults(&self) -> &Defaults {
&self.defaults
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Transformed<R> {
response: R,
warnings: Vec<Warning>,
reads: Vec<Location>,
}
impl<R> Transformed<R> {
#[must_use]
pub const fn response(&self) -> &R {
&self.response
}
#[must_use]
pub fn warnings(&self) -> &[Warning] {
&self.warnings
}
#[must_use]
pub fn reads(&self) -> &[Location] {
&self.reads
}
#[must_use]
pub fn into_response(self) -> R {
self.response
}
#[must_use]
pub fn into_parts(self) -> (R, Vec<Warning>) {
(self.response, self.warnings)
}
}
pub fn to_fhir<T: Table + ?Sized>(
programs: &ProgramSet,
table: &T,
seams: &Seams<'_>,
settings: &Settings,
request: &ToFhirRequest,
) -> Result<ToFhirResponse, OperationError> {
to_fhir_with_warnings(programs, table, seams, settings, request).map(Transformed::into_response)
}
pub fn to_fhir_with_warnings<T: Table + ?Sized>(
programs: &ProgramSet,
table: &T,
seams: &Seams<'_>,
settings: &Settings,
request: &ToFhirRequest,
) -> Result<Transformed<ToFhirResponse>, OperationError> {
let template = template_of(request)?;
let index = programs
.template(&template)
.ok_or_else(|| OperationError::UnknownTemplate {
template: String::from(template.as_str()),
})?;
let composition = composition_of(request.composition(), index, settings.now())?;
let program = select_by_template(programs.programs(), &template)
.map_err(|source| OperationError::Select { source })?;
let context = request.context().cloned().unwrap_or_default();
let (occurrences, mut warnings) =
occurrences::occurrences(program, table, index, &composition, seams, &context)?;
let resource_type = String::from(program.resource().as_str());
let mut targets = Vec::new();
let mut resources = Vec::new();
for (occurrence, path, outcome) in &occurrences {
let mut object = object_of(outcome.value())?;
subject(table, &mut object, &resource_type, request.context())?;
let mapped = Mapped {
resource_type: &resource_type,
template: template.as_str(),
occurrence,
path,
};
let id = identity(&object, &composition, &mapped, seams)?;
object.insert(String::from("id"), Value::String(id.clone()));
targets.push(format!("{resource_type}/{id}"));
resources.push(typed(&object, &resource_type)?);
for created in outcome.created() {
let mut object = object_of(created)?;
let kind = object
.get("resourceType")
.and_then(Value::as_str)
.map(String::from)
.ok_or(OperationError::NotAnObject {
what: "created resource",
})?;
subject(table, &mut object, &kind, request.context())?;
if let Some(created_id) = object.get("id").and_then(Value::as_str) {
targets.push(format!("{kind}/{created_id}"));
}
resources.push(typed(&object, &kind)?);
}
}
refuse_duplicates(&targets)?;
for (_, _, outcome) in &occurrences {
warnings.extend_from_slice(outcome.warnings());
}
let source = match composition_uid(&composition) {
Some(uid) => CompositionSource::new(template.as_str()).with_uid(uid),
None => CompositionSource::new(template.as_str()),
};
let provenance = provenance::of_run(
&targets,
settings.now(),
settings.device(),
&source,
request.context(),
);
let mut entry: Vec<BundleEntry> = resources.into_iter().map(entry_of).collect();
entry.push(entry_of(Resource::Provenance(Box::new(provenance))));
if let Some(reported) = issues::of_warnings(&warnings) {
entry.push(entry_of(Resource::OperationOutcome(Box::new(reported))));
}
Ok(Transformed {
response: ToFhirResponse::new(Bundle {
r#type: Code::from(BUNDLE_TYPE),
entry,
..Bundle::default()
}),
warnings,
reads: Vec::new(),
})
}
fn refuse_duplicates(targets: &[String]) -> Result<(), OperationError> {
let mut seen = std::collections::BTreeSet::new();
for target in targets {
if !seen.insert(target.as_str()) {
return Err(OperationError::DuplicateId {
reference: target.clone(),
});
}
}
Ok(())
}
pub fn to_openehr<T: Table + ?Sized>(
programs: &ProgramSet,
table: &T,
seams: &Seams<'_>,
settings: &Settings,
request: &ToOpenehrRequest,
) -> Result<ToOpenehrResponse, OperationError> {
to_openehr_with_warnings(programs, table, seams, settings, request)
.map(Transformed::into_response)
}
pub fn to_openehr_with_warnings<T: Table + ?Sized>(
programs: &ProgramSet,
table: &T,
seams: &Seams<'_>,
settings: &Settings,
request: &ToOpenehrRequest,
) -> Result<Transformed<ToOpenehrResponse>, OperationError> {
let addressed = bundle_entries(request.bundle())?;
subjects::refuse_several(&addressed)?;
let entries = entry_objects(request.bundle())?;
let program = select(programs, &entries, request.template_id())?;
let template = program.template().id().clone();
let index = programs
.template(&template)
.ok_or_else(|| OperationError::UnknownTemplate {
template: String::from(template.as_str()),
})?;
let document = mapped_resource(&entries, program)?;
let mut origin = Origin::new(settings.device());
if let Some(source) = SourceItem::of(&document) {
origin = origin.with_source(source);
}
let defaults = settings.defaults().clone().with_origin(origin);
let referrer = addressed
.iter()
.find(|&(_, resource)| *resource == document)
.and_then(|(full_url, _)| full_url.clone());
let mut references = BundleReferences::new(addressed, seams.references());
if let Some(full_url) = referrer {
references = references.with_referrer(full_url);
}
let seams = seams.with_references(&references);
let outcome = traverse::to_openehr(
program,
table,
index,
&document,
&seams,
&defaults,
&CallContext::new(),
)
.map_err(|source| OperationError::Mapping {
source: Box::new(source),
})?;
let serialized = serialize(index, outcome.value(), request.format())?;
let answer = ToOpenehrResponse::new(serialized);
let response = match issues::of_warnings(outcome.warnings()) {
Some(reported) => answer.with_outcome(reported),
None => answer,
};
Ok(Transformed {
response,
warnings: outcome.warnings().to_vec(),
reads: outcome.reads().to_vec(),
})
}
fn template_of(request: &ToFhirRequest) -> Result<TemplateId, OperationError> {
let inline = request.composition().template_id();
match (inline, request.template_id()) {
(Some(inline), Some(pinned)) if inline.as_str() != pinned.as_str() => {
Err(OperationError::TemplateDisagreement {
payload: String::from(inline.as_str()),
pinned: String::from(pinned.as_str()),
})
}
(_, Some(pinned)) => Ok(pinned.clone()),
(Some(inline), None) => Ok(inline),
(None, None) => match *request.composition() {
CompositionPayload::Flat(_) => Err(OperationError::FlatTemplate),
CompositionPayload::Canonical(_) => Err(OperationError::CanonicalTemplate),
},
}
}
fn composition_of(
payload: &CompositionPayload,
index: &WebTemplateIndex,
now: &str,
) -> Result<CanonicalComposition, OperationError> {
match *payload {
CompositionPayload::Canonical(ref object) => index
.accept(serde_json::Value::Object(object.clone()))
.map_err(|source| OperationError::Serialization {
source: Box::new(source),
}),
CompositionPayload::Flat(ref object) => {
index
.build_from_flat(object, now)
.map_err(|source| OperationError::Serialization {
source: Box::new(source),
})
}
}
}
pub(super) fn composition_uid(composition: &CanonicalComposition) -> Option<&str> {
composition.value().get("uid")?.get("value")?.as_str()
}
fn object_of(document: &Value) -> Result<Object, OperationError> {
match *document {
Value::Object(ref object) => Ok(object.clone()),
_ => Err(OperationError::NotAnObject {
what: "mapped resource",
}),
}
}
fn identity(
object: &Object,
composition: &CanonicalComposition,
mapped: &Mapped<'_>,
seams: &Seams<'_>,
) -> Result<String, OperationError> {
let resource_type = mapped.resource_type;
if let Some(resources) = seams.resource_identity() {
let mut request = ResourceRequest::new(resource_type, mapped.template)
.with_occurrence(mapped.occurrence.to_vec())
.with_entry_path(mapped.path);
if let Some(uid) = composition_uid(composition) {
request = request.with_composition(uid);
}
if let Some(Value::String(written)) = object.get("id") {
request = request.with_written(written.clone());
}
let id = resources
.identify(&request)
.map_err(|source| OperationError::Identity {
resource: String::from(resource_type),
source,
})?;
if !is_fhir_id(&id) {
return Err(OperationError::InvalidId {
resource: String::from(resource_type),
id,
});
}
return Ok(id);
}
if let Some(Value::String(written)) = object.get("id")
&& is_fhir_id(written)
{
return Ok(written.clone());
}
composition_uid(composition)
.map(|uid| identity::deterministic_id(&identity::versioned_object_uid(uid), mapped.path))
.ok_or_else(|| OperationError::Unidentified {
resource: String::from(resource_type),
})
}
#[derive(Debug, Clone, Copy)]
struct Mapped<'run> {
resource_type: &'run str,
template: &'run str,
occurrence: &'run [u32],
path: &'run str,
}
fn is_fhir_id(text: &str) -> bool {
!text.is_empty()
&& text.len() <= 64
&& text.chars().all(|character| {
character.is_ascii_alphanumeric() || character == '-' || character == '.'
})
}
fn subject<T: Table + ?Sized>(
table: &T,
object: &mut Object,
resource_type: &str,
context: Option<&CallContext>,
) -> Result<(), OperationError> {
let Some(patient) = context.and_then(CallContext::patient) else {
return Ok(());
};
let Some(schema) = table.type_named(resource_type) else {
return Ok(());
};
let Some(field) = schema
.fields
.iter()
.find(|field| field.name == "subject" || field.name == "patient")
else {
return Ok(());
};
let rendered = Json::to_json(patient).map_err(|source| OperationError::Encode { source })?;
let value = if field.many {
Value::Array(vec![Value::Object(rendered)])
} else {
Value::Object(rendered)
};
object.insert(String::from(field.name), value);
Ok(())
}
fn entry_of(resource: Resource) -> BundleEntry {
BundleEntry {
resource: Some(resource),
..BundleEntry::default()
}
}
fn typed(object: &Object, resource_type: &str) -> Result<Resource, OperationError> {
Resource::from_json(object, &mut Path::root(resource_type)).map_err(|source| {
OperationError::Mapped {
version: "R4",
source: Box::new(source),
}
})
}
fn bundle_entries(bundle: &Bundle) -> Result<Vec<(Option<String>, Value)>, OperationError> {
let mut entries = Vec::new();
for entry in &bundle.entry {
let Some(ref resource) = entry.resource else {
continue;
};
let object = Json::to_json(resource).map_err(|source| OperationError::Encode { source })?;
let full_url = entry.full_url.as_ref().and_then(|url| url.value.clone());
entries.push((full_url, Value::Object(object)));
}
Ok(entries)
}
fn entry_objects(bundle: &Bundle) -> Result<Vec<Object>, OperationError> {
let mut objects = Vec::new();
for entry in &bundle.entry {
let Some(ref resource) = entry.resource else {
continue;
};
let object = Json::to_json(resource).map_err(|source| OperationError::Encode { source })?;
objects.push(object);
}
Ok(objects)
}
fn record(seen: &mut Vec<String>, value: String) {
if !seen.contains(&value) {
seen.push(value);
}
}
fn select<'set>(
programs: &'set ProgramSet,
entries: &[Object],
template: Option<&TemplateId>,
) -> Result<&'set Program, OperationError> {
let claimed = profiles(entries);
if claimed.is_empty() {
let pinned = template.ok_or(OperationError::Select {
source: crate::resolve::select::SelectError::NoMatch {
wanted: String::from("a bundle that claims no profile and pins no template"),
},
})?;
return select_by_template(programs.programs(), pinned)
.map(AsRef::as_ref)
.map_err(|source| OperationError::Select { source });
}
select_by_profile(programs.programs(), &claimed, template)
.map(AsRef::as_ref)
.map_err(|source| OperationError::Select { source })
}
fn profiles(entries: &[Object]) -> Vec<String> {
let mut claimed: Vec<String> = Vec::new();
for object in entries {
let Some(Value::Array(listed)) = object.get("meta").and_then(|meta| meta.get("profile"))
else {
continue;
};
for entry in listed {
if let Value::String(url) = entry {
record(&mut claimed, url.clone());
}
}
}
claimed
}
fn mapped_resource(entries: &[Object], program: &Program) -> Result<Value, OperationError> {
let wanted = program.resource().as_str();
let found: Vec<&Object> = entries
.iter()
.filter(|object| {
matches!(object.get("resourceType"), Some(Value::String(name)) if name == wanted)
})
.collect();
match *found.as_slice() {
[only] => Ok(Value::Object(only.clone())),
[] => Err(OperationError::NoSubjectResource {
resource: String::from(wanted),
context: String::from(program.context().as_str()),
}),
ref several => Err(OperationError::SeveralSubjectResources {
resource: String::from(wanted),
count: several.len(),
}),
}
}
fn serialize(
index: &WebTemplateIndex,
composition: &CanonicalComposition,
format: Format,
) -> Result<String, OperationError> {
match format {
Format::Canonical => Ok(composition.value().to_string()),
Format::Flat => {
let flat =
index
.flatten(composition)
.map_err(|source| OperationError::Serialization {
source: Box::new(source),
})?;
Ok(serde_json::Value::Object(flat).to_string())
}
}
}