use fhir_types::codec::Value;
use openehr_mapping_core::composition::NodeValue;
use openehr_mapping_core::composition::RmPosition;
use openehr_mapping_core::index::ResolvedNode;
use openehr_mapping_core::index::paths::FlatId;
use openehr_rm::v1_2::model;
use openehr_rm::v1_2::paths::PathSegment;
use openehr_rm::v1_2::paths::Predicate;
use openehr_rm::v1_2::paths::RmPath;
use openehr_rm::v1_2::paths::item_at_path;
use openehr_rm::v1_2::paths::items_at_path;
use openehr_rm::v1_2::paths::write::SetPathError;
use openehr_rm::v1_2::paths::write::set_at_path;
use openehr_rm::v1_2::typing::RmType;
use openehr_sdt::flat::path::Segment;
use crate::engine::cell;
use crate::engine::family;
use crate::engine::fhir::FhirValue;
use crate::engine::lens::Lens;
use crate::engine::lens::LensError;
use crate::engine::lens::null_flavour::NullFlavourLens;
use crate::engine::lens::scalar::IntegerLens;
use crate::engine::lens::scalar::RealLens;
use crate::engine::outcome::Warning;
use crate::engine::rm;
use crate::engine::rm::RmError;
use crate::engine::rm::RmValue;
use crate::engine::rm::carried::Carried;
use crate::model::ast::keyword::Direction;
use crate::resolve::program::mapping::Mapping;
use crate::resolve::program::target::FhirTarget;
use crate::resolve::program::target::ListAxis;
use crate::resolve::program::target::OpenehrTarget;
use crate::tree::element::Table;
use crate::engine::traverse::Binding;
use crate::engine::traverse::Held;
use crate::engine::traverse::Run;
use crate::engine::traverse::Written;
use crate::engine::traverse::demographic::Shape;
use crate::engine::traverse::error::EngineError;
pub(super) const PARTY_REF: &str = "PARTY_REF";
const DV_DATE_TIME: &str = "DV_DATE_TIME";
impl<T: Table + ?Sized> Run<'_, T> {
fn convert_family(
&mut self,
owner: &str,
mapping: &Mapping,
target: &FhirTarget,
openehr: &OpenehrTarget,
view: &FhirValue,
binding: &Binding,
) -> Result<(), EngineError> {
let node = openehr.node();
let segments = tail_segments(openehr);
if openehr.on_element() && segments == [rm::null_flavour::NULL_FLAVOUR] {
let refuse = |source: LensError| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
};
let FhirValue::String(ref code) = *view else {
return Err(refuse(LensError::NoCell {
rm_type: String::from("ELEMENT.null_flavour"),
kind: view.kind().as_str(),
direction: Direction::FhirToOpenehr,
}));
};
let flavour = NullFlavourLens.put(code, None).map_err(refuse)?;
self.families
.extend(family::null_flavour(node, &binding.openehr, &flavour));
return Ok(());
}
let leaf = openehr
.leaf_class()
.ok_or_else(|| unsupported_tail(mapping, openehr))?;
let produced = cell::put(view, leaf, None, self.binding_of(node).as_deref(), &[]).map_err(
|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
},
)?;
for taken in &produced.fallbacks {
self.warnings.push(Warning::fallback(
taken,
self.locate(mapping, &binding.fhir),
));
}
let value = self.identified(mapping, view, produced.value, Shape::Identifier)?;
let under =
rm::family_of(owner, &segments).ok_or_else(|| unsupported_tail(mapping, openehr))?;
match value {
RmValue::Party(ref party) => {
if under
.iter()
.any(|segment| segment.name == family::HEALTH_CARE_FACILITY)
{
self.facility_written = true;
}
self.families
.extend(family::provider(node, &binding.openehr, &under, party));
}
RmValue::DateTime(ref date_time) => {
self.families.push(family::end_time(
node,
&binding.openehr,
&under,
&date_time.value,
));
}
_ => {
return Err(EngineError::Rm {
mapping: String::from(mapping.name()),
node: String::from(node.aql_path().as_str()),
source: Box::new(RmError::UnknownClass {
rm_type: String::from(value.rm_type()),
}),
});
}
}
Ok(())
}
pub(super) fn convert_tail(
&mut self,
mapping: &Mapping,
target: &FhirTarget,
openehr: &OpenehrTarget,
view: &FhirValue,
binding: &Binding,
) -> Result<(), EngineError> {
let node = openehr.node();
let segments = tail_segments(openehr);
let (class, carried) = rm::carried::carried(openehr.tail_class(), &segments)
.ok_or_else(|| unsupported_tail(mapping, openehr))?;
let refuse_rm = |source: RmError| EngineError::Rm {
mapping: String::from(mapping.name()),
node: String::from(node.aql_path().as_str()),
source: Box::new(source),
};
if carried == Carried::EntryTime {
let key = rm::entry_time_key(class, &segments.join("/"))
.ok_or_else(|| unsupported_tail(mapping, openehr))?;
return self.entry_time(mapping, target, node, view, binding, key);
}
if carried == Carried::Family {
return self.convert_family(class, mapping, target, openehr, view, binding);
}
let object = self
.held_object(&binding.openehr, node.flat_id())
.map_err(refuse_rm)?;
let written = if carried == Carried::Value && openehr.leaf_class() == Some(PARTY_REF) {
self.party_ref_of(mapping, target, view)?
.to_canonical()
.map_err(refuse_rm)?
} else if carried == Carried::Value {
let leaf = openehr
.leaf_class()
.ok_or_else(|| unsupported_tail(mapping, openehr))?;
let held = serde_json::Value::Object(object.clone());
let existing = attribute_at(&held, openehr, &binding.elements).and_then(|found| {
RmValue::from_canonical(leaf, node.aql_path().as_str(), found).ok()
});
let produced = cell::put(
view,
leaf,
existing.as_ref(),
self.binding_of(node).as_deref(),
&[],
)
.map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
})?;
for taken in &produced.fallbacks {
self.warnings.push(Warning::fallback(
taken,
self.locate(mapping, &binding.fhir),
));
}
self.identified(mapping, view, produced.value, Shape::Identifier)?
.to_canonical()
.map_err(refuse_rm)?
} else {
self.scalar_written(mapping, target, binding, view, (carried, class, node))?
};
if openehr.lists().len() > binding.elements.len() {
return Err(unsupported_tail(mapping, openehr));
}
let mut whole = serde_json::Value::Object(object);
set_at_path(
&mut whole,
&RmType::simple(class),
&positioned(openehr, &binding.elements),
written,
)
.map_err(|source| EngineError::TailWrite {
mapping: String::from(mapping.name()),
node: String::from(node.aql_path().as_str()),
source: Box::new(source),
})?;
let serde_json::Value::Object(mut object) = whole else {
return Err(unsupported_tail(mapping, openehr));
};
let kept = object
.get("_type")
.and_then(serde_json::Value::as_str)
.filter(|held| *held == class || model::is_a(held, class))
.map(String::from);
object.insert(
String::from("_type"),
serde_json::Value::String(kept.unwrap_or_else(|| String::from(class))),
);
self.store(Written {
flat_id: node.flat_id().clone(),
positions: binding.openehr.clone(),
value: Held::Partial(object),
});
Ok(())
}
fn scalar_written(
&mut self,
mapping: &Mapping,
target: &FhirTarget,
binding: &Binding,
view: &FhirValue,
(carried, class, node): (Carried, &str, &ResolvedNode),
) -> Result<serde_json::Value, EngineError> {
if let (Carried::Text, Some(produced)) = (carried, cell::put_string(view)) {
let produced = produced.map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
})?;
for taken in &produced.fallbacks {
self.warnings.push(Warning::fallback(
taken,
self.locate(mapping, &binding.fhir),
));
}
return Ok(serde_json::Value::String(produced.value));
}
let number = match (carried, view) {
(Carried::Integer, FhirValue::Integer(integer)) => Some(
IntegerLens
.put(integer, None)
.map(|number| serde_json::Value::Number(number.into())),
),
(Carried::Real, FhirValue::Decimal(decimal)) => {
Some(RealLens.put(decimal, None).map(serde_json::Value::Number))
}
_ => None,
};
if let Some(number) = number {
return number.map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
});
}
let element = String::from(target.resolved().leaf());
let text = view.write(&element).map_err(|source| EngineError::Fhir {
mapping: String::from(mapping.name()),
element: element.clone(),
source: Box::new(source),
})?;
scalar_json(carried, class, node, &text).map_err(|source| EngineError::Rm {
mapping: String::from(mapping.name()),
node: String::from(node.aql_path().as_str()),
source: Box::new(source),
})
}
fn entry_time(
&mut self,
mapping: &Mapping,
target: &FhirTarget,
node: &ResolvedNode,
view: &FhirValue,
binding: &Binding,
key: &str,
) -> Result<(), EngineError> {
let produced =
cell::put(view, DV_DATE_TIME, None, None, &[]).map_err(|source| EngineError::Cell {
mapping: String::from(mapping.name()),
element: String::from(target.expression().as_str()),
source: Box::new(source),
})?;
for taken in &produced.fallbacks {
self.warnings.push(Warning::fallback(
taken,
self.locate(mapping, &binding.fhir),
));
}
let RmValue::DateTime(ref time) = produced.value else {
return Err(EngineError::Rm {
mapping: String::from(mapping.name()),
node: String::from(node.aql_path().as_str()),
source: Box::new(RmError::UnknownClass {
rm_type: String::from(produced.value.rm_type()),
}),
});
};
self.families.push(
NodeValue::new(node, serde_json::Value::String(time.value.clone()))
.with_occurrences(binding.openehr.clone())
.under(vec![Segment {
name: String::from(key),
index: None,
}]),
);
Ok(())
}
fn held_object(
&self,
positions: &[RmPosition],
flat_id: &FlatId,
) -> Result<serde_json::Map<String, serde_json::Value>, RmError> {
let Some(written) = self
.written
.iter()
.find(|written| written.flat_id == *flat_id && written.positions == positions)
else {
return Ok(serde_json::Map::new());
};
match written.value {
Held::Partial(ref object) | Held::Canonical(serde_json::Value::Object(ref object)) => {
Ok(object.clone())
}
Held::Canonical(_) => Ok(serde_json::Map::new()),
Held::Value(ref value) => match value.to_canonical()? {
serde_json::Value::Object(object) => Ok(object),
_ => Ok(serde_json::Map::new()),
},
}
}
}
pub(super) fn attribute_at<'value>(
value: &'value serde_json::Value,
target: &OpenehrTarget,
elements: &[RmPosition],
) -> Option<&'value serde_json::Value> {
item_at_path(value, &positioned(target, elements))
}
pub(super) fn positioned(target: &OpenehrTarget, elements: &[RmPosition]) -> RmPath {
let mut tail = target.tail().clone();
for (axis, position) in target.lists().iter().zip(elements) {
if let Some(segment) = tail.segments.get_mut(axis.depth()) {
segment.predicate.position = usize::try_from(position.get()).ok();
}
}
tail
}
pub(super) fn list_length(
value: &serde_json::Value,
target: &OpenehrTarget,
axis: &ListAxis,
outer: &[RmPosition],
) -> usize {
let mut path = positioned(target, outer);
path.segments.truncate(axis.depth().saturating_add(1));
items_at_path(value, &path).len()
}
pub(super) fn lexical(value: &Value) -> String {
match *value {
Value::Null => String::new(),
Value::Bool(flag) => String::from(if flag { "true" } else { "false" }),
Value::Number(ref number) => String::from(number.as_str()),
Value::String(ref text) => text.clone(),
Value::Array(ref items) => items.iter().map(lexical).collect::<Vec<String>>().join(","),
Value::Object(ref object) => object
.iter()
.map(|(key, member)| format!("{key}={}", lexical(member)))
.collect::<Vec<String>>()
.join(";"),
}
}
pub(super) fn tail_segments(target: &OpenehrTarget) -> Vec<&str> {
target
.tail()
.segments
.iter()
.map(|segment| segment.attribute.as_str())
.collect()
}
pub(super) fn unsupported_tail(mapping: &Mapping, target: &OpenehrTarget) -> EngineError {
EngineError::UnsupportedTail {
mapping: String::from(mapping.name()),
node: String::from(target.node().aql_path().as_str()),
tail: target.tail().to_string(),
}
}
fn scalar_json(
carried: Carried,
class: &str,
node: &ResolvedNode,
written: &Value,
) -> Result<serde_json::Value, RmError> {
let text = match *written {
Value::String(ref text) => text.clone(),
Value::Number(ref number) => String::from(number.as_str()),
Value::Bool(flag) => String::from(if flag { "true" } else { "false" }),
Value::Null | Value::Array(_) | Value::Object(_) => String::new(),
};
let refuse = |expected: &'static str| RmError::Scalar {
node: String::from(node.aql_path().as_str()),
rm_type: String::from(class),
text: text.clone(),
expected,
};
match carried {
Carried::Text if written.as_str().is_some() => Ok(serde_json::Value::String(text)),
Carried::Text | Carried::Value | Carried::Family | Carried::EntryTime => {
Err(refuse("text"))
}
Carried::Real => serde_json::from_str::<serde_json::Number>(&text)
.map(serde_json::Value::Number)
.map_err(|_refused| refuse("a real number")),
Carried::Integer => text
.parse::<i64>()
.map(|number| serde_json::Value::Number(number.into()))
.map_err(|_refused| refuse("an integer")),
Carried::Boolean => match text.as_str() {
"true" => Ok(serde_json::Value::Bool(true)),
"false" => Ok(serde_json::Value::Bool(false)),
_ => Err(refuse("a boolean")),
},
}
}
pub(super) fn scalar(value: &serde_json::Value) -> Option<String> {
match *value {
serde_json::Value::String(ref text) => Some(text.clone()),
serde_json::Value::Bool(flag) => Some(String::from(if flag { "true" } else { "false" })),
serde_json::Value::Number(ref number) => Some(number.to_string()),
serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
None
}
}
}
pub(super) fn merge(
object: &mut serde_json::Map<String, serde_json::Value>,
class: &str,
segments: &[&str],
value: &str,
) -> Result<(), SetPathError> {
let path = RmPath {
absolute: false,
segments: segments
.iter()
.map(|attribute| PathSegment {
attribute: String::from(*attribute),
predicate: Predicate::default(),
descendant: false,
})
.collect(),
};
let mut whole = serde_json::Value::Object(core::mem::take(object));
let written = set_at_path(
&mut whole,
&RmType::simple(class),
&path,
serde_json::Value::String(String::from(value)),
);
if let serde_json::Value::Object(held) = whole {
*object = held;
}
written.map(drop)
}
#[cfg(test)]
mod tests {
use super::merge;
#[test]
fn manual_paths_that_share_a_prefix_merge_into_one_element() {
let mut object = serde_json::Map::new();
let class = "DV_CODED_TEXT";
merge(
&mut object,
class,
&["defining_code", "terminology_id", "value"],
"openehr",
)
.expect("the terminology should be written");
merge(&mut object, class, &["defining_code", "code_string"], "524")
.expect("the code should merge beside the terminology");
merge(&mut object, class, &["value"], "Initial").expect("the text should be written");
assert_eq!(
serde_json::Value::Object(object),
serde_json::json!({
"defining_code": {"terminology_id": {"value": "openehr"}, "code_string": "524"},
"value": "Initial"
})
);
}
}