Working on patch

hapi-fhir-base/pom.xml

@@ -20,9 +20,9 @@
 
 		<!-- JSON -->
 		<dependency>
-		    <groupId>com.google.code.gson</groupId>
-		    <artifactId>gson</artifactId>
-		    <version>2.7</version>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>2.7</version>
 		</dependency>
 
 		<!-- XML -->

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/annotation/Delete.java

@@ -25,6 +25,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import org.hl7.fhir.instance.model.api.IBaseResource;
+
 import ca.uhn.fhir.model.api.IResource;
 
 /**
@@ -47,5 +49,5 @@ public @interface Delete {
 	 * for client implementations. 
 	 */
 	// NB: Read, Search (maybe others) share this annotation, so update the javadocs everywhere
-	Class<? extends IResource> type() default IResource.class;	
+	Class<? extends IBaseResource> type() default IBaseResource.class;	
 }

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/annotation/Patch.java

@@ -0,0 +1,53 @@
+package ca.uhn.fhir.rest.annotation;
+
+import java.lang.annotation.ElementType;
+
+/*
+ * #%L
+ * HAPI FHIR - Core Library
+ * %%
+ * Copyright (C) 2014 - 2016 University Health Network
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.hl7.fhir.instance.model.api.IBaseResource;
+
+/**
+ * RESTful method annotation to be used for the proposed FHIR
+ * PATCH method
+ * 
+ * <p>
+ * Patch is used to apply a differential to a resource in either
+ * XML or JSON format
+ * </p>
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.METHOD })
+public @interface Patch {
+
+	/**
+	 * The return type for this search method. This generally does not need
+	 * to be populated for a server implementation, since servers will return
+	 * only one resource per class, but generally does need to be populated
+	 * for client implementations.
+	 */
+	// NB: Read, Search (maybe others) share this annotation, so update the javadocs everywhere
+	Class<? extends IBaseResource> type() default IBaseResource.class;
+
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/api/PatchTypeEnum.java

