import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
/**
 * Converts a set of FHIR resources to JSON.
 *
 * @param dataset a dataset containing FHIR resources
 * @param resourceType the FHIR resource type
 * @return a dataset of JSON strings for the FHIR resources
 */
public static Dataset<String> toJson(Dataset<?> dataset, String resourceType) {

  Dataset<IBaseResource> resourceDataset =
      dataset.as(FhirEncoders.forStu3()
          .getOrCreate()
          .of(resourceType));

  return resourceDataset.map(new ToJson(), Encoders.STRING());
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
private static void deleteServerResources(IGenericClient client, Iterable<Object> resources, String dataType){
	for(Object obj : resources){
		IBaseResource resource = (IBaseResource) obj;
		try{
			//delete existing
			client.delete()
				.resourceConditionalByType(resource.getClass())
				.where(new TokenClientParam("identifier").exactly()
					.systemAndCode("http://mcm.usciitg-prep.org", resource.getIdElement().getIdPart()))
				.execute();
			System.out.println(dataType + ":" + resource.getIdElement().getValue() + " deleted ID:" + resource.getIdElement().getIdPart());
		}catch(Exception e){
			System.out.println(dataType + ":" + resource.getIdElement().getValue() + " deleted: failure" + " ID:" + resource.getIdElement().getIdPart());
		}			
	}
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
/**
 * Returns an encoder for the given FHIR resource.
 *
 * @param type the type of the resource to encode.
 * @param <T> the type of the resource to be encoded.
 * @return an encoder for the resource.
 */
public <T extends IBaseResource> ExpressionEncoder<T> of(Class<T> type) {

  BaseRuntimeElementCompositeDefinition definition =
      context.getResourceDefinition(type);

  synchronized (encoderCache) {

    ExpressionEncoder<T> encoder = encoderCache.get(type);

    if (encoder == null) {

      encoder = (ExpressionEncoder<T>)
          EncoderBuilder.of(definition,
              context,
              new SchemaConverter(context));

      encoderCache.put(type, encoder);
    }

    return encoder;
  }
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
/**
 * Extracts the given resource type from the RDD of bundles and returns
 * it as a Dataset of that type.
 *
 * @param spark the spark session
 * @param bundles an RDD of FHIR Bundles
 * @param resourceName the FHIR name of the resource type to extract
 *     (e.g., condition, patient. etc).
 * @param encoders the Encoders instance defining how the resources are encoded.
 * @param <T> the type of the resource being extracted from the bundles.
 * @return a dataset of the given resource
 */
public static <T extends IBaseResource> Dataset<T> extractEntry(SparkSession spark,
    JavaRDD<Bundle> bundles,
    String resourceName,
    FhirEncoders encoders) {

  RuntimeResourceDefinition def = context.getResourceDefinition(resourceName);

  JavaRDD<T> resourceRdd = bundles.flatMap(new ToResource<T>(def.getName()));

  Encoder<T> encoder = encoders.of((Class<T>) def.getImplementingClass());

  return spark.createDataset(resourceRdd.rdd(), encoder);
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@Override
public <T extends IBaseResource> T fetchResource(FhirContext theContext, Class<T> theClass, String theUri) {
	String resName = myCtx.getResourceDefinition(theClass).getName();
	ourLog.info("Attempting to fetch {} at URL: {}", resName, theUri);
	
	myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.NEVER);
	IGenericClient client = myCtx.newRestfulGenericClient("http://example.com");
	
	T result;
	try {
		result = client.read(theClass, theUri);
	} catch (BaseServerResponseException e) {
		throw new CommandFailureException("FAILURE: "+theUri+" Received HTTP " + e.getStatusCode() + ": " + e.getMessage());
	}
	ourLog.info("Successfully loaded resource");
	return result;
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@Override
public void accept(CSVRecord theRecord) {

    for (IBaseResource resource : resources) {
        if (resource instanceof AllergyIntolerance) {
            AllergyIntolerance allergy = (AllergyIntolerance) resource;
            if (allergy.getIdentifier().size()>0 && theRecord.get("allergy.identifier").equals(allergy.getIdentifier().get(0).getValue())) {
                AllergyIntolerance.AllergyIntoleranceReactionComponent reaction = allergy.addReaction();
                reaction.addManifestation().addCoding()
                        .setSystem(CareConnectSystem.SNOMEDCT)
                        .setDisplay(theRecord.get("reaction.manifestation.display"))
                        .setCode(theRecord.get("reaction.manifestation"));
           //     System.out.println(ctx.newJsonParser().setPrettyPrint(true).encodeResourceToString(allergy));
            }
        }
    }

}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
protected List<Object> extractValues(String paths, IBaseResource instance) {
	List<Object> values = new ArrayList<Object>();
	String[] nextPathsSplit = paths.split("\\|");
	FhirTerser t = this.ctx.newTerser();
	for (String nextPath : nextPathsSplit) {
		String nextPathTrimmed = nextPath.trim();
		try {
			values.addAll(t.getValues(instance, nextPathTrimmed));
		} catch (Exception e) {
			RuntimeResourceDefinition def = this.ctx.getResourceDefinition(instance);
			logger.warn("Failed to index values from path[{}] in resource type[{}]: {}",
					new Object[] { nextPathTrimmed, def.getName(), e.toString(), e });
		}
	}
	return values;
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的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.instance.model.api.IBaseResource; //导入依赖的package包/类
private FhirValidationResult validateFhirRequest(Contents contents) {
    FhirValidationResult result = new FhirValidationResult();
    FhirValidator validator = fhirContext.newValidator();

    IParser parser = newParser(contents.contentType);
    IBaseResource resource = parser.parseResource(contents.content);
    ValidationResult vr = validator.validateWithResult(resource);

    if (vr.isSuccessful()) {
        result.passed = true;
    } else {
        result.passed = false;
        result.operationOutcome = vr.toOperationOutcome();
    }

    return result;
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
private Contents convertBodyForUpstream(Contents contents) {
    String targetContentType = determineTargetContentType(contents.contentType);

    if ("Client".equalsIgnoreCase(upstreamFormat) || isUpstreamAndClientFormatsEqual(contents.contentType)) {
        return new Contents(targetContentType, contents.content);
    }

    log.info("[" + openhimTrxID + "] Converting request body to " + targetContentType);

    IParser inParser = newParser(contents.contentType);
    IBaseResource resource = inParser.parseResource(contents.content);

    if ("JSON".equalsIgnoreCase(upstreamFormat) || "XML".equalsIgnoreCase(upstreamFormat)) {
        IParser outParser = newParser(targetContentType);
        String converted = outParser.setPrettyPrint(true).encodeResourceToString(resource);
        return new Contents(targetContentType, converted);
    } else {
        requestHandler.tell(new ExceptError(new RuntimeException("Unknown upstream format specified " + upstreamFormat)), getSelf());
        return null;
    }
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
private MeasureReport evaluatePatientListMeasure(Measure measure, String practitioner) {
        SearchParameterMap map = new SearchParameterMap();
        map.add("general-practitioner", new ReferenceParam(practitioner));
        IBundleProvider patientProvider = ((PatientResourceProvider) provider.resolveResourceProvider("Patient")).getDao().search(map);
        List<IBaseResource> patientList = patientProvider.getResources(0, patientProvider.size());

        if (patientList.isEmpty()) {
            throw new IllegalArgumentException("No patients were found with practitioner reference " + practitioner);
        }

        List<Patient> patients = new ArrayList<>();
        patientList.forEach(x -> patients.add((Patient) x));

//        context.setContextValue("Population", patients);

        report = evaluator.evaluate(context, measure, patients, measurementPeriod, MeasureReport.MeasureReportType.PATIENTLIST);
        validateReport();
        return report;
    }
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@OnWebSocketMessage
public void onMessage(String theMsg) {
	ourLog.info("Got msg: {}", theMsg);
	if (theMsg.startsWith("bound ")) {
		myGotBound = true;
		mySubsId = (theMsg.substring("bound ".length()));
		myPingCount++;
	} else if (myGotBound && theMsg.startsWith("add " + mySubsId + "\n")) {
		String text = theMsg.substring(("add " + mySubsId + "\n").length());
		IBaseResource res = myEncoding.newParser(myFhirCtx).parseResource(text);
		myReceived.add(res);
		myPingCount++;
	} else {
		myError = "Unexpected message: " + theMsg;
	}
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
public void handleMessage(RestOperationTypeEnum theOperationType, IIdType theId, final IBaseResource theSubscription) throws MessagingException {

		switch (theOperationType) {
			case DELETE:
				mySubscriptionInterceptor.unregisterSubscription(theId);
				return;
			case CREATE:
			case UPDATE:
				if (!theId.getResourceType().equals("Subscription")) {
					return;
				}
				TransactionTemplate txTemplate = new TransactionTemplate(myTransactionManager);
				txTemplate.execute(new TransactionCallbackWithoutResult() {
					@Override
					protected void doInTransactionWithoutResult(TransactionStatus status) {
						activateAndRegisterSubscriptionIfRequired(theSubscription);
					}
				});
				break;
			default:
				break;
		}

	}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
protected IBaseResource addCommonParams(HttpServletRequest theServletRequest, final HomeRequest theRequest, final ModelMap theModel) {
	if (myConfig.getDebugTemplatesMode()) {
		myTemplateEngine.getCacheManager().clearAllCaches();
	}

	final String serverId = theRequest.getServerIdWithDefault(myConfig);
	final String serverBase = theRequest.getServerBase(theServletRequest, myConfig);
	final String serverName = theRequest.getServerName(myConfig);
	final String apiKey = theRequest.getApiKey(theServletRequest, myConfig);
	theModel.put("serverId", serverId);
	theModel.put("base", serverBase);
	theModel.put("baseName", serverName);
	theModel.put("apiKey", apiKey);
	theModel.put("resourceName", defaultString(theRequest.getResource()));
	theModel.put("encoding", theRequest.getEncoding());
	theModel.put("pretty", theRequest.getPretty());
	theModel.put("_summary", theRequest.get_summary());
	theModel.put("serverEntries", myConfig.getIdToServerName());

	return loadAndAddConf(theServletRequest, theRequest, theModel);
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testResources() throws IOException, ClassNotFoundException {
	FhirContext ctx = FhirContext.forDstu2Hl7Org();

	Properties prop = new Properties();
	prop.load(ctx.getVersion().getFhirVersionPropertiesFile());
	for (Entry<Object, Object> next : prop.entrySet()) {
		if (next.getKey().toString().startsWith("resource.")) {
			Class<? extends IBaseResource> clazz = (Class<? extends IBaseResource>) Class.forName(next.getValue().toString());
			RuntimeResourceDefinition res = ctx.getResourceDefinition(clazz);

			scanChildren(new HashSet<Class<?>>(), clazz, res);
		}
	}
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@Test
public void testSearchWithNoResults() {
	Device dev = new Device();
	dev.addIdentifier().setSystem("Foo");
	myDeviceDao.create(dev, mySrd);

	IBundleProvider value = myDeviceDao.search(new SearchParameterMap());
	ourLog.info("Initial size: " + value.size());
	for (IBaseResource next : value.getResources(0, value.size())) {
		ourLog.info("Deleting: {}", next.getIdElement());
		myDeviceDao.delete((IIdType) next.getIdElement(), mySrd);
	}

	value = myDeviceDao.search(new SearchParameterMap());
	if (value.size() > 0) {
		ourLog.info("Found: " + (value.getResources(0, 1).get(0).getIdElement()));
		fail(myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(value.getResources(0, 1).get(0)));
	}
	assertEquals(0, value.size().intValue());

	List<IBaseResource> res = value.getResources(0, 0);
	assertTrue(res.isEmpty());

}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void translateClientArgumentIntoQueryArgument(FhirContext theContext, Object theSourceClientArgument, Map<String, List<String>> theTargetQueryArguments, IBaseResource theTargetResource)
		throws InternalErrorException {
	if (theSourceClientArgument instanceof Collection) {
		StringBuilder values = new StringBuilder();
		for (String next : (Collection<String>) theSourceClientArgument) {
			if (isNotBlank(next)) {
				if (values.length() > 0) {
					values.append(',');
				}
				values.append(next);
			}
		}
		theTargetQueryArguments.put(Constants.PARAM_ELEMENTS, Collections.singletonList(values.toString()));
	} else {
		String elements = (String) theSourceClientArgument;
		if (elements != null) {
			theTargetQueryArguments.put(Constants.PARAM_ELEMENTS, Collections.singletonList(elements));
		}
	}
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
public static <T extends IBaseResource> T apply(FhirContext theCtx, T theResourceToUpdate, String thePatchBody) {
	
	@SuppressWarnings("unchecked")
	Class<T> clazz = (Class<T>) theResourceToUpdate.getClass();
	
	String inputResource = theCtx.newXmlParser().encodeResourceToString(theResourceToUpdate);
	
	ByteArrayOutputStream result = new ByteArrayOutputStream();
	try {
		Patcher.patch(new ByteArrayInputStream(inputResource.getBytes(Constants.CHARSET_UTF8)), new ByteArrayInputStream(thePatchBody.getBytes(Constants.CHARSET_UTF8)), result);
	} catch (IOException e) {
		throw new InternalErrorException(e);
	}
	
	String resultString = new String(result.toByteArray(), Constants.CHARSET_UTF8);
	T retVal = theCtx.newXmlParser().parseResource(clazz, resultString);
	
	return retVal;
}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
@Test
public void testAsyncSearchSmallResultSetSameCoordinator() {
	SearchParameterMap params = new SearchParameterMap();
	params.add("name", new StringParam("ANAME"));

	List<Long> pids = createPidSequence(10, 100);
	SlowIterator<Long> iter = new SlowIterator<Long>(pids.iterator(), 2);
	when(mySearchBuider.createQuery(Mockito.same(params), any(String.class))).thenReturn(iter);

	doAnswer(loadPids()).when(mySearchBuider).loadResourcesByPid(any(List.class), any(List.class), any(Set.class), anyBoolean(), any(EntityManager.class), any(FhirContext.class), same(myCallingDao));

	IBundleProvider result = mySvc.registerSearch(myCallingDao, params, "Patient", new CacheControlDirective());
	assertNotNull(result.getUuid());
	assertEquals(90, result.size().intValue());

	List<IBaseResource> resources = result.getResources(0, 30);
	assertEquals(30, resources.size());
	assertEquals("10", resources.get(0).getIdElement().getValueAsString());
	assertEquals("39", resources.get(29).getIdElement().getValueAsString());

}
 

import org.hl7.fhir.instance.model.api.IBaseResource; //导入依赖的package包/类
public ResourceReferenceInfo(FhirContext theContext, IBaseResource theOwningResource, List<String> thePathToElement, IBaseReference theElement) {
	myContext = theContext;
	myOwningResource = theContext.getResourceDefinition(theOwningResource).getName();

	myResource = theElement;
	if (thePathToElement != null && !thePathToElement.isEmpty()) {
		StringBuilder sb = new StringBuilder();
		thePathToElement.iterator();
		for (Iterator<String> iterator = thePathToElement.iterator(); iterator.hasNext();) {
			sb.append(iterator.next());
			if (iterator.hasNext())
				sb.append(".");
		}
		myName = sb.toString();
	} else {
		myName = null;
	}
}