use fhir_types::codec::Value;
use crate::engine::bundle::Entry;
use crate::engine::bundle::resolve;
use crate::operations::error::OperationError;
const SUBJECT_ELEMENTS: [&str; 2] = ["subject", "patient"];
#[derive(Debug, Clone, PartialEq, Eq)]
enum Subject {
Entry(usize),
Outside(String),
}
pub(crate) fn refuse_several(entries: &[Entry]) -> Result<(), OperationError> {
let mut subjects: Vec<Subject> = Vec::new();
for (position, (full_url, resource)) in entries.iter().enumerate() {
if resource.get("resourceType").and_then(Value::as_str) == Some("Patient") {
record(&mut subjects, Subject::Entry(position));
}
for element in SUBJECT_ELEMENTS {
for reference in literals(resource.get(element)) {
let found = resolve(entries, full_url.as_deref(), reference);
if found.is_empty() {
record(&mut subjects, Subject::Outside(String::from(reference)));
}
for target in found {
record(&mut subjects, Subject::Entry(target));
}
}
}
}
if subjects.len() > 1 {
return Err(OperationError::SeveralSubjects {
subjects: subjects
.iter()
.map(|subject| rendered(entries, subject))
.collect(),
});
}
Ok(())
}
fn record(subjects: &mut Vec<Subject>, subject: Subject) {
if !subjects.contains(&subject) {
subjects.push(subject);
}
}
fn literals(element: Option<&Value>) -> Vec<&str> {
match element {
Some(Value::Array(items)) => items.iter().filter_map(literal).collect(),
Some(single) => literal(single).into_iter().collect(),
None => Vec::new(),
}
}
fn literal(reference: &Value) -> Option<&str> {
reference.get("reference").and_then(Value::as_str)
}
fn rendered(entries: &[Entry], subject: &Subject) -> String {
match *subject {
Subject::Outside(ref reference) => reference.clone(),
Subject::Entry(position) => {
let Some((full_url, resource)) = entries.get(position) else {
return format!("entry {position}");
};
if let Some(url) = full_url {
return url.clone();
}
let kind = resource.get("resourceType").and_then(Value::as_str);
let id = resource.get("id").and_then(Value::as_str);
match (kind, id) {
(Some(kind), Some(id)) => format!("{kind}/{id}"),
(Some(kind), None) => format!("{kind} at entry {position}"),
_ => format!("entry {position}"),
}
}
}
}