Fixes #764 to allow the AbstractJaxRsConformanceProvider to support the DSTU2_HL7ORG FhirContext

hapi-fhir-jaxrsserver-base/pom.xml

@@ -51,6 +51,11 @@
 			<artifactId>hapi-fhir-structures-dstu2</artifactId>
 			<version>${project.version}</version>
 		</dependency>
+		<dependency>
+			<groupId>ca.uhn.hapi.fhir</groupId>
+			<artifactId>hapi-fhir-structures-hl7org-dstu2</artifactId>
+			<version>${project.version}</version>
+		</dependency>
 		<dependency>
 			<groupId>ca.uhn.hapi.fhir</groupId>
 			<artifactId>hapi-fhir-structures-dstu3</artifactId>

hapi-fhir-jaxrsserver-base/src/main/java/ca/uhn/fhir/jaxrs/server/AbstractJaxRsConformanceProvider.java

@@ -68,6 +68,7 @@ public abstract class AbstractJaxRsConformanceProvider extends AbstractJaxRsProv
 	/** the conformance. It is created once during startup */
 	private CapabilityStatement myDstu3CapabilityStatement;
 	private ca.uhn.fhir.model.dstu2.resource.Conformance myDstu2Conformance;
+	private org.hl7.fhir.instance.model.Conformance myDstu2Hl7OrgConformance;
 
 	/**
 	 * Constructor allowing the description, servername and server to be set
@@ -132,6 +133,10 @@ public abstract class AbstractJaxRsConformanceProvider extends AbstractJaxRsProv
 			ca.uhn.fhir.rest.server.provider.dstu2.ServerConformanceProvider serverCapabilityStatementProvider = new ca.uhn.fhir.rest.server.provider.dstu2.ServerConformanceProvider(serverConfiguration);
 			serverCapabilityStatementProvider.initializeOperations();
 			myDstu2Conformance = serverCapabilityStatementProvider.getServerConformance(null);
+		} else if (super.getFhirContext().getVersion().getVersion().equals(FhirVersionEnum.DSTU2_HL7ORG)) {
+			org.hl7.fhir.instance.conf.ServerConformanceProvider serverCapabilityStatementProvider = new org.hl7.fhir.instance.conf.ServerConformanceProvider(serverConfiguration);
+			serverCapabilityStatementProvider.initializeOperations();
+			myDstu2Hl7OrgConformance = serverCapabilityStatementProvider.getServerConformance(null);
 		}
 	}
 
@@ -173,6 +178,8 @@ public abstract class AbstractJaxRsConformanceProvider extends AbstractJaxRsProv
 		} else if (super.getFhirContext().getVersion().getVersion().equals(FhirVersionEnum.DSTU2)) {
 			conformance = myDstu2Conformance;
 //			return (Response) response.returnResponse(ParseAction.create(myDstu2CapabilityStatement), Constants.STATUS_HTTP_200_OK, true, null, getResourceType().getSimpleName());
+		} else if (super.getFhirContext().getVersion().getVersion().equals(FhirVersionEnum.DSTU2_HL7ORG)) {
+			conformance = myDstu2Hl7OrgConformance;
 		}
 		
 		if (conformance != null) {
@@ -261,6 +268,8 @@ public abstract class AbstractJaxRsConformanceProvider extends AbstractJaxRsProv
 			return Class.class.cast(CapabilityStatement.class);
 		} else if (super.getFhirContext().getVersion().getVersion().equals(FhirVersionEnum.DSTU2)) {
 			return Class.class.cast(ca.uhn.fhir.model.dstu2.resource.Conformance.class);
+		} else if (super.getFhirContext().getVersion().getVersion().equals(FhirVersionEnum.DSTU2_HL7ORG)) {
+			return Class.class.cast(org.hl7.fhir.instance.model.Conformance.class);
 		}
 		return null;
 	}

hapi-fhir-jaxrsserver-base/src/test/java/ca/uhn/fhir/jaxrs/server/AbstractJaxRsConformanceProviderDstu2Hl7OrgTest.java

@@ -0,0 +1,109 @@
+package ca.uhn.fhir.jaxrs.server;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+import java.util.Arrays;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.ws.rs.HttpMethod;
+import javax.ws.rs.core.*;
+
+import org.glassfish.jersey.internal.MapPropertiesDelegate;
+import org.glassfish.jersey.server.ContainerRequest;
+import org.junit.Before;
+import org.junit.Test;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.jaxrs.server.test.TestJaxRsDummyPatientProvider;
+import ca.uhn.fhir.jaxrs.server.test.TestJaxRsMockPatientRestProviderDstu2Hl7Org;
+import ca.uhn.fhir.rest.api.Constants;
+import ca.uhn.fhir.rest.server.IResourceProvider;
+
+public class AbstractJaxRsConformanceProviderDstu2Hl7OrgTest {
+
+	private static final String BASEURI = "http://basiuri";
+	private static final String REQUESTURI = BASEURI + "/metadata";
+	AbstractJaxRsConformanceProvider provider;
+	private ConcurrentHashMap<Class<? extends IResourceProvider>, IResourceProvider> providers;
+	private ContainerRequest headers;
+	private MultivaluedHashMap<String, String> queryParameters;
+
+	@Before
+	public void setUp() throws Exception {
+		// headers
+		headers = new ContainerRequest(new URI(BASEURI), new URI(REQUESTURI), HttpMethod.GET, null,
+				new MapPropertiesDelegate());
+		// uri info
+		queryParameters = new MultivaluedHashMap<String, String>();
+
+
+		providers = new ConcurrentHashMap<Class<? extends IResourceProvider>, IResourceProvider>();
+		provider = createConformanceProvider(providers);
+	}
+
+	@Test
+	public void testConformance() throws Exception {
+		providers.put(AbstractJaxRsConformanceProvider.class, provider);
+		providers.put(TestJaxRsDummyPatientProvider.class, new TestJaxRsDummyPatientProvider());
+		Response response = createConformanceProvider(providers).conformance();
+		System.out.println(response);
+	}
+
+	@Test
+	public void testConformanceUsingOptions() throws Exception {
+		providers.put(AbstractJaxRsConformanceProvider.class, provider);
+		providers.put(TestJaxRsDummyPatientProvider.class, new TestJaxRsDummyPatientProvider());
+		Response response = createConformanceProvider(providers).conformanceUsingOptions();
+		System.out.println(response);
+	}
+
+	@Test
+	public void testConformanceWithMethods() throws Exception {
+		providers.put(AbstractJaxRsConformanceProvider.class, provider);
+		providers.put(TestJaxRsMockPatientRestProviderDstu2Hl7Org.class, new TestJaxRsMockPatientRestProviderDstu2Hl7Org());
+		Response response = createConformanceProvider(providers).conformance();
+		assertEquals(Constants.STATUS_HTTP_200_OK, response.getStatus());
+		assertTrue(response.getEntity().toString().contains("\"type\": \"Patient\""));
+		assertTrue(response.getEntity().toString().contains("someCustomOperation"));
+		System.out.println(response);
+		System.out.println(response.getEntity());
+	}
+
+	@Test
+	public void testConformanceInXml() throws Exception {
+		queryParameters.put(Constants.PARAM_FORMAT, Arrays.asList(Constants.CT_XML));
+		providers.put(AbstractJaxRsConformanceProvider.class, provider);
+		providers.put(TestJaxRsMockPatientRestProviderDstu2Hl7Org.class, new TestJaxRsMockPatientRestProviderDstu2Hl7Org());
+		Response response = createConformanceProvider(providers).conformance();
+		assertEquals(Constants.STATUS_HTTP_200_OK, response.getStatus());
+		System.out.println(response.getEntity());
+		assertTrue(response.getEntity().toString().contains(" <type value=\"Patient\"/>"));
+		assertTrue(response.getEntity().toString().contains("someCustomOperation"));
+		System.out.println(response.getEntity());
+	}
+
+	private AbstractJaxRsConformanceProvider createConformanceProvider(final ConcurrentHashMap<Class<? extends IResourceProvider>, IResourceProvider> providers)
+			throws Exception {
+		AbstractJaxRsConformanceProvider result = new AbstractJaxRsConformanceProvider(FhirContext.forDstu2Hl7Org(), null, null, null) {
+			@Override
+			protected ConcurrentHashMap<Class<? extends IResourceProvider>, IResourceProvider> getProviders() {
+				return providers;
+			}
+		};
+		// mocks
+		UriInfo uriInfo = mock(UriInfo.class);
+		when(uriInfo.getQueryParameters()).thenReturn(queryParameters);
+		when(uriInfo.getBaseUri()).thenReturn(new URI(BASEURI));
+		when(uriInfo.getRequestUri()).thenReturn(new URI(BASEURI + "/foo"));
+		result.setUriInfo(uriInfo);
+		result.setHeaders(headers);
+		result.setUpPostConstruct();
+		return result;
+	}
+
+}
+

hapi-fhir-jaxrsserver-base/src/test/java/ca/uhn/fhir/jaxrs/server/test/TestJaxRsMockPatientRestProviderDstu2Hl7Org.java

@@ -0,0 +1,128 @@
+package ca.uhn.fhir.jaxrs.server.test;
+
+import java.util.List;
+
+import javax.ejb.Stateless;
+import javax.interceptor.Interceptors;
+import javax.ws.rs.*;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+
+import org.hl7.fhir.instance.model.*;
+import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.mockito.Mockito;
+
+import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.jaxrs.server.AbstractJaxRsResourceProvider;
+import ca.uhn.fhir.jaxrs.server.interceptor.JaxRsExceptionInterceptor;
+import ca.uhn.fhir.rest.annotation.*;
+import ca.uhn.fhir.rest.api.*;
+import ca.uhn.fhir.rest.api.Constants;
+import ca.uhn.fhir.rest.param.StringAndListParam;
+import ca.uhn.fhir.rest.param.StringParam;
+import ca.uhn.fhir.rest.server.FifoMemoryPagingProvider;
+import ca.uhn.fhir.rest.server.IPagingProvider;
+
+/**
+ * A test server delegating each call to a mock
+ */
+@Path(TestJaxRsMockPatientRestProviderDstu2Hl7Org.PATH)
+@Stateless
+@Produces({ MediaType.APPLICATION_JSON, Constants.CT_FHIR_JSON, Constants.CT_FHIR_XML, Constants.CT_FHIR_JSON_NEW, Constants.CT_FHIR_XML_NEW })
+@Interceptors(JaxRsExceptionInterceptor.class)
+public class TestJaxRsMockPatientRestProviderDstu2Hl7Org extends AbstractJaxRsResourceProvider<Patient> {
+
+	static final String PATH = "/Patient";
+
+	public static final TestJaxRsMockPatientRestProviderDstu2Hl7Org mock = Mockito.mock(TestJaxRsMockPatientRestProviderDstu2Hl7Org.class);
+
+	public static final FifoMemoryPagingProvider PAGING_PROVIDER;
+
+	static
+	{
+		PAGING_PROVIDER = new FifoMemoryPagingProvider(10);
+		PAGING_PROVIDER.setDefaultPageSize(10);
+		PAGING_PROVIDER.setMaximumPageSize(100);
+	}
+
+	/**
+	 * Constructor
+	 */
+	public TestJaxRsMockPatientRestProviderDstu2Hl7Org() {
+		super(FhirContext.forDstu2Hl7Org());
+	}
+
+	@Search
+	public List<Patient> search(@RequiredParam(name = Patient.SP_NAME) final StringParam name, @RequiredParam(name=Patient.SP_ADDRESS) StringAndListParam theAddressParts) {
+		return mock.search(name, theAddressParts);
+	}
+
+	@Update
+	public MethodOutcome update(@IdParam final IdType theId, @ResourceParam final Patient patient,@ConditionalUrlParam final String theConditional) throws Exception {
+		return mock.update(theId, patient, theConditional);
+	}
+
+	@Read
+	public Patient find(@IdParam final IdType theId) {
+		return mock.find(theId);
+	}
+
+	@Read(version = true)
+	public Patient findHistory(@IdParam final IdType theId) {
+		return mock.findHistory(theId);
+	}
+
+	@Create
+	public MethodOutcome create(@ResourceParam final Patient patient, @ConditionalUrlParam String theConditional)
+			throws Exception {
+		return mock.create(patient, theConditional);
+	}
+
+	@Delete
+	public MethodOutcome delete(@IdParam final IdType theId, @ConditionalUrlParam final String theConditional) {
+		return mock.delete(theId, theConditional);
+	}
+
+    @Search(compartmentName = "Condition")
+    public List<IBaseResource> searchCompartment(@IdParam IdType thePatientId) {
+        return mock.searchCompartment(thePatientId);
+    }
+
+	@GET
+	@Path("/{id}/$someCustomOperation")
+	public Response someCustomOperationUsingGet(@PathParam("id") String id, String resource) throws Exception {
+		return customOperation(resource, RequestTypeEnum.GET, id, "$someCustomOperation",
+				RestOperationTypeEnum.EXTENDED_OPERATION_INSTANCE);
+	}
+
+	@POST
+	@Path("/{id}/$someCustomOperation")
+	public Response someCustomOperationUsingPost(@PathParam("id") String id, String resource) throws Exception {
+		return customOperation(resource, RequestTypeEnum.POST, id, "$someCustomOperation",
+				RestOperationTypeEnum.EXTENDED_OPERATION_INSTANCE);
+	}
+
+	@Operation(name = "someCustomOperation", idempotent = true, returnParameters = {
+			@OperationParam(name = "return", type = StringType.class) })
+	public Parameters someCustomOperation(@IdParam IdType myId, @OperationParam(name = "dummy") StringType dummyInput) {
+		return mock.someCustomOperation(myId, dummyInput);
+	}
+
+	@Validate()
+	public MethodOutcome validate(@ResourceParam final Patient resource) {
+		MethodOutcome mO = new MethodOutcome();
+		mO.setOperationOutcome(new OperationOutcome());
+		return mO;
+	}
+
+	@Override
+	public Class<Patient> getResourceType() {
+		return Patient.class;
+	}
+
+	@Override
+	public IPagingProvider getPagingProvider() {
+		return PAGING_PROVIDER;
+	}
+
+}

