Java Observation类代码示例

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
/**
 * Returns a FHIR Observation for testing purposes.
 */
public static Observation newObservation() {

  // Observation based on https://www.hl7.org/FHIR/observation-example-bloodpressure.json.html
  Observation observation = new Observation();

  observation.setId("blood-pressure");

  Identifier identifier = observation.addIdentifier();
  identifier.setSystem("urn:ietf:rfc:3986");
  identifier.setValue("urn:uuid:187e0c12-8dd2-67e2-99b2-bf273c878281");

  observation.setStatus(Observation.ObservationStatus.FINAL);

  Quantity quantity = new Quantity();
  quantity.setValue(new java.math.BigDecimal("123.45"));
  quantity.setUnit("mm[Hg]");
  observation.setValue(quantity);

  return observation;
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
/**
 * Set up Spark.
 */
@BeforeClass
public static void setUp() {
  spark = SparkSession.builder()
      .master("local[*]")
      .appName("testing")
      .getOrCreate();

  patientDataset = spark.createDataset(ImmutableList.of(patient),
      encoders.of(Patient.class));
  decodedPatient = patientDataset.head();

  conditionsDataset = spark.createDataset(ImmutableList.of(condition),
      encoders.of(Condition.class));
  decodedCondition = conditionsDataset.head();

  observationsDataset = spark.createDataset(ImmutableList.of(observation),
      encoders.of(Observation.class));
  decodedObservation = observationsDataset.head();

  medDataset = spark.createDataset(ImmutableList.of(medRequest),
      encoders.of(MedicationRequest.class));

  decodedMedRequest = medDataset.head();
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public void loadObservationData() throws Exception {
	IParser parser = ctx.newJsonParser();

	FileReader fileReader = new FileReader(
			new File(this.getClass().getClassLoader().getResource("fhir/observation_example001.json").getPath()));
	IBaseResource resource = parser.parseResource(fileReader);

	for (int i = 0; i < 1; i++) {

		resource.getIdElement().setValue("obs_" + i);
		((Observation) resource).getIdentifier().get(0).setValue("urn:uuid:187e0c12-8dd2-67e2-99b2-bf273c1111" + i);

		String json = parser.encodeResourceToString(resource);

		long timestamp = Calendar.getInstance().getTimeInMillis();
		session.execute(
				"INSERT INTO test.FHIR_RESOURCES (resource_id, version, resource_type, state, lastupdated, format, author, content)"
						+ " VALUES ('" + resource.getIdElement().getValue() + "', 1, '"
						+ resource.getClass().getSimpleName() + "', 'active', " + timestamp + ", 'json', 'dr who',"
						+ "'" + json + "')");

		System.out.println(resource.getClass().getSimpleName() + ": " + resource.getIdElement().getValue());
	}
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
protected SectionComponent processProceduresSection(Element section) throws Exception {
	ListResource list = new ListResource();
	for (Element entry : cda.getChildren(section, "entry")) {
		Element procedure = cda.getlastChild(entry);

		if (cda.hasTemplateId(procedure, "2.16.840.1.113883.10.20.22.4.14")) {
			processProcedure(list, procedure, ProcedureType.Procedure);
		} else if (cda.hasTemplateId(procedure, "2.16.840.1.113883.10.20.22.4.13")) {
			processProcedure(list, procedure, ProcedureType.Observation);
		} else if (cda.hasTemplateId(procedure, "2.16.840.1.113883.10.20.22.4.12")) {
			processProcedure(list, procedure, ProcedureType.Act);
		} else
			throw new Exception("Unhandled Section template ids: "+cda.showTemplateIds(procedure));
	}

	// todo: text
	SectionComponent s = new Composition.SectionComponent();
	s.setCode(convert.makeCodeableConceptFromCD(cda.getChild(section,  "code")));
	// todo: check subject
	s.addEntry(Factory.makeReference(addReference(list, "Procedures", makeUUIDReference())));
	return s;

}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
List<Observation> search (FhirContext ctx,
@OptionalParam(name= Observation.SP_CATEGORY) TokenParam category,
@OptionalParam(name= Observation.SP_CODE) TokenParam code,
@OptionalParam(name= Observation.SP_DATE) DateRangeParam effectiveDate,
@OptionalParam(name = Observation.SP_PATIENT) ReferenceParam patient
,@OptionalParam(name = Observation.SP_IDENTIFIER) TokenParam identifier
,@OptionalParam(name= Observation.SP_RES_ID) TokenParam id
);
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
List<ObservationEntity> searchEntity (FhirContext ctx,
                          @OptionalParam(name= Observation.SP_CATEGORY) TokenParam category,
                          @OptionalParam(name= Observation.SP_CODE) TokenParam code,
                          @OptionalParam(name= Observation.SP_DATE) DateRangeParam effectiveDate,
                          @OptionalParam(name = Observation.SP_PATIENT) ReferenceParam patient
        ,@OptionalParam(name = Observation.SP_IDENTIFIER) TokenParam identifier
        ,@OptionalParam(name= Observation.SP_RES_ID) TokenParam id
);
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
@Read
public Observation getObservationById(@IdParam IdType internalId) {
    Observation observation = observationDao.read(ctx,internalId);

    if (observation == null) {
        throw OperationOutcomeFactory.buildOperationOutcomeException(
                new ResourceNotFoundException("No observation found for ID: " + internalId.getIdPart()),
                OperationOutcome.IssueSeverity.ERROR, OperationOutcome.IssueType.NOTFOUND);
    }
    return observation;
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
@Search
public List<Observation> search(HttpServletRequest theRequest,

                                @OptionalParam(name= Observation.SP_CATEGORY) TokenParam category,
                                @OptionalParam(name= Observation.SP_CODE) TokenParam code,
                                @OptionalParam(name= Observation.SP_DATE) DateRangeParam effectiveDate,
                                @OptionalParam(name = Observation.SP_PATIENT) ReferenceParam patient,
                                @OptionalParam(name = Observation.SP_IDENTIFIER) TokenParam identifier
        , @OptionalParam(name = Observation.SP_RES_ID) TokenParam resid
                                   ) {
    return observationDao.search(ctx,category, code, effectiveDate,patient, identifier,resid);
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
@Test
public void testTransformObservationEntity(){
    ObservationEntity observationEntity = new ObservationEntityBuilder()
            .build();
    Observation observation = transformer.transform(observationEntity);
    assertThat(observation, not(nullValue()));
    assertThat(observation.getId(), not(nullValue()));
    assertThat(observation.getId(), equalTo((new Long(ObservationEntityBuilder.DEFAULT_ID)).toString()));
    assertThat(observation.getSubject(), not(nullValue()));
    assertThat(observation.getSubject().getReference(), equalTo("Patient/100002"));
    assertThat(observation.getEffective(), not(nullValue()));
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public List<Observation.ObservationRelatedComponent> getRelated()
{
   try
   {
      return adaptedClass.getRelated();
   }
   catch (Exception e)
   {
      throw new RuntimeException("Error getting Related", e);
   }
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public List<Observation.ObservationComponentComponent> getComponent()
{
   try
   {
      return adaptedClass.getComponent();
   }
   catch (Exception e)
   {
      throw new RuntimeException("Error getting Component", e);
   }
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public Observation.ObservationStatus getStatus()
{
   try
   {
      return adaptedClass.getStatus();
   }
   catch (Exception e)
   {
      throw new RuntimeException("Error getting Status", e);
   }
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public Enumeration<Observation.ObservationStatus> getStatusElement()
{
   try
   {
      return adaptedClass.getStatusElement();
   }
   catch (Exception e)
   {
      throw new RuntimeException("Error getting StatusElement", e);
   }
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
public List<Observation.ObservationReferenceRangeComponent> getReferenceRange()
{
   try
   {
      return adaptedClass.getReferenceRange();
   }
   catch (Exception e)
   {
      throw new RuntimeException("Error getting ReferenceRange", e);
   }
}
 

import org.hl7.fhir.dstu3.model.Observation; //导入依赖的package包/类
@Override
public List<IAuthRule> buildRuleList(RequestDetails theRequestDetails) {

   // Process this header
   String authHeader = theRequestDetails.getHeader("Authorization");

   RuleBuilder builder = new RuleBuilder();
   builder
      .allow().metadata().andThen()
      .allow().read().allResources().withAnyId().andThen()
      .allow().write().resourcesOfType(Observation.class).inCompartment("Patient", new IdType("Patient/123"));

   return builder.build();
}