@@ -0,0 +1,23 @@
+package ca.uhn.fhir.rest.api;
+
+import ca.uhn.fhir.rest.annotation.Patch;
+import ca.uhn.fhir.rest.server.Constants;
+
+/**
+ * Parameter type for methods annotated with {@link Patch}
+ */
+public enum PatchTypeEnum {
+
+	JSON_PATCH(Constants.CT_JSON_PATCH), XML_PATCH(Constants.CT_XML_PATCH);
+
+	private final String myContentType;
+
+	PatchTypeEnum(String theContentType) {
+		myContentType = theContentType;
+	}
+
+	public String getContentType() {
+		return myContentType;
+	}
+
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/api/RestOperationTypeEnum.java

@@ -130,7 +130,12 @@ public enum RestOperationTypeEnum {
 	/**
 	 * $meta-delete extended operation
 	 */
-	META_DELETE("$meta-delete"),
+	META_DELETE("$meta-delete"), 
+	
+	/**
+	 * Patch operation
+	 */
+	PATCH("patch"),
 
 	;
 

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/client/apache/ApacheHttpClient.java

@@ -30,12 +30,7 @@ import org.apache.http.HttpEntity;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
-import org.apache.http.client.methods.HttpDelete;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpOptions;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.client.methods.HttpPut;
-import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.client.methods.*;
 import org.apache.http.entity.ByteArrayEntity;
 import org.apache.http.message.BasicNameValuePair;
 import org.hl7.fhir.instance.model.api.IBaseBinary;
@@ -188,6 +183,10 @@ public class ApacheHttpClient implements IHttpClient {
 		switch (myRequestType) {
 		case DELETE:
 			return new HttpDelete(url);
+		case PATCH:
+			HttpPatch httpPatch = new HttpPatch(url);
+			httpPatch.setEntity(theEntity);
+			return httpPatch;
 		case OPTIONS:
 			return new HttpOptions(url);
 		case POST:

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseMethodBinding.java

@@ -46,20 +46,7 @@ import ca.uhn.fhir.model.api.Include;
 import ca.uhn.fhir.model.api.TagList;
 import ca.uhn.fhir.model.base.resource.BaseOperationOutcome;
 import ca.uhn.fhir.parser.IParser;
-import ca.uhn.fhir.rest.annotation.AddTags;
-import ca.uhn.fhir.rest.annotation.Create;
-import ca.uhn.fhir.rest.annotation.Delete;
-import ca.uhn.fhir.rest.annotation.DeleteTags;
-import ca.uhn.fhir.rest.annotation.GetPage;
-import ca.uhn.fhir.rest.annotation.GetTags;
-import ca.uhn.fhir.rest.annotation.History;
-import ca.uhn.fhir.rest.annotation.Metadata;
-import ca.uhn.fhir.rest.annotation.Operation;
-import ca.uhn.fhir.rest.annotation.Read;
-import ca.uhn.fhir.rest.annotation.Search;
-import ca.uhn.fhir.rest.annotation.Transaction;
-import ca.uhn.fhir.rest.annotation.Update;
-import ca.uhn.fhir.rest.annotation.Validate;
+import ca.uhn.fhir.rest.annotation.*;
 import ca.uhn.fhir.rest.api.MethodOutcome;
 import ca.uhn.fhir.rest.api.RestOperationTypeEnum;
 import ca.uhn.fhir.rest.client.BaseHttpClientInvocation;
@@ -387,9 +374,10 @@ public abstract class BaseMethodBinding<T> implements IClientResponseHandler<T>
 		Transaction transaction = theMethod.getAnnotation(Transaction.class);
 		Operation operation = theMethod.getAnnotation(Operation.class);
 		GetPage getPage = theMethod.getAnnotation(GetPage.class);
+		Patch patch = theMethod.getAnnotation(Patch.class);
 
 		// ** if you add another annotation above, also add it to the next line:
-		if (!verifyMethodHasZeroOrOneOperationAnnotation(theMethod, read, search, conformance, create, update, delete, history, validate, getTags, addTags, deleteTags, transaction, operation, getPage)) {
+		if (!verifyMethodHasZeroOrOneOperationAnnotation(theMethod, read, search, conformance, create, update, delete, history, validate, getTags, addTags, deleteTags, transaction, operation, getPage, patch)) {
 			return null;
 		}
 
@@ -448,6 +436,8 @@ public abstract class BaseMethodBinding<T> implements IClientResponseHandler<T>
 			returnTypeFromAnnotation = history.type();
 		} else if (delete != null) {
 			returnTypeFromAnnotation = delete.type();
+		} else if (patch != null) {
+			returnTypeFromAnnotation = patch.type();
 		} else if (create != null) {
 			returnTypeFromAnnotation = create.type();
 		} else if (update != null) {
@@ -513,6 +503,8 @@ public abstract class BaseMethodBinding<T> implements IClientResponseHandler<T>
 			return new UpdateMethodBinding(theMethod, theContext, theProvider);
 		} else if (delete != null) {
 			return new DeleteMethodBinding(theMethod, theContext, theProvider);
+		} else if (patch != null) {
+			return new PatchMethodBinding(theMethod, theContext, theProvider);
 		} else if (history != null) {
 			return new HistoryMethodBinding(theMethod, theContext, theProvider);
 		} else if (validate != null) {

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseOutcomeReturningMethodBinding.java

@@ -184,8 +184,15 @@ abstract class BaseOutcomeReturningMethodBinding extends BaseMethodBinding<Metho
 		 * on them
 		 */
 		MethodOutcome response;
-		response = (MethodOutcome) invokeServerMethod(theServer, theRequest, params);
-
+		Object methodReturn = invokeServerMethod(theServer, theRequest, params);
+		
+		if (methodReturn instanceof IBaseOperationOutcome) {
+			response = new MethodOutcome();
+			response.setOperationOutcome((IBaseOperationOutcome) methodReturn);
+		} else {
+			response = (MethodOutcome) methodReturn;
+		}
+		
 		if (response != null && response.getId() != null && response.getId().hasResourceType()) {
 			if (getContext().getResourceDefinition(response.getId().getResourceType()) == null) {
 				throw new InternalErrorException("Server method returned invalid resource ID: " + response.getId().getValue());

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseOutcomeReturningMethodBindingWithResourceIdButNoResourceBody.java

@@ -0,0 +1,60 @@
+package ca.uhn.fhir.rest.method;
+
+import java.lang.reflect.Method;
+
+import org.hl7.fhir.instance.model.api.IBaseResource;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.context.RuntimeResourceDefinition;
+import ca.uhn.fhir.model.api.IResource;
+import ca.uhn.fhir.rest.annotation.Delete;
+import ca.uhn.fhir.rest.annotation.IdParam;
+import ca.uhn.fhir.rest.annotation.VersionIdParam;
+import ca.uhn.fhir.rest.server.IResourceProvider;
+
+public abstract class BaseOutcomeReturningMethodBindingWithResourceIdButNoResourceBody extends BaseOutcomeReturningMethodBinding {
+
+	private String myResourceName;
+	private Integer myIdParameterIndex;
+
+	public BaseOutcomeReturningMethodBindingWithResourceIdButNoResourceBody(Method theMethod, FhirContext theContext, Object theProvider, Class<?> theMethodAnnotationType, Class<? extends IBaseResource> theResourceTypeFromAnnotation) {
+		super(theMethod, theContext, theMethodAnnotationType, theProvider);
+
+		Class<? extends IBaseResource> resourceType = theResourceTypeFromAnnotation;
+		if (resourceType != IResource.class) {
+			RuntimeResourceDefinition def = theContext.getResourceDefinition(resourceType);
+			myResourceName = def.getName();
+		} else {
+			if (theProvider != null && theProvider instanceof IResourceProvider) {
+				RuntimeResourceDefinition def = theContext.getResourceDefinition(((IResourceProvider) theProvider).getResourceType());
+				myResourceName = def.getName();
+			} else {
+				throw new ConfigurationException(
+						"Can not determine resource type for method '" + theMethod.getName() + "' on type " + theMethod.getDeclaringClass().getCanonicalName() + " - Did you forget to include the resourceType() value on the @" + Delete.class.getSimpleName() + " method annotation?");
+			}
+		}
+
+		myIdParameterIndex = MethodUtil.findIdParameterIndex(theMethod, getContext());
+		if (myIdParameterIndex == null) {
+			throw new ConfigurationException("Method '" + theMethod.getName() + "' on type '" + theMethod.getDeclaringClass().getCanonicalName() + "' has no parameter annotated with the @" + IdParam.class.getSimpleName() + " annotation");
+		}
+
+		Integer versionIdParameterIndex = MethodUtil.findVersionIdParameterIndex(theMethod);
+		if (versionIdParameterIndex != null) {
+			throw new ConfigurationException("Method '" + theMethod.getName() + "' on type '" + theMethod.getDeclaringClass().getCanonicalName() + "' has a parameter annotated with the @" + VersionIdParam.class.getSimpleName() + " annotation but delete methods may not have this annotation");
+		}
+
+	}
+
+	@Override
+	public String getResourceName() {
+		return myResourceName;
+	}
+
+	protected Integer getIdParameterIndex() {
+		return myIdParameterIndex;
+	}
+
+
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/DeleteMethodBinding.java

@@ -10,7 +10,7 @@ package ca.uhn.fhir.rest.method;
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
- *      http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -28,59 +28,19 @@ import java.util.Set;
 
 import org.hl7.fhir.instance.model.api.IIdType;
 
-import ca.uhn.fhir.context.ConfigurationException;
 import ca.uhn.fhir.context.FhirContext;
-import ca.uhn.fhir.context.RuntimeResourceDefinition;
 import ca.uhn.fhir.model.api.IResource;
-import ca.uhn.fhir.model.primitive.IdDt;
 import ca.uhn.fhir.rest.annotation.Delete;
-import ca.uhn.fhir.rest.annotation.IdParam;
-import ca.uhn.fhir.rest.annotation.VersionIdParam;
 import ca.uhn.fhir.rest.api.RequestTypeEnum;
 import ca.uhn.fhir.rest.api.RestOperationTypeEnum;
 import ca.uhn.fhir.rest.client.BaseHttpClientInvocation;
-import ca.uhn.fhir.rest.server.IResourceProvider;
 import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
 import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
 
-public class DeleteMethodBinding extends BaseOutcomeReturningMethodBinding {
-
-	private String myResourceName;
-	private Integer myIdParameterIndex;
+public class DeleteMethodBinding extends BaseOutcomeReturningMethodBindingWithResourceIdButNoResourceBody {
 
 	public DeleteMethodBinding(Method theMethod, FhirContext theContext, Object theProvider) {
-		super(theMethod, theContext, Delete.class, theProvider);
-
-		Delete deleteAnnotation = theMethod.getAnnotation(Delete.class);
-		Class<? extends IResource> resourceType = deleteAnnotation.type();
-		if (resourceType != IResource.class) {
-			RuntimeResourceDefinition def = theContext.getResourceDefinition(resourceType);
-			myResourceName = def.getName();
-		} else {
-			if (theProvider != null && theProvider instanceof IResourceProvider) {
-				RuntimeResourceDefinition def = theContext.getResourceDefinition(((IResourceProvider) theProvider).getResourceType());
-				myResourceName = def.getName();
-			} else {
-				throw new ConfigurationException(
-						"Can not determine resource type for method '" + theMethod.getName() + "' on type " + theMethod.getDeclaringClass().getCanonicalName() + " - Did you forget to include the resourceType() value on the @" + Delete.class.getSimpleName() + " method annotation?");
-			}
-		}
-
-		myIdParameterIndex = MethodUtil.findIdParameterIndex(theMethod, getContext());
-		if (myIdParameterIndex == null) {
-			throw new ConfigurationException("Method '" + theMethod.getName() + "' on type '" + theMethod.getDeclaringClass().getCanonicalName() + "' has no parameter annotated with the @" + IdParam.class.getSimpleName() + " annotation");
-		}
-
-		Integer versionIdParameterIndex = MethodUtil.findVersionIdParameterIndex(theMethod);
-		if (versionIdParameterIndex != null) {
-			throw new ConfigurationException("Method '" + theMethod.getName() + "' on type '" + theMethod.getDeclaringClass().getCanonicalName() + "' has a parameter annotated with the @" + VersionIdParam.class.getSimpleName() + " annotation but delete methods may not have this annotation");
-		}
-
-	}
-
-	@Override
-	protected boolean allowVoidReturnType() {
-		return true;
+		super(theMethod, theContext, theProvider, Delete.class, theMethod.getAnnotation(Delete.class).type());
 	}
 
 	@Override
@@ -102,13 +62,13 @@ public class DeleteMethodBinding extends BaseOutcomeReturningMethodBinding {
 	}
 
 	@Override
-	public String getResourceName() {
-		return myResourceName;
+	protected boolean allowVoidReturnType() {
+		return true;
 	}
 
 	@Override
 	public BaseHttpClientInvocation invokeClient(Object[] theArgs) throws InternalErrorException {
-		IdDt idDt = (IdDt) theArgs[myIdParameterIndex];
+		IIdType idDt = (IIdType) theArgs[getIdParameterIndex()];
 		if (idDt == null) {
 			throw new NullPointerException("ID can not be null");
 		}
@@ -136,7 +96,7 @@ public class DeleteMethodBinding extends BaseOutcomeReturningMethodBinding {
 
 	@Override
 	protected void addParametersForServerRequest(RequestDetails theRequest, Object[] theParams) {
-		theParams[myIdParameterIndex] = theRequest.getId();
+		theParams[getIdParameterIndex()] = theRequest.getId();
 	}
 
 	@Override

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/HttpDeleteClientInvocation.java

@@ -67,4 +67,10 @@ public class HttpDeleteClientInvocation extends BaseHttpClientInvocation {
 		return createHttpRequest(b.toString(), theEncoding, RequestTypeEnum.DELETE);
 	}
 
+	@Override
+	protected IHttpRequest createHttpRequest(String theUrl, EncodingEnum theEncoding, RequestTypeEnum theRequestType) {
+		// TODO Auto-generated method stub
+		return super.createHttpRequest(theUrl, theEncoding, theRequestType);
+	}
+
 }

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/HttpPatchClientInvocation.java

@@ -0,0 +1,84 @@
+package ca.uhn.fhir.rest.method;
+
+/*
+ * #%L
+ * HAPI FHIR - Core Library
+ * %%
+ * Copyright (C) 2014 - 2016 University Health Network
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+import java.util.List;
+import java.util.Map;
+
+import org.hl7.fhir.instance.model.api.IIdType;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.rest.api.RequestTypeEnum;
+import ca.uhn.fhir.rest.client.BaseHttpClientInvocation;
+import ca.uhn.fhir.rest.client.api.IHttpClient;
+import ca.uhn.fhir.rest.client.api.IHttpRequest;
+import ca.uhn.fhir.rest.server.EncodingEnum;
+
+public class HttpPatchClientInvocation extends BaseHttpClientInvocation {
+
+	private String myUrlPath;
+	private Map<String, List<String>> myParams;
+	private String myContents;
+	private String myContentType;
+
+	public HttpPatchClientInvocation(FhirContext theContext, IIdType theId, String theContentType, String theContents) {
+		super(theContext);
+		myUrlPath = theId.toUnqualifiedVersionless().getValue();
+		myContentType = theContentType;
+		myContents = theContents;
+	}
+//
+//	public HttpDeleteClientInvocation(FhirContext theContext, String theSearchUrl) {
+//		super(theContext);
+//		myUrlPath = theSearchUrl;
+//	}
+//
+//	public HttpDeleteClientInvocation(FhirContext theContext, String theResourceType, Map<String, List<String>> theParams) {
+//		super(theContext);
+//		myUrlPath = theResourceType;
+//		myParams = theParams;
+//	}
+
+	@Override
+	public IHttpRequest asHttpRequest(String theUrlBase, Map<String, List<String>> theExtraParams, EncodingEnum theEncoding, Boolean thePrettyPrint) {
+		StringBuilder b = new StringBuilder();
+		b.append(theUrlBase);
+		if (!theUrlBase.endsWith("/")) {
+			b.append('/');
+		}
+		b.append(myUrlPath);
+
+		appendExtraParamsWithQuestionMark(myParams, b, b.indexOf("?") == -1);
+		appendExtraParamsWithQuestionMark(theExtraParams, b, b.indexOf("?") == -1);
+
+		
+		
+		return createHttpRequest(b.toString(), theEncoding, RequestTypeEnum.PATCH);
+	}
+
+	@Override
+	protected IHttpRequest createHttpRequest(String theUrl, EncodingEnum theEncoding, RequestTypeEnum theRequestType) {
+		IHttpClient httpClient = getRestfulClientFactory().getHttpClient(new StringBuilder(theUrl), null, null, theRequestType, getHeaders());
+		return httpClient.createByteRequest(getContext(), myContents, myContentType, null);
+	}
+
+	
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/MethodUtil.java

@@ -22,10 +22,7 @@ import ca.uhn.fhir.model.primitive.IdDt;
 import ca.uhn.fhir.model.primitive.InstantDt;
 import ca.uhn.fhir.parser.IParser;
 import ca.uhn.fhir.rest.annotation.*;
-import ca.uhn.fhir.rest.api.MethodOutcome;
-import ca.uhn.fhir.rest.api.RestOperationTypeEnum;
-import ca.uhn.fhir.rest.api.SummaryEnum;
-import ca.uhn.fhir.rest.api.ValidationModeEnum;
+import ca.uhn.fhir.rest.api.*;
 import ca.uhn.fhir.rest.client.BaseHttpClientInvocation;
 import ca.uhn.fhir.rest.method.OperationParameter.IOperationParamConverter;
 import ca.uhn.fhir.rest.param.*;
@@ -364,6 +361,8 @@ public class MethodUtil {
 				param = new RequestOperationCallbackParameter();
 			} else if (parameterType.equals(SummaryEnum.class)) {
 				param = new SummaryEnumParameter();
+			} else if (parameterType.equals(PatchTypeEnum.class)) {
+				param = new PatchTypeParameter();
 			} else {
 				for (int i = 0; i < annotations.length && param == null; i++) {
 					Annotation nextAnnotation = annotations[i];

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/PatchMethodBinding.java

@@ -0,0 +1,129 @@
+package ca.uhn.fhir.rest.method;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+import org.apache.commons.lang3.Validate;
+import org.hl7.fhir.instance.model.api.IIdType;
+import org.springframework.beans.factory.xml.ResourceEntityResolver;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.model.api.IResource;
+import ca.uhn.fhir.rest.annotation.Patch;
+import ca.uhn.fhir.rest.annotation.ResourceParam;
+import ca.uhn.fhir.rest.api.PatchTypeEnum;
+import ca.uhn.fhir.rest.api.RequestTypeEnum;
+import ca.uhn.fhir.rest.api.RestOperationTypeEnum;
+import ca.uhn.fhir.rest.client.BaseHttpClientInvocation;
+import ca.uhn.fhir.rest.server.Constants;
+import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
+import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
+
+/**
+ * Base class for an operation that has a resource type but not a resource body in the
+ * request body
+ *
+ */
+public class PatchMethodBinding extends BaseOutcomeReturningMethodBindingWithResourceIdButNoResourceBody {
+
+	private int myPatchTypeParameterIndex = -1;
+	private int myResourceParamIndex;
+
+	public PatchMethodBinding(Method theMethod, FhirContext theContext, Object theProvider) {
+		super(theMethod, theContext, theProvider, Patch.class, theMethod.getAnnotation(Patch.class).type());
+
+		for (ListIterator<Parameter> iter = Arrays.asList(theMethod.getParameters()).listIterator(); iter.hasNext();) {
+			int nextIndex = iter.nextIndex();
+			Parameter next = iter.next();
+			if (next.getType().equals(PatchTypeEnum.class)) {
+				myPatchTypeParameterIndex = nextIndex;
+			}
+			if (next.getAnnotation(ResourceParam.class) != null) {
+				myResourceParamIndex = nextIndex;
+			}
+		}
+
+		if (myPatchTypeParameterIndex == -1) {
+			throw new ConfigurationException("Method has no parameter of type " + PatchTypeEnum.class.getName() + " - " + theMethod.toString());
+		}
+		if (myResourceParamIndex == -1) {
+			throw new ConfigurationException("Method has no parameter with @" + ResourceParam.class.getSimpleName() + " annotation - " + theMethod.toString());
+		}
+	}
+
+	@Override
+	public boolean incomingServerRequestMatchesMethod(RequestDetails theRequest) {
+		boolean retVal = super.incomingServerRequestMatchesMethod(theRequest);
+		if (retVal) {
+			PatchTypeParameter.getTypeForRequestOrThrowInvalidRequestException(theRequest);
+		}
+		return retVal;
+	}
+
+	@Override
+	public RestOperationTypeEnum getRestOperationType() {
+		return RestOperationTypeEnum.PATCH;
+	}
+
+	@Override
+	protected Set<RequestTypeEnum> provideAllowableRequestTypes() {
+		return Collections.singleton(RequestTypeEnum.PATCH);
+	}
+
+	@Override
+	protected BaseHttpClientInvocation createClientInvocation(Object[] theArgs, IResource theResource) {
+		StringBuilder urlExtension = new StringBuilder();
+		urlExtension.append(getContext().getResourceDefinition(theResource).getName());
+
+		return new HttpPostClientInvocation(getContext(), theResource, urlExtension.toString());
+	}
+
+	@Override
+	protected boolean allowVoidReturnType() {
+		return true;
+	}
+
+	@Override
+	public BaseHttpClientInvocation invokeClient(Object[] theArgs) throws InternalErrorException {
+		IIdType idDt = (IIdType) theArgs[getIdParameterIndex()];
+		if (idDt == null) {
+			throw new NullPointerException("ID can not be null");
+		}
+
+		if (idDt.hasResourceType() == false) {
+			idDt = idDt.withResourceType(getResourceName());
+		} else if (getResourceName().equals(idDt.getResourceType()) == false) {
+			throw new InvalidRequestException("ID parameter has the wrong resource type, expected '" + getResourceName() + "', found: " + idDt.getResourceType());
+		}
+
+		PatchTypeEnum patchType = (PatchTypeEnum) theArgs[myPatchTypeParameterIndex];
+		String body = (String) theArgs[myResourceParamIndex];
+		
+		HttpPatchClientInvocation retVal = createPatchInvocation(getContext(), idDt, patchType, body);
+		
+		for (int idx = 0; idx < theArgs.length; idx++) {
+			IParameter nextParam = getParameters().get(idx);
+			nextParam.translateClientArgumentIntoQueryArgument(getContext(), theArgs[idx], null, null);
+		}
+
+		return retVal;
+	}
+
+	public static HttpPatchClientInvocation createPatchInvocation(FhirContext theContext, IIdType theId, PatchTypeEnum thePatchType, String theBody) {
+		HttpPatchClientInvocation retVal = new HttpPatchClientInvocation(theContext, theId, thePatchType.getContentType(), theBody);
+		return retVal;
+	}
+
+	@Override
+	protected void addParametersForServerRequest(RequestDetails theRequest, Object[] theParams) {
+		theParams[getIdParameterIndex()] = theRequest.getId();
+	}
+
+	@Override
+	protected String getMatchingOperation() {
+		return null;
+	}
+
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/PatchTypeParameter.java

@@ -0,0 +1,72 @@
+package ca.uhn.fhir.rest.method;
+
+import static org.apache.commons.lang3.StringUtils.defaultString;
+
+/*
+ * #%L
+ * HAPI FHIR - Core Library
+ * %%
+ * Copyright (C) 2014 - 2016 University Health Network
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import org.hl7.fhir.instance.model.api.IBaseResource;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.rest.api.PatchTypeEnum;
+import ca.uhn.fhir.rest.server.Constants;
+import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
+import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
+import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
+
+class PatchTypeParameter implements IParameter {
+	@Override
+	public void translateClientArgumentIntoQueryArgument(FhirContext theContext, Object theSourceClientArgument, Map<String, List<String>> theTargetQueryArguments, IBaseResource theTargetResource) throws InternalErrorException {
+		// nothing
+	}
+
+	@Override
+	public Object translateQueryParametersIntoServerArgument(RequestDetails theRequest, BaseMethodBinding<?> theMethodBinding) throws InternalErrorException, InvalidRequestException {
+		return getTypeForRequestOrThrowInvalidRequestException(theRequest);
+	}
+
+	@Override
+	public void initializeTypes(Method theMethod, Class<? extends Collection<?>> theOuterCollectionType, Class<? extends Collection<?>> theInnerCollectionType, Class<?> theParameterType) {
+		// ignore
+	}
+
+	public static PatchTypeEnum getTypeForRequestOrThrowInvalidRequestException(RequestDetails theRequest) {
+		String contentTypeAll = defaultString(theRequest.getHeader(Constants.HEADER_CONTENT_TYPE));
+		String contentType = contentTypeAll;
+		int semiColonIdx = contentType.indexOf(';');
+		if (semiColonIdx != -1) {
+			contentType = contentTypeAll.substring(0, semiColonIdx);
+		}
+		contentType = contentType.trim();
+		if (Constants.CT_JSON_PATCH.equals(contentType)) {
+			return PatchTypeEnum.JSON_PATCH;
+		} else if (Constants.CT_XML_PATCH.equals(contentType)) {
+			return PatchTypeEnum.XML_PATCH;
+		} else {
+			throw new InvalidRequestException("Invalid Content-Type for PATCH operation: " + contentTypeAll);
+		}
+	}
+
+}

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/ServletRequestParameter.java

@@ -35,6 +35,10 @@ import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
 class ServletRequestParameter implements IParameter {
 	private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(ServletRequestParameter.class);
 
+	ServletRequestParameter() {
+		super();
+	}
+	
 	@Override
 	public void translateClientArgumentIntoQueryArgument(FhirContext theContext, Object theSourceClientArgument, Map<String, List<String>> theTargetQueryArguments, IBaseResource theTargetResource) throws InternalErrorException {
 		/*

hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/Constants.java

@@ -168,6 +168,8 @@ public class Constants {
 	public static final String TAG_SUBSETTED_SYSTEM = "http://hl7.org/fhir/v3/ObservationValue";
 	public static final String URL_TOKEN_HISTORY = "_history";
 	public static final String URL_TOKEN_METADATA = "metadata";
+	public static final String CT_JSON_PATCH = "application/json-patch+json";
+	public static final String CT_XML_PATCH = "application/xml-patch+xml";
 
 	static {
 		CHARSET_UTF8 = Charset.forName(CHARSET_NAME_UTF8);

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/.classpath

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/.gitignore

@@ -0,0 +1,128 @@
+/target
+/jpaserver_derby_files
+*.log
+ca.uhn.fhir.jpa.entity.ResourceTable/
+
+# Created by https://www.gitignore.io
+
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+
+### Maven ###
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+
+
+### Vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+
+
+
+### Eclipse ###
+*.pydevproject
+.metadata
+.gradle
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.loadpath
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# CDT-specific
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+
+# PDT-specific
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# TeXlipse plugin
+.texlipse
+

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,5 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.6

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/pom.xml

@@ -0,0 +1,229 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<!-- 
+	Note: HAPI projects use the "hapi-fhir" POM as their base to provide easy management. 
+	You do not need to use this in your own projects, so the "parent" tag and it's 
+	contents below may be removed 
+	if you are using this file as a basis for your own project. 
+	-->
+	<parent>
+		<groupId>ca.uhn.hapi.fhir</groupId>
+		<artifactId>hapi-fhir</artifactId>
+		<version>2.1-SNAPSHOT</version>
+		<relativePath>../../pom.xml</relativePath>
+	</parent>
+	
+	<groupId>ca.uhn.hapi.fhir.example</groupId>
+	<artifactId>hapi-fhir-jpaserver-example-postgres</artifactId>
+	<packaging>war</packaging>
+
+	<name>HAPI FHIR JPA Server - Example (Postgres)</name>
+
+	<dependencies>
+
+		<!-- This dependency includes the core HAPI-FHIR classes -->
+		<dependency>
+			<groupId>ca.uhn.hapi.fhir</groupId>
+			<artifactId>hapi-fhir-base</artifactId>
+			<version>2.1-SNAPSHOT</version>
+		</dependency>
+
+		<!-- This dependency includes the JPA server itself, which is packaged separately from the rest of HAPI FHIR -->
+		<dependency>
+			<groupId>ca.uhn.hapi.fhir</groupId>
+			<artifactId>hapi-fhir-jpaserver-base</artifactId>
+			<version>2.1-SNAPSHOT</version>
+		</dependency>
+
+		<!-- This dependency is used for the "FHIR Tester" web app overlay -->
+		<dependency>
+			<groupId>ca.uhn.hapi.fhir</groupId>
+			<artifactId>hapi-fhir-testpage-overlay</artifactId>
+			<version>2.1-SNAPSHOT</version>
+			<type>war</type>
+			<scope>provided</scope>
+		</dependency>
+		<dependency>
+			<groupId>ca.uhn.hapi.fhir</groupId>
+			<artifactId>hapi-fhir-testpage-overlay</artifactId>
+			<version>2.1-SNAPSHOT</version>
+			<classifier>classes</classifier>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- HAPI-FHIR uses Logback for logging support. The logback library is included automatically by Maven as a part of the hapi-fhir-base dependency, but you also need to include a logging library. Logback 
+			is used here, but log4j would also be fine. -->
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-classic</artifactId>
+		</dependency>
+
+		<!-- Needed for JEE/Servlet support -->
+		<dependency>
+			<groupId>javax.servlet</groupId>
+			<artifactId>javax.servlet-api</artifactId>
+			<scope>provided</scope>
+		</dependency>
+
+		<!-- If you are using HAPI narrative generation, you will need to include Thymeleaf as well. Otherwise the following can be omitted. -->
+		<dependency>
+			<groupId>org.thymeleaf</groupId>
+			<artifactId>thymeleaf</artifactId>
+		</dependency>
+
+		<!-- Used for CORS support -->
+		<dependency>
+			<groupId>org.ebaysf.web</groupId>
+			<artifactId>cors-filter</artifactId>
+			<exclusions>
+				<exclusion>
+					<artifactId>servlet-api</artifactId>
+					<groupId>javax.servlet</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+
+		<!-- Spring Web is used to deploy the server to a web container. -->
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-web</artifactId>
+		</dependency>
+
+		<!-- You may not need this if you are deploying to an application server which provides database connection pools itself. -->
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-dbcp2</artifactId>
+		</dependency>
+
+		<!-- This example uses Derby embedded database. If you are using another database such as Mysql or Oracle, you may omit the following dependencies and replace them with an appropriate database client 
+			dependency for your database platform. -->
+		<dependency>
+			<groupId>org.apache.derby</groupId>
+			<artifactId>derby</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.derby</groupId>
+			<artifactId>derbynet</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.derby</groupId>
+			<artifactId>derbyclient</artifactId>
+		</dependency>
+
+		<!-- The following dependencies are only needed for automated unit tests, you do not neccesarily need them to run the example. -->
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-servlets</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-servlet</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-server</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-util</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.jetty</groupId>
+			<artifactId>jetty-webapp</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.phloc</groupId>
+			<artifactId>phloc-schematron</artifactId>
+		</dependency>
+
+	</dependencies>
+
+	<build>
+
+		<!-- Tells Maven to name the generated WAR file as hapi-fhir-jpaserver-example.war -->
+		<finalName>hapi-fhir-jpaserver-example</finalName>
+
+		<!-- The following is not required for the application to build, but allows you to test it by issuing "mvn jetty:run" from the command line. -->
+		<pluginManagement>
+			<plugins>
+				<plugin>
+					<groupId>org.eclipse.jetty</groupId>
+					<artifactId>jetty-maven-plugin</artifactId>
+					<configuration>
+						<webApp>
+							<contextPath>/hapi-fhir-jpaserver-example</contextPath>
+							<allowDuplicateFragmentNames>true</allowDuplicateFragmentNames>
+						</webApp>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+
+		<plugins>
+			<!-- Tell Maven which Java source version you want to use -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				</configuration>
+			</plugin>
+
+			<!-- The configuration here tells the WAR plugin to include the FHIR Tester overlay. You can omit it if you are not using that feature. -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-war-plugin</artifactId>
+				<configuration>
+					<archive>
+						<manifestEntries>
+							<Build-Time>${maven.build.timestamp}</Build-Time>
+						</manifestEntries>
+					</archive>
+					<overlays>
+						<overlay>
+							<groupId>ca.uhn.hapi.fhir</groupId>
+							<artifactId>hapi-fhir-testpage-overlay</artifactId>
+						</overlay>
+					</overlays>
+					<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
+				</configuration>
+			</plugin>
+
+			<!-- This plugin is just a part of the HAPI internal build process, you do not need to incude it in your own projects -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-deploy-plugin</artifactId>
+				<configuration>
+					<skip>true</skip>
+				</configuration>
+			</plugin>
+
+			<!-- This is to run the integration tests -->
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-failsafe-plugin</artifactId>
+				<configuration>
+					<redirectTestOutputToFile>true</redirectTestOutputToFile>
+				</configuration>
+				<executions>
+					<execution>
+						<goals>
+							<goal>integration-test</goal>
+							<goal>verify</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+
+		</plugins>
+	</build>
+
+	<description>a</description>
+</project>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/readme.intellij.txt

@@ -0,0 +1,31 @@
+Running hapi-fhir-jpaserver-example in Tomcat from IntelliJ
+
+Install Tomcat.
+
+Make sure you have Tomcat set up in IntelliJ.
+File->Settings->Build, Execution, Deployment->Application Servers
+Click +
+Select "Tomcat Server"
+Enter the path to your tomcat deployment for both Tomcat Home (IntelliJ will fill in base directory for you)
+
+Add a Run Configuration for running hapi-fhir-jpaserver-example under Tomcat
+Run->Edit Configurations
+Click the green +
+Select Tomcat Server, Local
+Change the name to whatever you wish
+Uncheck the "After launch" checkbox
+On the "Deployment" tab, click the green +
+Select "Artifact"
+Select "hapi-fhir-jpaserver-example:war"
+In "Application context" type /hapi
+
+Run the configuration
+You should now have an "Application Servers" in the list of windows at the bottom.
+Click it.
+Select your server, and click the green triangle (or the bug if you want to debug)
+Wait for the console output to stop
+
+Point your browser (or fiddler, or what have you) to 
+http://localhost:8080/hapi/base/Patient
+
+You should get an empty bundle back.

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/java/ca/uhn/fhir/jpa/demo/FhirServerConfig.java

@@ -0,0 +1,121 @@
+package ca.uhn.fhir.jpa.demo;
+
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.apache.commons.lang3.time.DateUtils;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import ca.uhn.fhir.jpa.config.BaseJavaConfigDstu2;
+import ca.uhn.fhir.jpa.dao.DaoConfig;
+import ca.uhn.fhir.jpa.util.SubscriptionsRequireManualActivationInterceptorDstu2;
+import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.LoggingInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor;
+
+@Configuration
+@EnableTransactionManagement()
+public class FhirServerConfig extends BaseJavaConfigDstu2 {
+
+	/**
+	 * Configure FHIR properties around the the JPA server via this bean
+	 */
+	@Bean()
+	public DaoConfig daoConfig() {
+		DaoConfig retVal = new DaoConfig();
+		retVal.setSubscriptionEnabled(true);
+		retVal.setSubscriptionPollDelay(5000);
+		retVal.setSubscriptionPurgeInactiveAfterMillis(DateUtils.MILLIS_PER_HOUR);
+		retVal.setAllowMultipleDelete(true);
+		return retVal;
+	}
+
+	/**
+	 * The following bean configures the database connection. The 'url' property value of "jdbc:derby:directory:jpaserver_derby_files;create=true" indicates that the server should save resources in a
+	 * directory called "jpaserver_derby_files".
+	 * 
+	 * A URL to a remote database could also be placed here, along with login credentials and other properties supported by BasicDataSource.
+	 */
+	@Bean(destroyMethod = "close")
+	public DataSource dataSource() {
+		BasicDataSource retVal = new BasicDataSource();
+		retVal.setDriver(new org.apache.derby.jdbc.EmbeddedDriver());
+		retVal.setUrl("jdbc:derby:directory:target/jpaserver_derby_files;create=true");
+		retVal.setUsername("");
+		retVal.setPassword("");
+		return retVal;
+	}
+
+	@Bean()
+	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+		LocalContainerEntityManagerFactoryBean retVal = new LocalContainerEntityManagerFactoryBean();
+		retVal.setPersistenceUnitName("HAPI_PU");
+		retVal.setDataSource(dataSource());
+		retVal.setPackagesToScan("ca.uhn.fhir.jpa.entity");
+		retVal.setPersistenceProvider(new HibernatePersistenceProvider());
+		retVal.setJpaProperties(jpaProperties());
+		return retVal;
+	}
+
+	private Properties jpaProperties() {
+		Properties extraProperties = new Properties();
+		extraProperties.put("hibernate.dialect", org.hibernate.dialect.DerbyTenSevenDialect.class.getName());
+		extraProperties.put("hibernate.format_sql", "true");
+		extraProperties.put("hibernate.show_sql", "false");
+		extraProperties.put("hibernate.hbm2ddl.auto", "update");
+		extraProperties.put("hibernate.jdbc.batch_size", "20");
+		extraProperties.put("hibernate.cache.use_query_cache", "false");
+		extraProperties.put("hibernate.cache.use_second_level_cache", "false");
+		extraProperties.put("hibernate.cache.use_structured_entries", "false");
+		extraProperties.put("hibernate.cache.use_minimal_puts", "false");
+		extraProperties.put("hibernate.search.default.directory_provider", "filesystem");
+		extraProperties.put("hibernate.search.default.indexBase", "target/lucenefiles");
+		extraProperties.put("hibernate.search.lucene_version", "LUCENE_CURRENT");
+		return extraProperties;
+	}
+
+	/**
+	 * Do some fancy logging to create a nice access log that has details about each incoming request.
+	 */
+	public IServerInterceptor loggingInterceptor() {
+		LoggingInterceptor retVal = new LoggingInterceptor();
+		retVal.setLoggerName("fhirtest.access");
+		retVal.setMessageFormat(
+				"Path[${servletPath}] Source[${requestHeader.x-forwarded-for}] Operation[${operationType} ${operationName} ${idOrResourceName}] UA[${requestHeader.user-agent}] Params[${requestParameters}] ResponseEncoding[${responseEncodingNoDefault}]");
+		retVal.setLogExceptions(true);
+		retVal.setErrorMessageFormat("ERROR - ${requestVerb} ${requestUrl}");
+		return retVal;
+	}
+
+	/**
+	 * This interceptor adds some pretty syntax highlighting in responses when a browser is detected
+	 */
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor responseHighlighterInterceptor() {
+		ResponseHighlighterInterceptor retVal = new ResponseHighlighterInterceptor();
+		return retVal;
+	}
+
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor subscriptionSecurityInterceptor() {
+		SubscriptionsRequireManualActivationInterceptorDstu2 retVal = new SubscriptionsRequireManualActivationInterceptorDstu2();
+		return retVal;
+	}
+
+	@Bean()
+	public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+		JpaTransactionManager retVal = new JpaTransactionManager();
+		retVal.setEntityManagerFactory(entityManagerFactory);
+		return retVal;
+	}
+
+}

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/java/ca/uhn/fhir/jpa/demo/FhirServerConfigDstu3.java

@@ -0,0 +1,129 @@
+package ca.uhn.fhir.jpa.demo;
+
+import java.util.Properties;
+
+import javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.apache.commons.lang3.time.DateUtils;
+import org.hibernate.jpa.HibernatePersistenceProvider;
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import ca.uhn.fhir.jpa.config.BaseJavaConfigDstu3;
+import ca.uhn.fhir.jpa.dao.DaoConfig;
+import ca.uhn.fhir.jpa.util.SubscriptionsRequireManualActivationInterceptorDstu3;
+import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.LoggingInterceptor;
+import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor;
+
+/**
+ * This class isn't used by default by the example, but 
+ * you can use it as a config if you want to support DSTU3
+ * instead of DSTU2 in your server.
+ * 
+ * See https://github.com/jamesagnew/hapi-fhir/issues/278
+ */
+@Configuration
+@EnableTransactionManagement()
+public class FhirServerConfigDstu3 extends BaseJavaConfigDstu3 {
+
+	/**
+	 * Configure FHIR properties around the the JPA server via this bean
+	 */
+	@Bean()
+	public DaoConfig daoConfig() {
+		DaoConfig retVal = new DaoConfig();
+		retVal.setSubscriptionEnabled(true);
+		retVal.setSubscriptionPollDelay(5000);
+		retVal.setSubscriptionPurgeInactiveAfterMillis(DateUtils.MILLIS_PER_HOUR);
+		retVal.setAllowMultipleDelete(true);
+		return retVal;
+	}
+
+	/**
+	 * The following bean configures the database connection. The 'url' property value of "jdbc:derby:directory:jpaserver_derby_files;create=true" indicates that the server should save resources in a
+	 * directory called "jpaserver_derby_files".
+	 * 
+	 * A URL to a remote database could also be placed here, along with login credentials and other properties supported by BasicDataSource.
+	 */
+	@Bean(destroyMethod = "close")
+	public DataSource dataSource() {
+		BasicDataSource retVal = new BasicDataSource();
+		retVal.setDriver(new org.apache.derby.jdbc.EmbeddedDriver());
+		retVal.setUrl("jdbc:derby:directory:target/jpaserver_derby_files;create=true");
+		retVal.setUsername("");
+		retVal.setPassword("");
+		return retVal;
+	}
+
+	@Bean()
+	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+		LocalContainerEntityManagerFactoryBean retVal = new LocalContainerEntityManagerFactoryBean();
+		retVal.setPersistenceUnitName("HAPI_PU");
+		retVal.setDataSource(dataSource());
+		retVal.setPackagesToScan("ca.uhn.fhir.jpa.entity");
+		retVal.setPersistenceProvider(new HibernatePersistenceProvider());
+		retVal.setJpaProperties(jpaProperties());
+		return retVal;
+	}
+
+	private Properties jpaProperties() {
+		Properties extraProperties = new Properties();
+		extraProperties.put("hibernate.dialect", org.hibernate.dialect.DerbyTenSevenDialect.class.getName());
+		extraProperties.put("hibernate.format_sql", "true");
+		extraProperties.put("hibernate.show_sql", "false");
+		extraProperties.put("hibernate.hbm2ddl.auto", "update");
+		extraProperties.put("hibernate.jdbc.batch_size", "20");
+		extraProperties.put("hibernate.cache.use_query_cache", "false");
+		extraProperties.put("hibernate.cache.use_second_level_cache", "false");
+		extraProperties.put("hibernate.cache.use_structured_entries", "false");
+		extraProperties.put("hibernate.cache.use_minimal_puts", "false");
+		extraProperties.put("hibernate.search.default.directory_provider", "filesystem");
+		extraProperties.put("hibernate.search.default.indexBase", "target/lucenefiles");
+		extraProperties.put("hibernate.search.lucene_version", "LUCENE_CURRENT");
+//		extraProperties.put("hibernate.search.default.worker.execution", "async");
+		return extraProperties;
+	}
+
+	/**
+	 * Do some fancy logging to create a nice access log that has details about each incoming request.
+	 */
+	public IServerInterceptor loggingInterceptor() {
+		LoggingInterceptor retVal = new LoggingInterceptor();
+		retVal.setLoggerName("fhirtest.access");
+		retVal.setMessageFormat(
+				"Path[${servletPath}] Source[${requestHeader.x-forwarded-for}] Operation[${operationType} ${operationName} ${idOrResourceName}] UA[${requestHeader.user-agent}] Params[${requestParameters}] ResponseEncoding[${responseEncodingNoDefault}]");
+		retVal.setLogExceptions(true);
+		retVal.setErrorMessageFormat("ERROR - ${requestVerb} ${requestUrl}");
+		return retVal;
+	}
+
+	/**
+	 * This interceptor adds some pretty syntax highlighting in responses when a browser is detected
+	 */
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor responseHighlighterInterceptor() {
+		ResponseHighlighterInterceptor retVal = new ResponseHighlighterInterceptor();
+		return retVal;
+	}
+
+	@Bean(autowire = Autowire.BY_TYPE)
+	public IServerInterceptor subscriptionSecurityInterceptor() {
+		SubscriptionsRequireManualActivationInterceptorDstu3 retVal = new SubscriptionsRequireManualActivationInterceptorDstu3();
+		return retVal;
+	}
+
+	@Bean()
+	public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+		JpaTransactionManager retVal = new JpaTransactionManager();
+		retVal.setEntityManagerFactory(entityManagerFactory);
+		return retVal;
+	}
+
+}

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/java/ca/uhn/fhir/jpa/demo/FhirTesterConfig.java

@@ -0,0 +1,56 @@
+package ca.uhn.fhir.jpa.demo;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.to.FhirTesterMvcConfig;
+import ca.uhn.fhir.to.TesterConfig;
+
+//@formatter:off
+/**
+ * This spring config file configures the web testing module. It serves two
+ * purposes:
+ * 1. It imports FhirTesterMvcConfig, which is the spring config for the
+ *    tester itself
+ * 2. It tells the tester which server(s) to talk to, via the testerConfig()
+ *    method below
+ */
+@Configuration
+@Import(FhirTesterMvcConfig.class)
+public class FhirTesterConfig {
+
+	/**
+	 * This bean tells the testing webpage which servers it should configure itself
+	 * to communicate with. In this example we configure it to talk to the local
+	 * server, as well as one public server. If you are creating a project to 
+	 * deploy somewhere else, you might choose to only put your own server's 
+	 * address here.
+	 * 
+	 * Note the use of the ${serverBase} variable below. This will be replaced with
+	 * the base URL as reported by the server itself. Often for a simple Tomcat
+	 * (or other container) installation, this will end up being something
+	 * like "http://localhost:8080/hapi-fhir-jpaserver-example". If you are
+	 * deploying your server to a place with a fully qualified domain name, 
+	 * you might want to use that instead of using the variable.
+	 */
+	@Bean
+	public TesterConfig testerConfig() {
+		TesterConfig retVal = new TesterConfig();
+		retVal
+			.addServer()
+				.withId("home")
+				.withFhirVersion(FhirVersionEnum.DSTU2)
+				.withBaseUrl("${serverBase}/baseDstu2")
+				.withName("Local Tester")
+			.addServer()
+				.withId("hapi")
+				.withFhirVersion(FhirVersionEnum.DSTU2)
+				.withBaseUrl("http://fhirtest.uhn.ca/baseDstu2")
+				.withName("Public HAPI Test Server");
+		return retVal;
+	}
+	
+}
+//@formatter:on

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/java/ca/uhn/fhir/jpa/demo/JpaServerDemo.java

@@ -0,0 +1,171 @@
+package ca.uhn.fhir.jpa.demo;
+
+import java.util.Collection;
+import java.util.List;
+
+import javax.servlet.ServletException;
+
+import org.hl7.fhir.dstu3.model.Meta;
+import org.springframework.web.context.ContextLoaderListener;
+import org.springframework.web.context.WebApplicationContext;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.jpa.dao.DaoConfig;
+import ca.uhn.fhir.jpa.dao.IFhirSystemDao;
+import ca.uhn.fhir.jpa.provider.JpaConformanceProviderDstu1;
+import ca.uhn.fhir.jpa.provider.JpaConformanceProviderDstu2;
+import ca.uhn.fhir.jpa.provider.JpaSystemProviderDstu1;
+import ca.uhn.fhir.jpa.provider.JpaSystemProviderDstu2;
+import ca.uhn.fhir.jpa.provider.dstu3.JpaConformanceProviderDstu3;
+import ca.uhn.fhir.jpa.provider.dstu3.JpaSystemProviderDstu3;
+import ca.uhn.fhir.jpa.provider.dstu3.TerminologyUploaderProviderDstu3;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import ca.uhn.fhir.model.api.IResource;
+import ca.uhn.fhir.model.dstu2.composite.MetaDt;
+import ca.uhn.fhir.model.dstu2.resource.Bundle;
+import ca.uhn.fhir.narrative.DefaultThymeleafNarrativeGenerator;
+import ca.uhn.fhir.rest.server.ETagSupportEnum;
+import ca.uhn.fhir.rest.server.EncodingEnum;
+import ca.uhn.fhir.rest.server.IResourceProvider;
+import ca.uhn.fhir.rest.server.RestfulServer;
+import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
+
+public class JpaServerDemo extends RestfulServer {
+
+	private static final long serialVersionUID = 1L;
+
+	private WebApplicationContext myAppCtx;
+
+	@SuppressWarnings("unchecked")
+	@Override
+	protected void initialize() throws ServletException {
+		super.initialize();
+
+		/* 
+		 * We want to support FHIR DSTU2 format. This means that the server
+		 * will use the DSTU2 bundle format and other DSTU2 encoding changes.
+		 *
+		 * If you want to use DSTU1 instead, change the following line, and change the 2 occurrences of dstu2 in web.xml to dstu1
+		 */
+		FhirVersionEnum fhirVersion = FhirVersionEnum.DSTU2;
+		setFhirContext(new FhirContext(fhirVersion));
+
+		// Get the spring context from the web container (it's declared in web.xml)
+		myAppCtx = ContextLoaderListener.getCurrentWebApplicationContext();
+
+		/* 
+		 * The BaseJavaConfigDstu2.java class is a spring configuration
+		 * file which is automatically generated as a part of hapi-fhir-jpaserver-base and
+		 * contains bean definitions for a resource provider for each resource type
+		 */
+		String resourceProviderBeanName;
+		if (fhirVersion == FhirVersionEnum.DSTU1) {
+			resourceProviderBeanName = "myResourceProvidersDstu1";
+		} else if (fhirVersion == FhirVersionEnum.DSTU2) {
+			resourceProviderBeanName = "myResourceProvidersDstu2";
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			resourceProviderBeanName = "myResourceProvidersDstu3";
+		} else {
+			throw new IllegalStateException();
+		}
+		List<IResourceProvider> beans = myAppCtx.getBean(resourceProviderBeanName, List.class);
+		setResourceProviders(beans);
+		
+		/* 
+		 * The system provider implements non-resource-type methods, such as
+		 * transaction, and global history.
+		 */
+		Object systemProvider;
+		if (fhirVersion == FhirVersionEnum.DSTU1) {
+			systemProvider = myAppCtx.getBean("mySystemProviderDstu1", JpaSystemProviderDstu1.class);
+		} else if (fhirVersion == FhirVersionEnum.DSTU2) {
+			systemProvider = myAppCtx.getBean("mySystemProviderDstu2", JpaSystemProviderDstu2.class);
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			systemProvider = myAppCtx.getBean("mySystemProviderDstu3", JpaSystemProviderDstu3.class);
+		} else {
+			throw new IllegalStateException();
+		}
+		setPlainProviders(systemProvider);
+
+		/*
+		 * The conformance provider exports the supported resources, search parameters, etc for
+		 * this server. The JPA version adds resource counts to the exported statement, so it
+		 * is a nice addition.
+		 */
+		if (fhirVersion == FhirVersionEnum.DSTU1) {
+			IFhirSystemDao<List<IResource>, MetaDt> systemDao = myAppCtx.getBean("mySystemDaoDstu1", IFhirSystemDao.class);
+			JpaConformanceProviderDstu1 confProvider = new JpaConformanceProviderDstu1(this, systemDao);
+			confProvider.setImplementationDescription("Example Server");
+			setServerConformanceProvider(confProvider);
+		} else if (fhirVersion == FhirVersionEnum.DSTU2) {
+			IFhirSystemDao<Bundle, MetaDt> systemDao = myAppCtx.getBean("mySystemDaoDstu2", IFhirSystemDao.class);
+			JpaConformanceProviderDstu2 confProvider = new JpaConformanceProviderDstu2(this, systemDao,
+					myAppCtx.getBean(DaoConfig.class));
+			confProvider.setImplementationDescription("Example Server");
+			setServerConformanceProvider(confProvider);
+		} else if (fhirVersion == FhirVersionEnum.DSTU3) {
+			IFhirSystemDao<org.hl7.fhir.dstu3.model.Bundle, Meta> systemDao = myAppCtx.getBean("mySystemDaoDstu3", IFhirSystemDao.class);
+			JpaConformanceProviderDstu3 confProvider = new JpaConformanceProviderDstu3(this, systemDao,
+			myAppCtx.getBean(DaoConfig.class));
+			confProvider.setImplementationDescription("Example Server");
+			setServerConformanceProvider(confProvider);
+		} else {
+			throw new IllegalStateException();
+		}
+
+		/*
+		 * Enable ETag Support (this is already the default)
+		 */
+		setETagSupport(ETagSupportEnum.ENABLED);
+
+		/*
+		 * This server tries to dynamically generate narratives
+		 */
+		FhirContext ctx = getFhirContext();
+		ctx.setNarrativeGenerator(new DefaultThymeleafNarrativeGenerator());
+
+		/*
+		 * Default to JSON and pretty printing
+		 */
+		setDefaultPrettyPrint(true);
+		setDefaultResponseEncoding(EncodingEnum.JSON);
+
+		/*
+		 * -- New in HAPI FHIR 1.5 --
+		 * This configures the server to page search results to and from
+		 * the database, instead of only paging them to memory. This may mean
+		 * a performance hit when performing searches that return lots of results,
+		 * but makes the server much more scalable.
+		 */
+		setPagingProvider(myAppCtx.getBean(DatabaseBackedPagingProvider.class));
+
+		/*
+		 * Load interceptors for the server from Spring (these are defined in FhirServerConfig.java)
+		 */
+		Collection<IServerInterceptor> interceptorBeans = myAppCtx.getBeansOfType(IServerInterceptor.class).values();
+		for (IServerInterceptor interceptor : interceptorBeans) {
+			this.registerInterceptor(interceptor);
+		}
+
+		/*
+		 * If you are hosting this server at a specific DNS name, the server will try to 
+		 * figure out the FHIR base URL based on what the web container tells it, but
+		 * this doesn't always work. If you are setting links in your search bundles that
+		 * just refer to "localhost", you might want to use a server address strategy:
+		 */
+		//setServerAddressStrategy(new HardcodedServerAddressStrategy("http://mydomain.com/fhir/baseDstu2"));
+		
+		/*
+		 * If you are using DSTU3+, you may want to add a terminology uploader, which allows 
+		 * uploading of external terminologies such as Snomed CT. Note that this uploader
+		 * does not have any security attached (any anonymous user may use it by default)
+		 * so it is a potential security vulnerability. Consider using an AuthorizationInterceptor
+		 * with this feature.
+		 */
+		//if (fhirVersion == FhirVersionEnum.DSTU3) {
+		//	 registerProvider(myAppCtx.getBean(TerminologyUploaderProviderDstu3.class));
+		//}
+	}
+
+}

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/resources/logback.xml

@@ -0,0 +1,16 @@
+<configuration scan="true" scanPeriod="30 seconds">
+
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+			<level>INFO</level>
+		</filter>
+		<encoder>
+			<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%file:%line] %msg%n</pattern>
+		</encoder>
+	</appender>
+
+	<root level="INFO">
+		<appender-ref ref="STDOUT" />
+	</root>
+
+</configuration>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/templates/about.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head  th:include="tmpl-head :: head">
+		<title>About This Server</title>
+	</head>
+
+	<body>
+		<form action="" method="get" id="outerForm">
+		<div th:replace="tmpl-navbar-top :: top" ></div>
+		
+		<div class="container-fluid">
+			<div class="row">
+				<div th:replace="tmpl-navbar-left :: left" ></div>
+
+				<div class="col-sm-9 col-sm-offset-3 col-md-9 col-md-offset-3 main">
+
+					<div th:replace="tmpl-banner :: banner"></div>
+
+					<div class="panel panel-default">
+						<div class="panel-heading">
+							<h3 class="panel-title">About This Server</h3>
+						</div>
+						<div class="panel-body">
+							<div class="pull-right">
+								<object data="img/fhirtest-architecture.svg" width="383" height="369" type="image/svg+xml"></object>
+							</div>
+							<p>
+								This server provides a nearly complete implementation of the FHIR Specification
+								using a 100% open source software stack. It is hosted by University Health Network.
+							</p>
+							<p>
+								The architecture in use here is shown in the image on the right. This server is built
+								from a number of modules of the 
+								<a href="https://github.com/jamesagnew/hapi-fhir/">HAPI FHIR</a>
+								project, which is a 100% open-source (Apache 2.0 Licensed) Java based
+								implementation of the FHIR specification.
+							</p>
+							<p>
+								
+							</p>
+						</div>
+					</div>
+					<div class="panel panel-default">
+						<div class="panel-heading">
+							<h3 class="panel-title">Data On This Server</h3>
+						</div>
+						<div class="panel-body">
+							<p>
+								This server is regularly loaded with a standard set of test data sourced
+								from UHN's own testing environment. Do not use this server to store any data
+								that you will need later, as we will be regularly resetting it. 
+							</p>
+							<p>
+								This is not a production server and it provides no privacy. Do not store any
+								confidential data here.
+							</p>
+						</div>
+					</div>
+					
+				</div>
+			</div>
+		</div>
+
+		<div th:replace="tmpl-footer :: footer" ></div>
+		</form>
+	</body>
+</html>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/templates/tmpl-footer.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="en">
+	<div th:fragment="footer">
+		<script>
+		  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+		  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+		  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+		  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+		
+		  ga('create', 'UA-1395874-6', 'auto');
+		  ga('require', 'displayfeatures');
+		  ga('require', 'linkid', 'linkid.js');
+		  ga('send', 'pageview');		
+		</script>
+	</div>
+</html>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/templates/tmpl-home-welcome.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+	<div th:fragment="banner" class="well">
+		<th:block th:if="${serverId} == 'home'">
+			<p>
+				This is the home for the FHIR test server operated by
+				<a href="http://uhn.ca">University Health Network</a>. This server
+				(and the testing application you are currently using to access it)
+				is entirely built using
+				<a href="https://github.com/jamesagnew/hapi-fhir">HAPI-FHIR</a>, 
+				a 100% open-source Java implementation of the
+				<a href="http://hl7.org/implement/standards/fhir/">FHIR specification</a>.
+			</p>
+			<p>
+				Here are some things you might wish to try:
+			</p>
+			<ul>
+				<li>
+					View a
+					<a href="http://fhirtest.uhn.ca/search?serverId=home&amp;encoding=json&amp;pretty=true&amp;resource=Patient&amp;param.0.type=string&amp;param.0.name=_id&amp;param.0.0=&amp;resource-search-limit=">list of patients</a>
+					on this server.
+				</li>
+				<li>
+					Construct a
+					<a href="http://fhirtest.uhn.ca/resource?serverId=home&amp;encoding=json&amp;pretty=true&amp;resource=Patient">search query</a>
+					on this server.
+				</li>
+				<li>
+					Access a 
+					<a href="http://fhirtest.uhn.ca/home?serverId=furore">different server</a>
+					(use the <b>Server</b> menu at the top of the page to see a list of public FHIR servers)
+				</li>
+			</ul>
+		</th:block>
+		<th:block th:if="${serverId} != 'home'">
+			<p>
+				You are accessing the public FHIR server
+				<b th:text="${baseName}"/>. This server is hosted elsewhere on the internet
+				but is being accessed using the HAPI client implementation.
+			</p>
+		</th:block>
+		<p>
+			<b style="color: red;">
+				<span class="glyphicon glyphicon-warning-sign"/> 
+				This is not a production server!
+			</b> 
+			Do not store any information here that contains personal health information
+			or any other confidential information. This server will be regularly purged 
+			and reloaded with fixed test data. 
+		</p>
+	</div>
+</html>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/web.xml

@@ -0,0 +1,108 @@
+<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="3.0"
+	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee ./xsd/web-app_3_0.xsd">
+
+	<listener>
+		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
+	</listener>
+	<context-param>
+		<param-name>contextClass</param-name>
+		<param-value>
+			org.springframework.web.context.support.AnnotationConfigWebApplicationContext
+		</param-value>
+	</context-param>
+	<context-param>
+		<param-name>contextConfigLocation</param-name>
+		<param-value>
+			ca.uhn.fhir.jpa.demo.FhirServerConfig
+		</param-value>
+	</context-param>
+
+	<!-- Servlets -->
+
+	<servlet>
+		<servlet-name>spring</servlet-name>
+		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
+		<init-param>
+			<param-name>contextClass</param-name>
+			<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
+		</init-param>
+		<init-param>
+			<param-name>contextConfigLocation</param-name>
+			<param-value>ca.uhn.fhir.jpa.demo.FhirTesterConfig</param-value>
+		</init-param>
+		<load-on-startup>2</load-on-startup>
+	</servlet>
+
+	<servlet>
+		<servlet-name>fhirServlet</servlet-name>
+		<servlet-class>ca.uhn.fhir.jpa.demo.JpaServerDemo</servlet-class>
+		<init-param>
+			<param-name>ImplementationDescription</param-name>
+			<param-value>FHIR JPA Server</param-value>
+		</init-param>
+		<init-param>
+			<param-name>FhirVersion</param-name>
+			<param-value>DSTU2</param-value>
+		</init-param>
+		<load-on-startup>1</load-on-startup>
+	</servlet>
+
+	<servlet-mapping>
+		<servlet-name>fhirServlet</servlet-name>
+		<url-pattern>/baseDstu2/*</url-pattern>
+	</servlet-mapping>
+
+	<servlet-mapping>
+		<servlet-name>spring</servlet-name>
+		<url-pattern>/</url-pattern>
+	</servlet-mapping>
+
+
+
+	<!-- This filters provide support for Cross Origin Resource Sharing (CORS) -->
+	<filter>
+		<filter-name>CORS Filter</filter-name>
+		<filter-class>org.ebaysf.web.cors.CORSFilter</filter-class>
+		<init-param>
+			<description>A comma separated list of allowed origins. Note: An '*' cannot be used for an allowed origin when using credentials.</description>
+			<param-name>cors.allowed.origins</param-name>
+			<param-value>*</param-value>
+		</init-param>
+		<init-param>
+			<description>A comma separated list of HTTP verbs, using which a CORS request can be made.</description>
+			<param-name>cors.allowed.methods</param-name>
+			<param-value>GET,POST,PUT,DELETE,OPTIONS</param-value>
+		</init-param>
+		<init-param>
+			<description>A comma separated list of allowed headers when making a non simple CORS request.</description>
+			<param-name>cors.allowed.headers</param-name>
+			<param-value>X-FHIR-Starter,Origin,Accept,X-Requested-With,Content-Type,Access-Control-Request-Method,Access-Control-Request-Headers</param-value>
+		</init-param>
+		<init-param>
+			<description>A comma separated list non-standard response headers that will be exposed to XHR2 object.</description>
+			<param-name>cors.exposed.headers</param-name>
+			<param-value>Location,Content-Location</param-value>
+		</init-param>
+		<init-param>
+			<description>A flag that suggests if CORS is supported with cookies</description>
+			<param-name>cors.support.credentials</param-name>
+			<param-value>true</param-value>
+		</init-param>
+		<init-param>
+			<description>A flag to control logging</description>
+			<param-name>cors.logging.enabled</param-name>
+			<param-value>true</param-value>
+		</init-param>
+		<init-param>
+			<description>Indicates how long (in seconds) the results of a preflight request can be cached in a preflight result cache.</description>
+			<param-name>cors.preflight.maxage</param-name>
+			<param-value>300</param-value>
+		</init-param>
+	</filter>
+	<filter-mapping>
+		<filter-name>CORS Filter</filter-name>
+		<url-pattern>/*</url-pattern>
+	</filter-mapping>
+
+
+</web-app>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/xsd/jsp_2_2.xsd

@@ -0,0 +1,389 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
+            targetNamespace="http://java.sun.com/xml/ns/javaee"
+            xmlns:javaee="http://java.sun.com/xml/ns/javaee"
+            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            elementFormDefault="qualified"
+            attributeFormDefault="unqualified"
+            version="2.2">
+  <xsd:annotation>
+    <xsd:documentation>
+
+      DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+      
+      Copyright 2003-2009 Sun Microsystems, Inc. All rights reserved.
+      
+      The contents of this file are subject to the terms of either the
+      GNU General Public License Version 2 only ("GPL") or the Common
+      Development and Distribution License("CDDL") (collectively, the
+      "License").  You may not use this file except in compliance with
+      the License. You can obtain a copy of the License at
+      https://glassfish.dev.java.net/public/CDDL+GPL.html or
+      glassfish/bootstrap/legal/LICENSE.txt.  See the License for the
+      specific language governing permissions and limitations under the
+      License.
+      
+      When distributing the software, include this License Header
+      Notice in each file and include the License file at
+      glassfish/bootstrap/legal/LICENSE.txt.  Sun designates this
+      particular file as subject to the "Classpath" exception as
+      provided by Sun in the GPL Version 2 section of the License file
+      that accompanied this code.  If applicable, add the following
+      below the License Header, with the fields enclosed by brackets []
+      replaced by your own identifying information:
+      "Portions Copyrighted [year] [name of copyright owner]"
+      
+      Contributor(s):
+      
+      If you wish your version of this file to be governed by only the
+      CDDL or only the GPL Version 2, indicate your decision by adding
+      "[Contributor] elects to include this software in this
+      distribution under the [CDDL or GPL Version 2] license."  If you
+      don't indicate a single choice of license, a recipient has the
+      option to distribute your version of this file under either the
+      CDDL, the GPL Version 2 or to extend the choice of license to its
+      licensees as provided above.  However, if you add GPL Version 2
+      code and therefore, elected the GPL Version 2 license, then the
+      option applies only if the new code is made subject to such
+      option by the copyright holder.
+      
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:annotation>
+    <xsd:documentation>
+
+      This is the XML Schema for the JSP 2.2 deployment descriptor
+      types.  The JSP 2.2 schema contains all the special
+      structures and datatypes that are necessary to use JSP files
+      from a web application. 
+      
+      The contents of this schema is used by the web-common_3_0.xsd 
+      file to define JSP specific content. 
+      
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:annotation>
+    <xsd:documentation>
+
+      The following conventions apply to all Java EE
+      deployment descriptor elements unless indicated otherwise.
+      
+      - In elements that specify a pathname to a file within the
+      same JAR file, relative filenames (i.e., those not
+      starting with "/") are considered relative to the root of
+      the JAR file's namespace.  Absolute filenames (i.e., those
+      starting with "/") also specify names in the root of the
+      JAR file's namespace.  In general, relative names are
+      preferred.  The exception is .war files where absolute
+      names are preferred for consistency with the Servlet API.
+      
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:include schemaLocation="javaee_6.xsd"/>
+
+
+<!-- **************************************************** -->
+
+  <xsd:complexType name="jsp-configType">
+    <xsd:annotation>
+      <xsd:documentation>
+
+        The jsp-configType is used to provide global configuration
+        information for the JSP files in a web application. It has
+        two subelements, taglib and jsp-property-group.
+        
+      </xsd:documentation>
+    </xsd:annotation>
+    <xsd:sequence>
+      <xsd:element name="taglib"
+                   type="javaee:taglibType"
+                   minOccurs="0"
+                   maxOccurs="unbounded"/>
+      <xsd:element name="jsp-property-group"
+                   type="javaee:jsp-property-groupType"
+                   minOccurs="0"
+                   maxOccurs="unbounded"/>
+    </xsd:sequence>
+    <xsd:attribute name="id"
+                   type="xsd:ID"/>
+  </xsd:complexType>
+
+
+<!-- **************************************************** -->
+
+  <xsd:complexType name="jsp-fileType">
+    <xsd:annotation>
+      <xsd:documentation>
+
+        The jsp-file element contains the full path to a JSP file
+        within the web application beginning with a `/'.
+        
+      </xsd:documentation>
+    </xsd:annotation>
+    <xsd:simpleContent>
+      <xsd:restriction base="javaee:pathType"/>
+    </xsd:simpleContent>
+  </xsd:complexType>
+
+
+<!-- **************************************************** -->
+
+  <xsd:complexType name="jsp-property-groupType">
+    <xsd:annotation>
+      <xsd:documentation>
+
+        The jsp-property-groupType is used to group a number of
+        files so they can be given global property information.
+        All files so described are deemed to be JSP files.  The
+        following additional properties can be described:
+        
+        - Control whether EL is ignored.
+        - Control whether scripting elements are invalid.
+        - Indicate pageEncoding information.
+        - Indicate that a resource is a JSP document (XML).
+        - Prelude and Coda automatic includes.
+        - Control whether the character sequence #{ is allowed
+        when used as a String literal.
+        - Control whether template text containing only
+        whitespaces must be removed from the response output.
+        - Indicate the default contentType information.
+        - Indicate the default buffering model for JspWriter
+        - Control whether error should be raised for the use of
+        undeclared namespaces in a JSP page.
+        
+      </xsd:documentation>
+    </xsd:annotation>
+    <xsd:sequence>
+      <xsd:group ref="javaee:descriptionGroup"/>
+      <xsd:element name="url-pattern"
+                   type="javaee:url-patternType"
+                   maxOccurs="unbounded"/>
+      <xsd:element name="el-ignored"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            Can be used to easily set the isELIgnored
+            property of a group of JSP pages.  By default, the
+            EL evaluation is enabled for Web Applications using
+            a Servlet 2.4 or greater web.xml, and disabled
+            otherwise.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="page-encoding"
+                   type="javaee:string"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The valid values of page-encoding are those of the
+            pageEncoding page directive.  It is a
+            translation-time error to name different encodings
+            in the pageEncoding attribute of the page directive
+            of a JSP page and in a JSP configuration element
+            matching the page.  It is also a translation-time
+            error to name different encodings in the prolog
+            or text declaration of a document in XML syntax and
+            in a JSP configuration element matching the document.
+            It is legal to name the same encoding through
+            mulitple mechanisms.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="scripting-invalid"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            Can be used to easily disable scripting in a
+            group of JSP pages.  By default, scripting is
+            enabled.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="is-xml"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            If true, denotes that the group of resources
+            that match the URL pattern are JSP documents,
+            and thus must be interpreted as XML documents.
+            If false, the resources are assumed to not
+            be JSP documents, unless there is another
+            property group that indicates otherwise.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="include-prelude"
+                   type="javaee:pathType"
+                   minOccurs="0"
+                   maxOccurs="unbounded">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The include-prelude element is a context-relative
+            path that must correspond to an element in the
+            Web Application.  When the element is present,
+            the given path will be automatically included (as
+            in an include directive) at the beginning of each
+            JSP page in this jsp-property-group.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="include-coda"
+                   type="javaee:pathType"
+                   minOccurs="0"
+                   maxOccurs="unbounded">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The include-coda element is a context-relative
+            path that must correspond to an element in the
+            Web Application.  When the element is present,
+            the given path will be automatically included (as
+            in an include directive) at the end of each
+            JSP page in this jsp-property-group.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="deferred-syntax-allowed-as-literal"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The character sequence #{ is reserved for EL expressions.
+            Consequently, a translation error occurs if the #{
+            character sequence is used as a String literal, unless
+            this element is enabled (true). Disabled (false) by
+            default.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="trim-directive-whitespaces"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            Indicates that template text containing only whitespaces
+            must be removed from the response output. It has no
+            effect on JSP documents (XML syntax). Disabled (false)
+            by default.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="default-content-type"
+                   type="javaee:string"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The valid values of default-content-type are those of the
+            contentType page directive.  It specifies the default
+            response contentType if the page directive does not include
+            a contentType attribute.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="buffer"
+                   type="javaee:string"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The valid values of buffer are those of the
+            buffer page directive.  It specifies if buffering should be
+            used for the output to response, and if so, the size of the
+            buffer to use.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="error-on-undeclared-namespace"
+                   type="javaee:true-falseType"
+                   minOccurs="0">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            The default behavior when a tag with unknown namespace is used
+            in a JSP page (regular syntax) is to silently ignore it.  If
+            set to true, then an error must be raised during the translation
+            time when an undeclared tag is used in a JSP page.  Disabled
+            (false) by default.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+    </xsd:sequence>
+    <xsd:attribute name="id"
+                   type="xsd:ID"/>
+  </xsd:complexType>
+
+
+<!-- **************************************************** -->
+
+  <xsd:complexType name="taglibType">
+    <xsd:annotation>
+      <xsd:documentation>
+
+        The taglibType defines the syntax for declaring in
+        the deployment descriptor that a tag library is
+        available to the application.  This can be done
+        to override implicit map entries from TLD files and
+        from the container.
+        
+      </xsd:documentation>
+    </xsd:annotation>
+    <xsd:sequence>
+      <xsd:element name="taglib-uri"
+                   type="javaee:string">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            A taglib-uri element describes a URI identifying a
+            tag library used in the web application.  The body
+            of the taglib-uri element may be either an
+            absolute URI specification, or a relative URI.
+            There should be no entries in web.xml with the
+            same taglib-uri value.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+      <xsd:element name="taglib-location"
+                   type="javaee:pathType">
+        <xsd:annotation>
+          <xsd:documentation>
+
+            the taglib-location element contains the location
+            (as a resource relative to the root of the web
+            application) where to find the Tag Library
+            Description file for the tag library.
+            
+          </xsd:documentation>
+        </xsd:annotation>
+      </xsd:element>
+    </xsd:sequence>
+    <xsd:attribute name="id"
+                   type="xsd:ID"/>
+  </xsd:complexType>
+
+</xsd:schema>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/xsd/web-app_3_0.xsd

@@ -0,0 +1,272 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns="http://www.w3.org/2001/XMLSchema"
+            targetNamespace="http://java.sun.com/xml/ns/javaee"
+            xmlns:javaee="http://java.sun.com/xml/ns/javaee"
+            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            elementFormDefault="qualified"
+            attributeFormDefault="unqualified"
+            version="3.0">
+  <xsd:annotation>
+    <xsd:documentation>
+
+      DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+      
+      Copyright 2003-2009 Sun Microsystems, Inc. All rights reserved.
+      
+      The contents of this file are subject to the terms of either the
+      GNU General Public License Version 2 only ("GPL") or the Common
+      Development and Distribution License("CDDL") (collectively, the
+      "License").  You may not use this file except in compliance with
+      the License. You can obtain a copy of the License at
+      https://glassfish.dev.java.net/public/CDDL+GPL.html or
+      glassfish/bootstrap/legal/LICENSE.txt.  See the License for the
+      specific language governing permissions and limitations under the
+      License.
+      
+      When distributing the software, include this License Header
+      Notice in each file and include the License file at
+      glassfish/bootstrap/legal/LICENSE.txt.  Sun designates this
+      particular file as subject to the "Classpath" exception as
+      provided by Sun in the GPL Version 2 section of the License file
+      that accompanied this code.  If applicable, add the following
+      below the License Header, with the fields enclosed by brackets []
+      replaced by your own identifying information:
+      "Portions Copyrighted [year] [name of copyright owner]"
+      
+      Contributor(s):
+      
+      If you wish your version of this file to be governed by only the
+      CDDL or only the GPL Version 2, indicate your decision by adding
+      "[Contributor] elects to include this software in this
+      distribution under the [CDDL or GPL Version 2] license."  If you
+      don't indicate a single choice of license, a recipient has the
+      option to distribute your version of this file under either the
+      CDDL, the GPL Version 2 or to extend the choice of license to its
+      licensees as provided above.  However, if you add GPL Version 2
+      code and therefore, elected the GPL Version 2 license, then the
+      option applies only if the new code is made subject to such
+      option by the copyright holder.
+      
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:annotation>
+    <xsd:documentation>
+      <![CDATA[[
+      This is the XML Schema for the Servlet 3.0 deployment descriptor.
+      The deployment descriptor must be named "WEB-INF/web.xml" in the
+      web application's war file.  All Servlet deployment descriptors
+      must indicate the web application schema by using the Java EE
+      namespace:
+      
+      http://java.sun.com/xml/ns/javaee 
+      
+      and by indicating the version of the schema by 
+      using the version element as shown below: 
+      
+      <web-app xmlns="http://java.sun.com/xml/ns/javaee"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="..."
+      version="3.0"> 
+      ...
+      </web-app>
+      
+      The instance documents may indicate the published version of
+      the schema using the xsi:schemaLocation attribute for Java EE
+      namespace with the following location:
+      
+      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd
+      
+      ]]>
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:annotation>
+    <xsd:documentation>
+
+      The following conventions apply to all Java EE
+      deployment descriptor elements unless indicated otherwise.
+      
+      - In elements that specify a pathname to a file within the
+      same JAR file, relative filenames (i.e., those not
+      starting with "/") are considered relative to the root of
+      the JAR file's namespace.  Absolute filenames (i.e., those
+      starting with "/") also specify names in the root of the
+      JAR file's namespace.  In general, relative names are
+      preferred.  The exception is .war files where absolute
+      names are preferred for consistency with the Servlet API.
+      
+    </xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:include schemaLocation="web-common_3_0.xsd"/>
+
+
+<!-- **************************************************** -->
+
+  <xsd:element name="web-app"
+               type="javaee:web-appType">
+    <xsd:annotation>
+      <xsd:documentation>
+
+        The web-app element is the root of the deployment
+        descriptor for a web application.  Note that the sub-elements
+        of this element can be in the arbitrary order. Because of
+        that, the multiplicity of the elements of distributable,
+        session-config, welcome-file-list, jsp-config, login-config,
+        and locale-encoding-mapping-list was changed from "?" to "*"
+        in this schema.  However, the deployment descriptor instance
+        file must not contain multiple elements of session-config,
+        jsp-config, and login-config. When there are multiple elements of
+        welcome-file-list or locale-encoding-mapping-list, the container
+        must concatenate the element contents.  The multiple occurence
+        of the element distributable is redundant and the container
+        treats that case exactly in the same way when there is only
+        one distributable. 
+        
+      </xsd:documentation>
+    </xsd:annotation>
+    <xsd:unique name="web-common-servlet-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The servlet element contains the name of a servlet.
+          The name must be unique within the web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:servlet"/>
+      <xsd:field xpath="javaee:servlet-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-filter-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The filter element contains the name of a filter.
+          The name must be unique within the web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:filter"/>
+      <xsd:field xpath="javaee:filter-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-ejb-local-ref-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The ejb-local-ref-name element contains the name of an EJB
+          reference. The EJB reference is an entry in the web
+          application's environment and is relative to the
+          java:comp/env context.  The name must be unique within
+          the web application.
+          
+          It is recommended that name is prefixed with "ejb/".
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:ejb-local-ref"/>
+      <xsd:field xpath="javaee:ejb-ref-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-ejb-ref-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The ejb-ref-name element contains the name of an EJB
+          reference. The EJB reference is an entry in the web
+          application's environment and is relative to the
+          java:comp/env context.  The name must be unique within
+          the web application.
+          
+          It is recommended that name is prefixed with "ejb/".
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:ejb-ref"/>
+      <xsd:field xpath="javaee:ejb-ref-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-resource-env-ref-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The resource-env-ref-name element specifies the name of
+          a resource environment reference; its value is the
+          environment entry name used in the web application code.
+          The name is a JNDI name relative to the java:comp/env
+          context and must be unique within a web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:resource-env-ref"/>
+      <xsd:field xpath="javaee:resource-env-ref-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-message-destination-ref-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The message-destination-ref-name element specifies the name of
+          a message destination reference; its value is the
+          environment entry name used in the web application code.
+          The name is a JNDI name relative to the java:comp/env
+          context and must be unique within a web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:message-destination-ref"/>
+      <xsd:field xpath="javaee:message-destination-ref-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-res-ref-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The res-ref-name element specifies the name of a
+          resource manager connection factory reference.  The name
+          is a JNDI name relative to the java:comp/env context.
+          The name must be unique within a web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:resource-ref"/>
+      <xsd:field xpath="javaee:res-ref-name"/>
+    </xsd:unique>
+    <xsd:unique name="web-common-env-entry-name-uniqueness">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The env-entry-name element contains the name of a web
+          application's environment entry.  The name is a JNDI
+          name relative to the java:comp/env context.  The name
+          must be unique within a web application.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:env-entry"/>
+      <xsd:field xpath="javaee:env-entry-name"/>
+    </xsd:unique>
+    <xsd:key name="web-common-role-name-key">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          A role-name-key is specified to allow the references
+          from the security-role-refs.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:security-role"/>
+      <xsd:field xpath="javaee:role-name"/>
+    </xsd:key>
+    <xsd:keyref name="web-common-role-name-references"
+                refer="javaee:web-common-role-name-key">
+      <xsd:annotation>
+        <xsd:documentation>
+
+          The keyref indicates the references from
+          security-role-ref to a specified role-name.
+          
+        </xsd:documentation>
+      </xsd:annotation>
+      <xsd:selector xpath="javaee:servlet/javaee:security-role-ref"/>
+      <xsd:field xpath="javaee:role-link"/>
+    </xsd:keyref>
+  </xsd:element>
+
+</xsd:schema>

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/main/webapp/WEB-INF/xsd/xml.xsd

@@ -0,0 +1,287 @@
+<?xml version='1.0'?>
+<?xml-stylesheet href="../2008/09/xsd.xsl" type="text/xsl"?>
+<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace" 
+  xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+  xmlns   ="http://www.w3.org/1999/xhtml"
+  xml:lang="en">
+
+ <xs:annotation>
+  <xs:documentation>
+   <div>
+    <h1>About the XML namespace</h1>
+
+    <div class="bodytext">
+     <p>
+      This schema document describes the XML namespace, in a form
+      suitable for import by other schema documents.
+     </p>
+     <p>
+      See <a href="http://www.w3.org/XML/1998/namespace.html">
+      http://www.w3.org/XML/1998/namespace.html</a> and
+      <a href="http://www.w3.org/TR/REC-xml">
+      http://www.w3.org/TR/REC-xml</a> for information 
+      about this namespace.
+     </p>
+     <p>
+      Note that local names in this namespace are intended to be
+      defined only by the World Wide Web Consortium or its subgroups.
+      The names currently defined in this namespace are listed below.
+      They should not be used with conflicting semantics by any Working
+      Group, specification, or document instance.
+     </p>
+     <p>   
+      See further below in this document for more information about <a
+      href="#usage">how to refer to this schema document from your own
+      XSD schema documents</a> and about <a href="#nsversioning">the
+      namespace-versioning policy governing this schema document</a>.
+     </p>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:attribute name="lang">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>lang (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose value
+       is a language code for the natural language of the content of
+       any element; its value is inherited.  This name is reserved
+       by virtue of its definition in the XML specification.</p>
+     
+    </div>
+    <div>
+     <h4>Notes</h4>
+     <p>
+      Attempting to install the relevant ISO 2- and 3-letter
+      codes as the enumerated possible values is probably never
+      going to be a realistic possibility.  
+     </p>
+     <p>
+      See BCP 47 at <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt">
+       http://www.rfc-editor.org/rfc/bcp/bcp47.txt</a>
+      and the IANA language subtag registry at
+      <a href="http://www.iana.org/assignments/language-subtag-registry">
+       http://www.iana.org/assignments/language-subtag-registry</a>
+      for further information.
+     </p>
+     <p>
+      The union allows for the 'un-declaration' of xml:lang with
+      the empty string.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+  <xs:simpleType>
+   <xs:union memberTypes="xs:language">
+    <xs:simpleType>    
+     <xs:restriction base="xs:string">
+      <xs:enumeration value=""/>
+     </xs:restriction>
+    </xs:simpleType>
+   </xs:union>
+  </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="space">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>space (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose
+       value is a keyword indicating what whitespace processing
+       discipline is intended for the content of the element; its
+       value is inherited.  This name is reserved by virtue of its
+       definition in the XML specification.</p>
+     
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+  <xs:simpleType>
+   <xs:restriction base="xs:NCName">
+    <xs:enumeration value="default"/>
+    <xs:enumeration value="preserve"/>
+   </xs:restriction>
+  </xs:simpleType>
+ </xs:attribute>
+ 
+ <xs:attribute name="base" type="xs:anyURI"> <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>base (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose value
+       provides a URI to be used as the base for interpreting any
+       relative URIs in the scope of the element on which it
+       appears; its value is inherited.  This name is reserved
+       by virtue of its definition in the XML Base specification.</p>
+     
+     <p>
+      See <a
+      href="http://www.w3.org/TR/xmlbase/">http://www.w3.org/TR/xmlbase/</a>
+      for information about this attribute.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+ 
+ <xs:attribute name="id" type="xs:ID">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>id (as an attribute name)</h3> 
+      <p>
+       denotes an attribute whose value
+       should be interpreted as if declared to be of type ID.
+       This name is reserved by virtue of its definition in the
+       xml:id specification.</p>
+     
+     <p>
+      See <a
+      href="http://www.w3.org/TR/xml-id/">http://www.w3.org/TR/xml-id/</a>
+      for information about this attribute.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+
+ <xs:attributeGroup name="specialAttrs">
+  <xs:attribute ref="xml:base"/>
+  <xs:attribute ref="xml:lang"/>
+  <xs:attribute ref="xml:space"/>
+  <xs:attribute ref="xml:id"/>
+ </xs:attributeGroup>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div>
+   
+    <h3>Father (in any context at all)</h3> 
+
+    <div class="bodytext">
+     <p>
+      denotes Jon Bosak, the chair of 
+      the original XML Working Group.  This name is reserved by 
+      the following decision of the W3C XML Plenary and 
+      XML Coordination groups:
+     </p>
+     <blockquote>
+       <p>
+	In appreciation for his vision, leadership and
+	dedication the W3C XML Plenary on this 10th day of
+	February, 2000, reserves for Jon Bosak in perpetuity
+	the XML name "xml:Father".
+       </p>
+     </blockquote>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div xml:id="usage" id="usage">
+    <h2><a name="usage">About this schema document</a></h2>
+
+    <div class="bodytext">
+     <p>
+      This schema defines attributes and an attribute group suitable
+      for use by schemas wishing to allow <code>xml:base</code>,
+      <code>xml:lang</code>, <code>xml:space</code> or
+      <code>xml:id</code> attributes on elements they define.
+     </p>
+     <p>
+      To enable this, such a schema must import this schema for
+      the XML namespace, e.g. as follows:
+     </p>
+     <pre>
+          &lt;schema . . .>
+           . . .
+           &lt;import namespace="http://www.w3.org/XML/1998/namespace"
+                      schemaLocation="http://www.w3.org/2001/xml.xsd"/>
+     </pre>
+     <p>
+      or
+     </p>
+     <pre>
+           &lt;import namespace="http://www.w3.org/XML/1998/namespace"
+                      schemaLocation="http://www.w3.org/2009/01/xml.xsd"/>
+     </pre>
+     <p>
+      Subsequently, qualified reference to any of the attributes or the
+      group defined below will have the desired effect, e.g.
+     </p>
+     <pre>
+          &lt;type . . .>
+           . . .
+           &lt;attributeGroup ref="xml:specialAttrs"/>
+     </pre>
+     <p>
+      will define a type which will schema-validate an instance element
+      with any of those attributes.
+     </p>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div id="nsversioning" xml:id="nsversioning">
+    <h2><a name="nsversioning">Versioning policy for this schema document</a></h2>
+    <div class="bodytext">
+     <p>
+      In keeping with the XML Schema WG's standard versioning
+      policy, this schema document will persist at
+      <a href="http://www.w3.org/2009/01/xml.xsd">
+       http://www.w3.org/2009/01/xml.xsd</a>.
+     </p>
+     <p>
+      At the date of issue it can also be found at
+      <a href="http://www.w3.org/2001/xml.xsd">
+       http://www.w3.org/2001/xml.xsd</a>.
+     </p>
+     <p>
+      The schema document at that URI may however change in the future,
+      in order to remain compatible with the latest version of XML
+      Schema itself, or with the XML namespace itself.  In other words,
+      if the XML Schema or XML namespaces change, the version of this
+      document at <a href="http://www.w3.org/2001/xml.xsd">
+       http://www.w3.org/2001/xml.xsd 
+      </a> 
+      will change accordingly; the version at 
+      <a href="http://www.w3.org/2009/01/xml.xsd">
+       http://www.w3.org/2009/01/xml.xsd 
+      </a> 
+      will not change.
+     </p>
+     <p>
+      Previous dated (and unchanging) versions of this schema 
+      document are at:
+     </p>
+     <ul>
+      <li><a href="http://www.w3.org/2009/01/xml.xsd">
+	http://www.w3.org/2009/01/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2007/08/xml.xsd">
+	http://www.w3.org/2007/08/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2004/10/xml.xsd">
+	http://www.w3.org/2004/10/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2001/03/xml.xsd">
+	http://www.w3.org/2001/03/xml.xsd</a></li>
+     </ul>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+</xs:schema>
+

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/test/java/ca/uhn/fhir/jpa/demo/ExampleServerIT.java

@@ -0,0 +1,81 @@
+package ca.uhn.fhir.jpa.demo;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.webapp.WebAppContext;
+import org.hl7.fhir.instance.model.api.IIdType;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.model.dstu2.resource.Patient;
+import ca.uhn.fhir.rest.client.IGenericClient;
+import ca.uhn.fhir.rest.client.ServerValidationModeEnum;
+import ca.uhn.fhir.rest.client.interceptor.LoggingInterceptor;
+
+public class ExampleServerIT {
+
+	private static IGenericClient ourClient;
+	private static FhirContext ourCtx = FhirContext.forDstu2();
+	private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(ExampleServerIT.class);
+
+	private static int ourPort;
+
+	private static Server ourServer;
+	private static String ourServerBase;
+
+	@Test
+	public void testCreateAndRead() throws IOException {
+		String methodName = "testCreateResourceConditional";
+
+		Patient pt = new Patient();
+		pt.addName().addFamily(methodName);
+		IIdType id = ourClient.create().resource(pt).execute().getId();
+
+		Patient pt2 = ourClient.read().resource(Patient.class).withId(id).execute();
+		assertEquals(methodName, pt2.getName().get(0).getFamily().get(0).getValue());
+	}
+
+	@AfterClass
+	public static void afterClass() throws Exception {
+		ourServer.stop();
+	}
+
+	@BeforeClass
+	public static void beforeClass() throws Exception {
+		/*
+		 * This runs under maven, and I'm not sure how else to figure out the target directory from code..
+		 */
+		String path = ExampleServerIT.class.getClassLoader().getResource(".keep_hapi-fhir-jpaserver-example").getPath();
+		path = new File(path).getParent();
+		path = new File(path).getParent();
+		path = new File(path).getParent();
+
+		ourLog.info("Project base path is: {}", path);
+
+		ourPort = RandomServerPortProvider.findFreePort();
+		ourServer = new Server(ourPort);
+
+		WebAppContext webAppContext = new WebAppContext();
+		webAppContext.setContextPath("/");
+		webAppContext.setDescriptor(path + "/src/main/webapp/WEB-INF/web.xml");
+		webAppContext.setResourceBase(path + "/target/hapi-fhir-jpaserver-example");
+		webAppContext.setParentLoaderPriority(true);
+
+		ourServer.setHandler(webAppContext);
+		ourServer.start();
+
+		ourCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.NEVER);
+		ourCtx.getRestfulClientFactory().setSocketTimeout(1200 * 1000);
+		ourServerBase = "http://localhost:" + ourPort + "/baseDstu2";
+		ourClient = ourCtx.newRestfulGenericClient(ourServerBase);
+		ourClient.registerInterceptor(new LoggingInterceptor(true));
+
+	}
+
+}

hapi-fhir-jpaserver-examples/hapi-fhir-jpaserver-example-postgres/src/test/java/ca/uhn/fhir/jpa/demo/RandomServerPortProvider.java

@@ -0,0 +1,36 @@
+package ca.uhn.fhir.jpa.demo;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Provides server ports
+ */
+public class RandomServerPortProvider {
+
+	private static List<Integer> ourPorts = new ArrayList<Integer>(); 
+	
+	public static int findFreePort() {
+		ServerSocket server;
+		try {
+			server = new ServerSocket(0);
+			int port = server.getLocalPort();
+			ourPorts.add(port);
+			server.close();
+			Thread.sleep(500);
+			return port;
+		} catch (IOException e) {
+			throw new Error(e);
+		} catch (InterruptedException e) {
+			throw new Error(e);
+		}
+	}
+
+	public static List<Integer> list() {
+		return ourPorts;
+	}
+
+}
+ 

hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/client/PatchClientDstu3Test.java

@@ -0,0 +1,117 @@
+package ca.uhn.fhir.rest.client;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.nio.charset.Charset;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.io.input.ReaderInputStream;
+import org.apache.http.HttpResponse;
+import org.apache.http.ProtocolVersion;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.message.BasicHeader;
+import org.apache.http.message.BasicStatusLine;
+import org.hl7.fhir.dstu3.model.IdType;
+import org.hl7.fhir.dstu3.model.OperationOutcome;
+import org.hl7.fhir.dstu3.model.Patient;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.internal.stubbing.defaultanswers.ReturnsDeepStubs;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.parser.IParser;
+import ca.uhn.fhir.rest.annotation.IdParam;
+import ca.uhn.fhir.rest.annotation.Patch;
+import ca.uhn.fhir.rest.annotation.ResourceParam;
+import ca.uhn.fhir.rest.api.MethodOutcome;
+import ca.uhn.fhir.rest.api.PatchTypeEnum;
+import ca.uhn.fhir.rest.client.api.IRestfulClient;
+import ca.uhn.fhir.rest.server.Constants;
+import ca.uhn.fhir.util.TestUtil;
+
+public class PatchClientDstu3Test {
+	public interface IClientType extends IRestfulClient {
+
+		@Patch(type=Patient.class)
+		MethodOutcome patch(@IdParam IdType theId, @ResourceParam String theBody, PatchTypeEnum thePatchType);
+		
+	}
+
+	private static FhirContext ourCtx;
+	private HttpClient myHttpClient;
+	private HttpResponse myHttpResponse;
+
+	@Before
+	public void before() {
+		myHttpClient = mock(HttpClient.class, new ReturnsDeepStubs());
+		ourCtx.getRestfulClientFactory().setHttpClient(myHttpClient);
+		ourCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.NEVER);
+		myHttpResponse = mock(HttpResponse.class, new ReturnsDeepStubs());
+	}
+
+	@Test
+	public void testJsonPatch() throws Exception {
+		ArgumentCaptor<HttpUriRequest> capt = prepareResponse();
+
+		IClientType client = ourCtx.newRestfulClient(IClientType.class, "http://example.com/fhir");
+
+		Patient pt = new Patient();
+		pt.getText().setDivAsString("A PATIENT");
+
+		MethodOutcome outcome = client.patch(new IdType("Patient/123"), "{}", PatchTypeEnum.JSON_PATCH);
+
+		assertEquals("PATCH", capt.getAllValues().get(0).getMethod());
+		assertEquals("http://example.com/fhir/Patient/123", capt.getAllValues().get(0).getURI().toASCIIString());
+		assertEquals(Constants.CT_JSON_PATCH, capt.getAllValues().get(0).getFirstHeader("content-type").getValue().replaceAll(";.*", ""));
+		assertEquals("{}", extractBodyAsString(capt));
+		assertEquals("<div xmlns=\"http://www.w3.org/1999/xhtml\">OK</div>", ((OperationOutcome) outcome.getOperationOutcome()).getText().getDivAsString());
+	}
+
+
+	private String extractBodyAsString(ArgumentCaptor<HttpUriRequest> capt) throws IOException {
+		String body = IOUtils.toString(((HttpEntityEnclosingRequestBase) capt.getAllValues().get(0)).getEntity().getContent(), "UTF-8");
+		return body;
+	}
+
+	private ArgumentCaptor<HttpUriRequest> prepareResponse() throws IOException, ClientProtocolException {
+		final IParser p = ourCtx.newXmlParser();
+
+		final OperationOutcome resp1 = new OperationOutcome();
+		resp1.getText().setDivAsString("OK");
+
+		ArgumentCaptor<HttpUriRequest> capt = ArgumentCaptor.forClass(HttpUriRequest.class);
+		when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse);
+		when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK"));
+		when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8"));
+		when(myHttpResponse.getEntity().getContent()).thenAnswer(new Answer<ReaderInputStream>() {
+			@Override
+			public ReaderInputStream answer(InvocationOnMock theInvocation) throws Throwable {
+				return new ReaderInputStream(new StringReader(p.encodeResourceToString(resp1)), Charset.forName("UTF-8"));
+			}
+		});
+		return capt;
+	}
+
+	@AfterClass
+	public static void afterClassClearContext() {
+		TestUtil.clearAllStaticFieldsForUnitTest();
+	}
+
+	@BeforeClass
+	public static void beforeClass() {
+		ourCtx = FhirContext.forDstu3();
+	}
+
+}

hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/server/PatchDstu3Test.java

@@ -0,0 +1,186 @@
+package ca.uhn.fhir.rest.server;
+
+import static org.junit.Assert.assertEquals;
+
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpPatch;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.ServletHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.hl7.fhir.dstu3.model.IdType;
+import org.hl7.fhir.dstu3.model.OperationOutcome;
+import org.hl7.fhir.dstu3.model.Patient;
+import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.rest.annotation.IdParam;
+import ca.uhn.fhir.rest.annotation.Patch;
+import ca.uhn.fhir.rest.annotation.ResourceParam;
+import ca.uhn.fhir.util.PortUtil;
+import ca.uhn.fhir.util.TestUtil;
+
+public class PatchDstu3Test {
+
+	private static CloseableHttpClient ourClient;
+	private static FhirContext ourCtx = FhirContext.forDstu3();
+	private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(PatchDstu3Test.class);
+	private static int ourPort;
+	private static Server ourServer;
+	private static String ourLastMethod;
+
+	@Before
+	public void before() {
+		ourLastMethod = null;
+		ourLastBody = null;
+		ourLastId = null;
+	}
+
+	@Test
+	public void testPatchValidJson() throws Exception {
+		String requestContents = "[ { \"op\": \"add\", \"path\": \"/a/b/c\", \"value\": [ \"foo\", \"bar\" ] } ]";
+		HttpPatch httpPatch = new HttpPatch("http://localhost:" + ourPort + "/Patient/123");
+		httpPatch.setEntity(new StringEntity(requestContents, ContentType.parse(Constants.CT_JSON_PATCH)));
+		CloseableHttpResponse status = ourClient.execute(httpPatch);
+
+		try {
+			String responseContent = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
+			ourLog.info(responseContent);
+			assertEquals(200, status.getStatusLine().getStatusCode());
+			assertEquals("<OperationOutcome xmlns=\"http://hl7.org/fhir\"><text><div xmlns=\"http://www.w3.org/1999/xhtml\">OK</div></text></OperationOutcome>", responseContent);
+		} finally {
+			IOUtils.closeQuietly(status.getEntity().getContent());
+		}
+
+		assertEquals("patientPatch", ourLastMethod);
+		assertEquals("Patient/123", ourLastId.getValue());
+		assertEquals(requestContents, ourLastBody);
+	}
+
+	@Test
+	public void testPatchValidXml() throws Exception {
+		String requestContents = "<root/>";
+		HttpPatch httpPatch = new HttpPatch("http://localhost:" + ourPort + "/Patient/123");
+		httpPatch.setEntity(new StringEntity(requestContents, ContentType.parse(Constants.CT_XML_PATCH)));
+		CloseableHttpResponse status = ourClient.execute(httpPatch);
+
+		try {
+			String responseContent = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
+			ourLog.info(responseContent);
+			assertEquals(200, status.getStatusLine().getStatusCode());
+			assertEquals("<OperationOutcome xmlns=\"http://hl7.org/fhir\"><text><div xmlns=\"http://www.w3.org/1999/xhtml\">OK</div></text></OperationOutcome>", responseContent);
+		} finally {
+			IOUtils.closeQuietly(status.getEntity().getContent());
+		}
+
+		assertEquals("patientPatch", ourLastMethod);
+		assertEquals("Patient/123", ourLastId.getValue());
+		assertEquals(requestContents, ourLastBody);
+	}
+
+	@Test
+	public void testPatchValidJsonWithCharset() throws Exception {
+		String requestContents = "[ { \"op\": \"add\", \"path\": \"/a/b/c\", \"value\": [ \"foo\", \"bar\" ] } ]";
+		HttpPatch httpPatch = new HttpPatch("http://localhost:" + ourPort + "/Patient/123");
+		httpPatch.setEntity(new StringEntity(requestContents, ContentType.parse(Constants.CT_JSON_PATCH + Constants.CHARSET_UTF8_CTSUFFIX)));
+		CloseableHttpResponse status = ourClient.execute(httpPatch);
+
+		try {
+			String responseContent = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
+			ourLog.info(responseContent);
+			assertEquals(200, status.getStatusLine().getStatusCode());
+		} finally {
+			IOUtils.closeQuietly(status.getEntity().getContent());
+		}
+
+		assertEquals("patientPatch", ourLastMethod);
+		assertEquals("Patient/123", ourLastId.getValue());
+		assertEquals(requestContents, ourLastBody);
+	}
+
+	@Test
+	public void testPatchInvalidMimeType() throws Exception {
+		String requestContents = "[ { \"op\": \"add\", \"path\": \"/a/b/c\", \"value\": [ \"foo\", \"bar\" ] } ]";
+		HttpPatch httpPatch = new HttpPatch("http://localhost:" + ourPort + "/Patient/123");
+		httpPatch.setEntity(new StringEntity(requestContents, ContentType.parse("text/plain; charset=UTF-8")));
+		CloseableHttpResponse status = ourClient.execute(httpPatch);
+
+		try {
+			String responseContent = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
+			ourLog.info(responseContent);
+			assertEquals(400, status.getStatusLine().getStatusCode());
+			assertEquals("<OperationOutcome xmlns=\"http://hl7.org/fhir\"><issue><severity value=\"error\"/><code value=\"processing\"/><diagnostics value=\"Invalid Content-Type for PATCH operation: text/plain; charset=UTF-8\"/></issue></OperationOutcome>", responseContent);
+		} finally {
+			IOUtils.closeQuietly(status.getEntity().getContent());
+		}
+
+	}
+
+	@AfterClass
+	public static void afterClassClearContext() throws Exception {
+		ourServer.stop();
+		TestUtil.clearAllStaticFieldsForUnitTest();
+	}
+
+	@BeforeClass
+	public static void beforeClass() throws Exception {
+		ourPort = PortUtil.findFreePort();
+		ourServer = new Server(ourPort);
+
+		DummyPatientResourceProvider patientProvider = new DummyPatientResourceProvider();
+
+		ServletHandler proxyHandler = new ServletHandler();
+		RestfulServer servlet = new RestfulServer(ourCtx);
+		servlet.setPagingProvider(new FifoMemoryPagingProvider(10));
+
+		servlet.setResourceProviders(patientProvider);
+		ServletHolder servletHolder = new ServletHolder(servlet);
+		proxyHandler.addServletWithMapping(servletHolder, "/*");
+		ourServer.setHandler(proxyHandler);
+		ourServer.start();
+
+		PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(5000, TimeUnit.MILLISECONDS);
+		HttpClientBuilder builder = HttpClientBuilder.create();
+		builder.setConnectionManager(connectionManager);
+		ourClient = builder.build();
+
+	}
+
+	private static String ourLastBody;
+	private static IdType ourLastId;
+	public static class DummyPatientResourceProvider implements IResourceProvider {
+
+
+
+		@Override
+		public Class<? extends IBaseResource> getResourceType() {
+			return Patient.class;
+		}
+
+		//@formatter:off
+		@Patch
+		public OperationOutcome patientPatch(@IdParam IdType theId, @ResourceParam String theBody) {
+			ourLastMethod = "patientPatch";
+			ourLastBody = theBody;
+			ourLastId = theId;
+			OperationOutcome retVal = new OperationOutcome();
+			retVal.getText().setDivAsString("<div>OK</div>");
+			return retVal;
+		}
+		//@formatter:on
+
+	}
+
+}

pom.xml

@@ -391,6 +391,11 @@
 				<artifactId>reflow-velocity-tools</artifactId>
 				<version>1.1.1</version>
 			</dependency>
+			<dependency>
+				<groupId>net.riotopsys</groupId>
+				<artifactId>json_patch</artifactId>
+				<version>0.0.0</version>
+			</dependency>
 			<dependency>
 				<groupId>net.sf.json-lib</groupId>
 				<artifactId>json-lib</artifactId>