org.hl7.fhir.dstu3.model.DomainResource Java Examples

public ConditionCategory getCategory(DomainResource resource){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	if (!fhirCondition.getCategory().isEmpty()) {
		List<Coding> coding = fhirCondition.getCategory().get(0).getCoding();
		if (!coding.isEmpty()) {
			for (Coding categoryCoding : coding) {
				if (categoryCoding.getSystem()
					.equals("http://hl7.org/fhir/condition-category")) {
					return (ConditionCategory) categoryMapping
						.getLocalEnumValueByCode(categoryCoding.getCode().toUpperCase());
				}
			}
		}
	}
	return ConditionCategory.UNKNOWN;
}
 

public Optional<String> getEnd(DomainResource resource){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	try {
		if (fhirCondition.hasAbatementDateTimeType()) {
			DateTimeType dateTime = fhirCondition.getAbatementDateTimeType();
			if (dateTime != null) {
				Date date = dateTime.getValue();
				SimpleDateFormat format = new SimpleDateFormat("dd.MM.yyyy");
				return Optional.of(format.format(date));
			}
		} else if (fhirCondition.hasAbatementStringType()) {
			return Optional.of(fhirCondition.getAbatementStringType().getValue());
		}
	} catch (FHIRException e) {
		LoggerFactory.getLogger(ConditionAccessor.class).error("Could not access end.", e);
	}
	return Optional.empty();
}
 

public void setCategory(DomainResource resource, ObservationCategory category){
	org.hl7.fhir.dstu3.model.Observation fhirObservation =
		(org.hl7.fhir.dstu3.model.Observation) resource;
	CodeableConcept categoryCode = new CodeableConcept();
	if (category.name().startsWith("SOAP_")) {
		// elexis soap categories
		categoryCode.setCoding(
			Collections.singletonList(new Coding(IdentifierSystem.ELEXIS_SOAP.getSystem(),
				category.getCode(), category.getLocalized())));
	} else {
		org.hl7.fhir.dstu3.model.codesystems.ObservationCategory fhirCategoryCode =
			(org.hl7.fhir.dstu3.model.codesystems.ObservationCategory) categoryMapping
				.getFhirEnumValueByEnum(category);
		if (fhirCategoryCode != null) {
			// lookup matching fhir category
			categoryCode
				.setCoding(Collections.singletonList(new Coding(fhirCategoryCode.getSystem(),
					fhirCategoryCode.toCode(), fhirCategoryCode.getDisplay())));
		} else {
			throw new IllegalStateException("Unknown observation category " + category);
		}
	}
	if (!categoryCode.getCoding().isEmpty()) {
		fhirObservation.setCategory(Collections.singletonList(categoryCode));
	}
}
 

private ValueSet resolveBindingReference(DomainResource ctxt, Type reference) {
  if (reference instanceof UriType) {
    return context.fetchResource(ValueSet.class, ((UriType) reference).getValue().toString());
  }
  else if (reference instanceof Reference) {
    String s = ((Reference) reference).getReference();
    if (s.startsWith("#")) {
      for (Resource c : ctxt.getContained()) {
        if (c.getId().equals(s.substring(1)) && (c instanceof ValueSet))
          return (ValueSet) c;
      }
      return null;
    } else {
      return context.fetchResource(ValueSet.class, ((Reference) reference).getReference());
    }
  }
  else
    return null;
}
 

public void setConsultationId(DomainResource resource, String consultationId) {
	org.hl7.fhir.dstu3.model.Encounter fhirEncounter = (org.hl7.fhir.dstu3.model.Encounter) resource;
	boolean identifierFound = false;
	List<Identifier> existing = fhirEncounter.getIdentifier();
	for (Identifier existingIdentifier : existing) {
		if (IdentifierSystem.ELEXIS_CONSID.getSystem().equals(existingIdentifier.getSystem())) {
			existingIdentifier.setValue(consultationId);
			identifierFound = true;
			break;
		}
	}
	if (!identifierFound) {
		Identifier identifier = fhirEncounter.addIdentifier();
		identifier.setSystem(IdentifierSystem.ELEXIS_CONSID.getSystem());
		identifier.setValue(consultationId);
	}
}
 