hapi-fhir-structures-hl7org-dstu2/src/main/java/org/hl7/fhir/instance/conf/ServerConformanceProvider.java

@@ -28,6 +28,7 @@ import java.util.*;
 import java.util.Map.Entry;
 import java.util.jar.Manifest;
 
+import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
 
 import ca.uhn.fhir.context.FhirVersionEnum;
@@ -70,10 +71,14 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
 	private IdentityHashMap<OperationMethodBinding, String> myOperationBindingToName;
 	private HashMap<String, List<OperationMethodBinding>> myOperationNameToBindings;
 	private String myPublisher = "Not provided";
-	private RestfulServer myRestfulServer;
+  private RestulfulServerConfiguration myServerConfiguration;
 
 	public ServerConformanceProvider(RestfulServer theRestfulServer) {
-		myRestfulServer = theRestfulServer;
+     this.myServerConfiguration = theRestfulServer.createConfiguration();
+	}
+
+  public ServerConformanceProvider(RestulfulServerConfiguration theServerConfiguration) {
+    this.myServerConfiguration = theServerConfiguration;
   }
 	
 	/*
@@ -86,8 +91,13 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
 		super();
 	}
 
+	@Override
 	public void setRestfulServer (RestfulServer theRestfulServer) {
-		myRestfulServer = theRestfulServer;
+     myServerConfiguration = theRestfulServer.createConfiguration();
+	}
+
+  RestulfulServerConfiguration getServerConfiguration() {
+    return myServerConfiguration;
   }
 
   private void checkBindingForSystemOps(ConformanceRestComponent rest, Set<SystemRestfulInteraction> systemOps,
@@ -114,7 +124,7 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
 
   private Map<String, List<BaseMethodBinding<?>>> collectMethodBindings() {
     Map<String, List<BaseMethodBinding<?>>> resourceToMethods = new TreeMap<String, List<BaseMethodBinding<?>>>();
-    for (ResourceBinding next : myRestfulServer.getResourceBindings()) {
+    for (ResourceBinding next : myServerConfiguration.getResourceBindings()) {
       String resourceName = next.getResourceName();
       for (BaseMethodBinding<?> nextMethodBinding : next.getMethodBindings()) {
         if (resourceToMethods.containsKey(resourceName) == false) {
@@ -123,7 +133,7 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
         resourceToMethods.get(resourceName).add(nextMethodBinding);
       }
     }
-    for (BaseMethodBinding<?> nextMethodBinding : myRestfulServer.getServerBindings()) {
+    for (BaseMethodBinding<?> nextMethodBinding : myServerConfiguration.getServerBindings()) {
       String resourceName = "";
       if (resourceToMethods.containsKey(resourceName) == false) {
         resourceToMethods.put(resourceName, new ArrayList<BaseMethodBinding<?>>());
@@ -163,10 +173,10 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
     retVal.setAcceptUnknown(UnknownContentCode.EXTENSIONS); // TODO: make this configurable - this is a fairly big effort since the parser
     // needs to be modified to actually allow it
 
-    retVal.getImplementation().setDescription(myRestfulServer.getImplementationDescription());
+    retVal.getImplementation().setDescription(myServerConfiguration.getImplementationDescription());
     retVal.setKind(ConformanceStatementKind.INSTANCE);
-    retVal.getSoftware().setName(myRestfulServer.getServerName());
+    retVal.getSoftware().setName(myServerConfiguration.getServerName());
-    retVal.getSoftware().setVersion(myRestfulServer.getServerVersion());
+    retVal.getSoftware().setVersion(myServerConfiguration.getServerVersion());
     retVal.addFormat(Constants.CT_FHIR_XML);
     retVal.addFormat(Constants.CT_FHIR_JSON);
 
@@ -183,10 +193,11 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
         Set<TypeRestfulInteraction> resourceOps = new HashSet<TypeRestfulInteraction>();
         ConformanceRestResourceComponent resource = rest.addResource();
         String resourceName = nextEntry.getKey();
-        RuntimeResourceDefinition def = myRestfulServer.getFhirContext().getResourceDefinition(resourceName);
+        RuntimeResourceDefinition def = myServerConfiguration.getFhirContext().getResourceDefinition(resourceName);
         resource.getTypeElement().setValue(def.getName());
-        resource.getProfile()
+        ServletContext servletContext = (ServletContext) (theRequest == null ? null : theRequest.getAttribute(RestfulServer.SERVLET_CONTEXT_ATTRIBUTE));
-            .setReference((def.getResourceProfile(myRestfulServer.getServerBaseForRequest(theRequest))));
+        String serverBase = myServerConfiguration.getServerAddressStrategy().determineServerBase(servletContext, theRequest);
+        resource.getProfile().setReference((def.getResourceProfile(serverBase)));
 
         TreeSet<String> includes = new TreeSet<String>();
 
@@ -296,7 +307,7 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
   }
 
   private Date conformanceDate() {
-    String buildDate = getBuildDateFromManifest();
+    String buildDate = myServerConfiguration.getConformanceDate();
     if (buildDate != null) {
       DateFormat dateFormat = new SimpleDateFormat();
       try {
@@ -308,21 +319,6 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
     return new Date();
   }
 
-  private String getBuildDateFromManifest() {
-    if (myRestfulServer != null && myRestfulServer.getServletContext() != null) {
-      InputStream inputStream = myRestfulServer.getServletContext().getResourceAsStream("/META-INF/MANIFEST.MF");
-      if (inputStream != null) {
-        try {
-          Manifest manifest = new Manifest(inputStream);
-          return manifest.getMainAttributes().getValue("Build-Time");
-        } catch (IOException e) {
-          // fall through
-        }
-      }
-    }
-    return null;
-  }
-
   private void handleDynamicSearchMethodBinding(ConformanceRestResourceComponent resource,
       RuntimeResourceDefinition def, TreeSet<String> includes, DynamicSearchMethodBinding searchMethodBinding) {
     includes.addAll(searchMethodBinding.getIncludes());
@@ -433,7 +429,7 @@ public class ServerConformanceProvider implements IServerConformanceProvider<Con
           param.getTypeElement().setValueAsString(nextParameter.getParamType().getCode());
         }
         for (Class<? extends IBaseResource> nextTarget : nextParameter.getDeclaredTypes()) {
-          RuntimeResourceDefinition targetDef = myRestfulServer.getFhirContext().getResourceDefinition(nextTarget);
+          RuntimeResourceDefinition targetDef = myServerConfiguration.getFhirContext().getResourceDefinition(nextTarget);
           if (targetDef != null) {
             ResourceType code;
             try {