public List<ICoding> getDocumentClass(DomainResource resource){
	org.hl7.fhir.dstu3.model.DocumentReference fhirResource =
		(org.hl7.fhir.dstu3.model.DocumentReference) resource;
	CodeableConcept codeableConcept = fhirResource.getClass_();
	if (codeableConcept != null) {
		return ModelUtil.getCodingsFromConcept(codeableConcept);
	}
	return Collections.emptyList();
}
 

@Override
public void setConsultationId(String consultationId){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setConsultationId((DomainResource) resource.get(), consultationId);
		saveResource(resource.get());
	}
	getEntity().setConsultationId(consultationId);
}
 

public void setType(DomainResource resource, List<ICoding> coding){
	org.hl7.fhir.dstu3.model.Encounter fhirEncounter =
		(org.hl7.fhir.dstu3.model.Encounter) resource;
	List<CodeableConcept> codeableConcepts = fhirEncounter.getType();
	if (!codeableConcepts.isEmpty()) {
		codeableConcepts.clear();
	}
	CodeableConcept codeableConcept = new CodeableConcept();
	ModelUtil.setCodingsToConcept(codeableConcept, coding);
	fhirEncounter.setType(Collections.singletonList(codeableConcept));
}
 

@Override
public List<ICoding> getCoding(){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		return accessor.getCoding((DomainResource) resource.get());
	}
	return Collections.emptyList();
}
 

@Override
public void setPatientId(String patientId){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setPatientId((DomainResource) resource.get(), patientId);
		saveResource(resource.get());
	}
	
	getEntity().setPatientId(patientId);
}
 

@Override
public void setStartTime(LocalDateTime time){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setStartTime((DomainResource) resource.get(), time);
		saveResource(resource.get());
	}
}
 

@Override
public void setDateRecorded(LocalDate date){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setDateRecorded((DomainResource) resource.get(), date);
		saveResource(resource.get());
	}
}
 

public Optional<String> getComment(DomainResource resource){
	org.hl7.fhir.dstu3.model.Observation fhirObservation =
		(org.hl7.fhir.dstu3.model.Observation) resource;
	if (fhirObservation.hasComment()) {
		return Optional.of(fhirObservation.getComment());
	}
	return Optional.empty();
}
 

public void setIndication(DomainResource resource, List<ICondition> indication){
	org.hl7.fhir.dstu3.model.Encounter fhirEncounter =
		(org.hl7.fhir.dstu3.model.Encounter) resource;
	List<DiagnosisComponent> theIndication = new ArrayList<>();
	for (ICondition iCondition : indication) {
		theIndication.add(new DiagnosisComponent(new Reference(new IdDt("Condition", iCondition.getId()))));
	}
	fhirEncounter.setDiagnosis(theIndication);
}
 

@Override
public void setEnd(String end){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setEnd((DomainResource) resource.get(), end);
		saveResource(resource.get());
	}
}
 

public void addStringExtension(String theUrl, String theValue){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent() && resource.get() instanceof DomainResource) {
		DomainResource domainResource = (DomainResource) resource.get();
		Extension extension = new Extension(theUrl);
		extension.setValue(new StringType().setValue(theValue));
		domainResource.addExtension(extension);
		saveResource(domainResource);
	}
}
 

public Optional<BigDecimal> getNumericValue(DomainResource resource){
	org.hl7.fhir.dstu3.model.Observation fhirObservation =
		(org.hl7.fhir.dstu3.model.Observation) resource;
	if (fhirObservation.hasValueQuantity()) {
		Quantity quantity = (Quantity) fhirObservation.getValue();
		if (quantity.getValue() != null) {
			return Optional.of(quantity.getValue());
		}
	}
	return Optional.empty();
}
 

@Override
public void setComment(String comment){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setComment((DomainResource) resource.get(), comment);
		saveResource(resource.get());
	}
}
 

public void setStatus(DomainResource resource, ConditionStatus status){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	ConditionClinicalStatus fhirCategoryCode =
		(ConditionClinicalStatus) statusMapping.getFhirEnumValueByEnum(status);
	if (fhirCategoryCode != null) {
		fhirCondition.setClinicalStatus(fhirCategoryCode);
	}
}
 

@Override
public void setMandatorId(String mandatorId){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setMandatorId((DomainResource) resource.get(), mandatorId);
		saveResource(resource.get());
	}
	
	getEntity().setMandatorId(mandatorId);
}
 

public void setCategory(DomainResource resource, ConditionCategory category){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	CodeableConcept categoryCode = new CodeableConcept();
	org.hl7.fhir.dstu3.model.codesystems.ConditionCategory fhirCategoryCode =
		(org.hl7.fhir.dstu3.model.codesystems.ConditionCategory) categoryMapping
			.getFhirEnumValueByEnum(category);
	if (fhirCategoryCode != null) {
		categoryCode
			.setCoding(Collections.singletonList(new Coding(fhirCategoryCode.getSystem(),
				fhirCategoryCode.toCode(), fhirCategoryCode.getDisplay())));
		fhirCondition.setCategory(Collections.singletonList(categoryCode));
	}
}
 

public void setPracticeSetting(DomainResource resource, ICoding coding){
	org.hl7.fhir.dstu3.model.DocumentReference fhirResource =
		(org.hl7.fhir.dstu3.model.DocumentReference) resource;
	DocumentReferenceContextComponent fhirContext = fhirResource.getContext();
	if (fhirContext != null) {
		CodeableConcept codeableConcept = new CodeableConcept();
		ModelUtil.setCodingToConcept(codeableConcept, coding);
		fhirContext.setPracticeSetting(codeableConcept);
	}
}
 

public Map<String, String> getStringExtensions(){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent() && resource.get() instanceof DomainResource) {
		List<Extension> extensions = ((DomainResource) resource.get()).getExtension();
		return extensions.stream()
			.filter(extension -> extension.getValue() instanceof StringType)
			.collect(Collectors.toMap(extension -> extension.getUrl(),
				extension -> ((StringType) extension.getValue()).getValueAsString()));
	}
	return Collections.emptyMap();
}
 

public Optional<LocalDate> getDateRecorded(DomainResource resource){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	Date date = fhirCondition.getAssertedDate();
	if (date != null) {
		return Optional.of(getLocalDate(date));
	}
	return Optional.empty();
}
 

public List<ICoding> getPracticeSetting(DomainResource resource){
	org.hl7.fhir.dstu3.model.DocumentReference fhirResource =
		(org.hl7.fhir.dstu3.model.DocumentReference) resource;
	DocumentReferenceContextComponent fhirContext = fhirResource.getContext();
	if (fhirContext != null) {
		CodeableConcept codeableConcept = fhirContext.getPracticeSetting();
		if (codeableConcept != null) {
			return ModelUtil.getCodingsFromConcept(codeableConcept);
		}
	}
	return Collections.emptyList();
}
 

@Override
public void setDocumentClass(ICoding coding){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		accessor.setDocumentClass((DomainResource) resource.get(), coding);
		saveResource(resource.get());
	}
}
 

@Override
public List<ICondition> getIndication(){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		return accessor.getIndication((DomainResource) resource.get());
	}
	return new ArrayList<>();
}
 

public Optional<String> getText(DomainResource resource){
	Narrative narrative = ((DomainResource) resource).getText();
	if (narrative != null && narrative.getDivAsString() != null) {
		return ModelUtil.getNarrativeAsString(narrative);
	}
	return Optional.empty();
}
 

@Override
public Optional<LocalDateTime> getStartTime(){
	Optional<IBaseResource> resource = loadResource();
	if (resource.isPresent()) {
		return accessor.getStartTime((DomainResource) resource.get());
	}
	return Optional.empty();
}
 

public void removeNote(DomainResource resource, String text){
	org.hl7.fhir.dstu3.model.Condition fhirCondition =
		(org.hl7.fhir.dstu3.model.Condition) resource;
	List<Annotation> notes = new ArrayList<Annotation>(fhirCondition.getNote());
	notes = notes.stream().filter(annotation -> !text.equals(annotation.getText()))
		.collect(Collectors.toList());
	fhirCondition.setNote(notes);
}