Merge branch 'master' into more_properties

# Conflicts:
#	src/main/java/ca/uhn/fhir/jpa/starter/HapiProperties.java
#	src/main/resources/hapi.properties

src/main/java/ca/uhn/fhir/jpa/starter/FhirServerConfigCommon.java

@@ -0,0 +1,93 @@
+package ca.uhn.fhir.jpa.starter;
+
+import java.lang.reflect.InvocationTargetException;
+import java.sql.Driver;
+
+import ca.uhn.fhir.jpa.model.entity.ModelConfig;
+import org.apache.commons.dbcp2.BasicDataSource;
+import org.hl7.fhir.instance.model.Subscription;
+import org.springframework.beans.factory.annotation.Autowire;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+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 is the primary configuration file for the example server
+ */
+@Configuration
+@EnableTransactionManagement()
+public class FhirServerConfigCommon {
+
+	/**
+	 * Configure FHIR properties around the the JPA server via this bean
+	 */
+	@Bean()
+	public DaoConfig daoConfig() {
+		DaoConfig retVal = new DaoConfig();
+		retVal.setAllowMultipleDelete(HapiProperties.getAllowMultipleDelete());
+		retVal.setAllowExternalReferences(HapiProperties.getAllowExternalReferences());
+		retVal.setExpungeEnabled(HapiProperties.getExpungeEnabled());
+		retVal.setAutoCreatePlaceholderReferenceTargets(HapiProperties.getAllowPlaceholderReferences());
+		
+		// You can enable these if you want to support Subscriptions from your server
+		if (HapiProperties.getSubscriptionRestHookEnabled()) {
+			retVal.addSupportedSubscriptionType(Subscription.SubscriptionChannelType.RESTHOOK);
+		}
+		if (HapiProperties.getSubscriptionEmailEnabled()) {
+			retVal.addSupportedSubscriptionType(Subscription.SubscriptionChannelType.EMAIL);
+		}
+
+    	return retVal;
+	}
+
+	@Bean
+	public ModelConfig modelConfig() {
+		return new ModelConfig();
+	}
+
+	/**
+	 * 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 BasicDataSource dataSource() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
+		BasicDataSource retVal = new BasicDataSource();
+		Driver driver = (Driver) Class.forName(HapiProperties.getDataSourceDriver()).getConstructor().newInstance();
+		retVal.setDriver(driver);
+		retVal.setUrl(HapiProperties.getDataSourceUrl());
+		retVal.setUsername(HapiProperties.getDataSourceUsername());
+		retVal.setPassword(HapiProperties.getDataSourcePassword());
+		return retVal;
+	}
+
+
+	/**
+	 * 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(HapiProperties.getLoggerName());
+		retVal.setMessageFormat(HapiProperties.getLoggerFormat());
+		retVal.setErrorMessageFormat(HapiProperties.getLoggerErrorFormat());
+		retVal.setLogExceptions(HapiProperties.getLoggerLogExceptions());
+		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;
+	}
+
+}

src/main/java/ca/uhn/fhir/jpa/starter/FhirServerConfigDstu2.java

@@ -0,0 +1,57 @@
+package ca.uhn.fhir.jpa.starter;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.jpa.config.BaseJavaConfigDstu2;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+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 javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+@Configuration
+public class FhirServerConfigDstu2 extends BaseJavaConfigDstu2 {
+
+    @Autowired
+    private DataSource myDataSource;
+
+    /**
+     * We override the paging provider definition so that we can customize
+     * the default/max page sizes for search results. You can set these however
+     * you want, although very large page sizes will require a lot of RAM.
+     */
+    @Override
+    public DatabaseBackedPagingProvider databaseBackedPagingProvider() {
+        DatabaseBackedPagingProvider pagingProvider = super.databaseBackedPagingProvider();
+        pagingProvider.setDefaultPageSize(HapiProperties.getDefaultPageSize());
+        pagingProvider.setMaximumPageSize(HapiProperties.getMaximumPageSize());
+        return pagingProvider;
+    }
+
+    @Override
+    @Bean()
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        LocalContainerEntityManagerFactoryBean retVal = super.entityManagerFactory();
+        retVal.setPersistenceUnitName(HapiProperties.getPersistenceUnitName());
+
+        try {
+            retVal.setDataSource(myDataSource);
+        } catch (Exception e) {
+            throw new ConfigurationException("Could not set the data source due to a configuration issue", e);
+        }
+
+        retVal.setJpaProperties(HapiProperties.getProperties());
+        return retVal;
+    }
+
+    @Bean()
+    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+        JpaTransactionManager retVal = new JpaTransactionManager();
+        retVal.setEntityManagerFactory(entityManagerFactory);
+        return retVal;
+    }
+
+}

src/main/java/ca/uhn/fhir/jpa/starter/FhirServerConfigDstu3.java

@@ -0,0 +1,57 @@
+package ca.uhn.fhir.jpa.starter;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.jpa.config.BaseJavaConfigDstu3;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+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 javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+@Configuration
+public class FhirServerConfigDstu3 extends BaseJavaConfigDstu3 {
+
+    @Autowired
+    private DataSource myDataSource;
+
+    /**
+     * We override the paging provider definition so that we can customize
+     * the default/max page sizes for search results. You can set these however
+     * you want, although very large page sizes will require a lot of RAM.
+     */
+    @Override
+    public DatabaseBackedPagingProvider databaseBackedPagingProvider() {
+        DatabaseBackedPagingProvider pagingProvider = super.databaseBackedPagingProvider();
+        pagingProvider.setDefaultPageSize(HapiProperties.getDefaultPageSize());
+        pagingProvider.setMaximumPageSize(HapiProperties.getMaximumPageSize());
+        return pagingProvider;
+    }
+
+    @Override
+    @Bean()
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        LocalContainerEntityManagerFactoryBean retVal = super.entityManagerFactory();
+        retVal.setPersistenceUnitName(HapiProperties.getPersistenceUnitName());
+
+        try {
+            retVal.setDataSource(myDataSource);
+        } catch (Exception e) {
+            throw new ConfigurationException("Could not set the data source due to a configuration issue", e);
+        }
+
+        retVal.setJpaProperties(HapiProperties.getProperties());
+        return retVal;
+    }
+
+    @Bean()
+    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+        JpaTransactionManager retVal = new JpaTransactionManager();
+        retVal.setEntityManagerFactory(entityManagerFactory);
+        return retVal;
+    }
+
+}

src/main/java/ca/uhn/fhir/jpa/starter/FhirServerConfigR4.java

@@ -0,0 +1,57 @@
+package ca.uhn.fhir.jpa.starter;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.jpa.config.BaseJavaConfigR4;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+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 javax.persistence.EntityManagerFactory;
+import javax.sql.DataSource;
+
+@Configuration
+public class FhirServerConfigR4 extends BaseJavaConfigR4 {
+
+    @Autowired
+    private DataSource myDataSource;
+
+    /**
+     * We override the paging provider definition so that we can customize
+     * the default/max page sizes for search results. You can set these however
+     * you want, although very large page sizes will require a lot of RAM.
+     */
+    @Override
+    public DatabaseBackedPagingProvider databaseBackedPagingProvider() {
+        DatabaseBackedPagingProvider pagingProvider = super.databaseBackedPagingProvider();
+        pagingProvider.setDefaultPageSize(HapiProperties.getDefaultPageSize());
+        pagingProvider.setMaximumPageSize(HapiProperties.getMaximumPageSize());
+        return pagingProvider;
+    }
+
+    @Override
+    @Bean()
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
+        LocalContainerEntityManagerFactoryBean retVal = super.entityManagerFactory();
+        retVal.setPersistenceUnitName(HapiProperties.getPersistenceUnitName());
+
+        try {
+            retVal.setDataSource(myDataSource);
+        } catch (Exception e) {
+            throw new ConfigurationException("Could not set the data source due to a configuration issue", e);
+        }
+
+        retVal.setJpaProperties(HapiProperties.getProperties());
+        return retVal;
+    }
+
+    @Bean()
+    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
+        JpaTransactionManager retVal = new JpaTransactionManager();
+        retVal.setEntityManagerFactory(entityManagerFactory);
+        return retVal;
+    }
+
+}

src/main/java/ca/uhn/fhir/jpa/starter/FhirTesterConfig.java

@@ -0,0 +1,50 @@
+package ca.uhn.fhir.jpa.starter;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+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-starter". 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(HapiProperties.getServerId())
+				.withFhirVersion(HapiProperties.getFhirVersion())
+				.withBaseUrl("${serverBase}" + HapiProperties.getServerBase())
+				.withName(HapiProperties.getServerName());
+		return retVal;
+	}
+
+}
+//@formatter:on

src/main/java/ca/uhn/fhir/jpa/starter/HapiProperties.java

@@ -0,0 +1,238 @@
+package ca.uhn.fhir.jpa.starter;
+
+import ca.uhn.fhir.context.ConfigurationException;
+import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.rest.api.EncodingEnum;
+import ca.uhn.fhir.rest.server.ETagSupportEnum;
+import com.google.common.annotations.VisibleForTesting;
+
+import java.io.InputStream;
+import java.util.Properties;
+
+public class HapiProperties {
+    static final String ALLOW_EXTERNAL_REFERENCES = "allow_external_references";
+    static final String ALLOW_MULTIPLE_DELETE = "allow_multiple_delete";
+    static final String ALLOW_PLACEHOLDER_REFERENCES = "allow_placeholder_references";
+    static final String DATASOURCE_DRIVER = "datasource.driver";
+    static final String DATASOURCE_PASSWORD = "datasource.password";
+    static final String DATASOURCE_URL = "datasource.url";
+    static final String DATASOURCE_USERNAME = "datasource.username";
+    static final String DEFAULT_ENCODING = "default_encoding";
+    static final String DEFAULT_PAGE_SIZE = "default_page_size";
+    static final String DEFAULT_PRETTY_PRINT = "default_pretty_print";
+    static final String ETAG_SUPPORT = "etag_support";
+    static final String FHIR_VERSION = "fhir_version";
+    static final String HAPI_PROPERTIES = "hapi.properties";
+    static final String LOGGER_ERROR_FORMAT = "logger.error_format";
+    static final String LOGGER_FORMAT = "logger.format";
+    static final String LOGGER_LOG_EXCEPTIONS = "logger.log_exceptions";
+    static final String LOGGER_NAME = "logger.name";
+    static final String MAX_PAGE_SIZE = "max_page_size";
+    static final String PERSISTENCE_UNIT_NAME = "persistence_unit_name";
+    static final String SERVER_ADDRESS = "server_address";
+    static final String SERVER_BASE = "server.base";
+    static final String SERVER_ID = "server.id";
+    static final String SERVER_NAME = "server.name";
+    static final String SUBSCRIPTION_EMAIL_ENABLED = "subscription.email.enabled";
+    static final String SUBSCRIPTION_RESTHOOK_ENABLED = "subscription.resthook.enabled";
+    static final String TEST_PORT = "test.port";
+
+    private static Properties properties;
+
+    /*
+     * Force the configuration to be reloaded
+     */
+    public static void forceReload() {
+        properties = null;
+        getProperties();
+    }
+
+    /**
+     * This is mostly here for unit tests. Use the actual properties file
+     * to set values
+     */
+    @VisibleForTesting
+    public static void setProperty(String theKey, String theValue) {
+        getProperties().setProperty(theKey, theValue);
+    }
+
+    public static Properties getProperties() {
+        if (properties == null) {
+            // Load the configurable properties file
+            try (InputStream in = HapiProperties.class.getClassLoader().getResourceAsStream(HAPI_PROPERTIES)){
+                HapiProperties.properties = new Properties();
+                HapiProperties.properties.load(in);
+            } catch (Exception e) {
+                throw new ConfigurationException("Could not load HAPI properties", e);
+            }
+        }
+
+        return properties;
+    }
+
+    private static String getProperty(String propertyName) {
+        Properties properties = HapiProperties.getProperties();
+
+        if (properties != null) {
+            return properties.getProperty(propertyName);
+        }
+
+        return null;
+    }
+
+    private static String getProperty(String propertyName, String defaultValue) {
+        Properties properties = HapiProperties.getProperties();
+
+        if (properties != null) {
+            String value = properties.getProperty(propertyName);
+
+            if (value != null && value.length() > 0) {
+                return value;
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static Boolean getBooleanProperty(String propertyName, Boolean defaultValue) {
+        String value = HapiProperties.getProperty(propertyName);
+
+        if (value == null || value.length() == 0) {
+            return defaultValue;
+        }
+
+        return Boolean.parseBoolean(value);
+    }
+
+    private static Integer getIntegerProperty(String propertyName, Integer defaultValue) {
+        String value = HapiProperties.getProperty(propertyName);
+
+        if (value == null || value.length() == 0) {
+            return defaultValue;
+        }
+
+        return Integer.parseInt(value);
+    }
+
+    public static FhirVersionEnum getFhirVersion() {
+        String fhirVersionString = HapiProperties.getProperty(FHIR_VERSION);
+
+        if (fhirVersionString != null && fhirVersionString.length() > 0) {
+            return FhirVersionEnum.valueOf(fhirVersionString);
+        }
+
+        return FhirVersionEnum.DSTU3;
+    }
+
+    public static ETagSupportEnum getEtagSupport() {
+        String etagSupportString = HapiProperties.getProperty(ETAG_SUPPORT);
+
+        if (etagSupportString != null && etagSupportString.length() > 0) {
+            return ETagSupportEnum.valueOf(etagSupportString);
+        }
+
+        return ETagSupportEnum.ENABLED;
+    }
+
+    public static EncodingEnum getDefaultEncoding() {
+        String defaultEncodingString = HapiProperties.getProperty(DEFAULT_ENCODING);
+
+        if (defaultEncodingString != null && defaultEncodingString.length() > 0) {
+            return EncodingEnum.valueOf(defaultEncodingString);
+        }
+
+        return EncodingEnum.JSON;
+    }
+
+    public static Boolean getDefaultPrettyPrint() {
+        return HapiProperties.getBooleanProperty(DEFAULT_PRETTY_PRINT, true);
+    }
+
+    public static String getServerAddress() {
+        return HapiProperties.getProperty(SERVER_ADDRESS);
+    }
+
+    public static Integer getDefaultPageSize() {
+        return HapiProperties.getIntegerProperty(DEFAULT_PAGE_SIZE, 20);
+    }
+
+    public static Integer getMaximumPageSize() {
+        return HapiProperties.getIntegerProperty(MAX_PAGE_SIZE, 200);
+    }
+
+    public static String getPersistenceUnitName() {
+        return HapiProperties.getProperty(PERSISTENCE_UNIT_NAME, "HAPI_PU");
+    }
+
+    public static String getLoggerName() {
+        return HapiProperties.getProperty(LOGGER_NAME, "fhirtest.access");
+    }
+
+    public static String getLoggerFormat() {
+        return HapiProperties.getProperty(LOGGER_FORMAT, "Path[${servletPath}] Source[${requestHeader.x-forwarded-for}] Operation[${operationType} ${operationName} ${idOrResourceName}] UA[${requestHeader.user-agent}] Params[${requestParameters}] ResponseEncoding[${responseEncodingNoDefault}]");
+    }
+
+    public static String getLoggerErrorFormat() {
+        return HapiProperties.getProperty(LOGGER_ERROR_FORMAT, "ERROR - ${requestVerb} ${requestUrl}");
+    }
+
+    public static Boolean getLoggerLogExceptions() {
+        return HapiProperties.getBooleanProperty(LOGGER_LOG_EXCEPTIONS, true);
+    }
+
+    public static String getDataSourceDriver() {
+        return HapiProperties.getProperty(DATASOURCE_DRIVER, "org.apache.derby.jdbc.EmbeddedDriver");
+    }
+
+    public static String getDataSourceUrl() {
+        return HapiProperties.getProperty(DATASOURCE_URL, "jdbc:derby:directory:target/jpaserver_derby_files;create=true");
+    }
+
+    public static String getDataSourceUsername() {
+        return HapiProperties.getProperty(DATASOURCE_USERNAME);
+    }
+
+    public static String getDataSourcePassword() {
+        return HapiProperties.getProperty(DATASOURCE_PASSWORD);
+    }
+
+    public static Boolean getAllowMultipleDelete() {
+        return HapiProperties.getBooleanProperty(ALLOW_MULTIPLE_DELETE, true);
+    }
+
+    public static Boolean getAllowExternalReferences() {
+        return HapiProperties.getBooleanProperty(ALLOW_EXTERNAL_REFERENCES, true);
+    }
+
+    public static Boolean getExpungeEnabled() {
+        return HapiProperties.getBooleanProperty("expunge_enabled", true);
+    }
+
+    public static Integer getTestPort() {
+        return HapiProperties.getIntegerProperty(TEST_PORT, 0);
+    }
+
+    public static String getServerBase() {
+        return HapiProperties.getProperty(SERVER_BASE, "/fhir");
+    }
+
+    public static String getServerName() {
+        return HapiProperties.getProperty(SERVER_NAME, "Local Tester");
+    }
+
+    public static String getServerId() {
+        return HapiProperties.getProperty(SERVER_ID, "home");
+    }
+
+    public static Boolean getAllowPlaceholderReferences() {
+        return HapiProperties.getBooleanProperty(ALLOW_PLACEHOLDER_REFERENCES, true);
+    }
+
+    public static Boolean getSubscriptionEmailEnabled() {
+        return HapiProperties.getBooleanProperty(SUBSCRIPTION_EMAIL_ENABLED, true);
+    }
+
+    public static Boolean getSubscriptionRestHookEnabled() {
+        return HapiProperties.getBooleanProperty(SUBSCRIPTION_RESTHOOK_ENABLED, true);
+    }
+}

src/main/java/ca/uhn/fhir/jpa/starter/JpaRestfulServer.java

@@ -0,0 +1,178 @@
+package ca.uhn.fhir.jpa.starter;
+
+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.JpaConformanceProviderDstu2;
+import ca.uhn.fhir.jpa.provider.JpaSystemProviderDstu2;
+import ca.uhn.fhir.jpa.provider.SubscriptionTriggeringProvider;
+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.provider.r4.JpaConformanceProviderR4;
+import ca.uhn.fhir.jpa.provider.r4.JpaSystemProviderR4;
+import ca.uhn.fhir.jpa.provider.r4.TerminologyUploaderProviderR4;
+import ca.uhn.fhir.jpa.search.DatabaseBackedPagingProvider;
+import ca.uhn.fhir.model.dstu2.composite.MetaDt;
+import ca.uhn.fhir.narrative.DefaultThymeleafNarrativeGenerator;
+import ca.uhn.fhir.rest.server.HardcodedServerAddressStrategy;
+import ca.uhn.fhir.rest.server.IResourceProvider;
+import ca.uhn.fhir.rest.server.RestfulServer;
+import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor;
+import org.hl7.fhir.dstu3.model.Bundle;
+import org.hl7.fhir.dstu3.model.Meta;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+import javax.servlet.ServletException;
+import java.util.List;
+
+public class JpaRestfulServer extends RestfulServer {
+
+    private static final long serialVersionUID = 1L;
+    private AnnotationConfigApplicationContext appCtx;
+
+    @Override
+    public void destroy() {
+        appCtx.close();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected void initialize() throws ServletException {
+        super.initialize();
+
+        /*
+         * Create a FhirContext object that uses the version of FHIR
+         * specified in the properties file.
+         */
+        FhirVersionEnum fhirVersion = HapiProperties.getFhirVersion();
+        setFhirContext(new FhirContext(fhirVersion));
+
+        appCtx = new AnnotationConfigApplicationContext();
+
+        /*
+         * ResourceProviders are fetched from the Spring context
+         */
+        List<IResourceProvider> resourceProviders;
+        Object systemProvider;
+        if (fhirVersion == FhirVersionEnum.DSTU2) {
+            appCtx.register(FhirServerConfigDstu2.class, FhirServerConfigCommon.class);
+            appCtx.refresh();
+            resourceProviders = appCtx.getBean("myResourceProvidersDstu2", List.class);
+            systemProvider = appCtx.getBean("mySystemProviderDstu2", JpaSystemProviderDstu2.class);
+        } else if (fhirVersion == FhirVersionEnum.DSTU3) {
+            appCtx.register(FhirServerConfigDstu3.class, FhirServerConfigCommon.class);
+            appCtx.refresh();
+            resourceProviders = appCtx.getBean("myResourceProvidersDstu3", List.class);
+            systemProvider = appCtx.getBean("mySystemProviderDstu3", JpaSystemProviderDstu3.class);
+        } else if (fhirVersion == FhirVersionEnum.R4) {
+            appCtx.register(FhirServerConfigR4.class, FhirServerConfigCommon.class);
+            appCtx.refresh();
+            resourceProviders = appCtx.getBean("myResourceProvidersR4", List.class);
+            systemProvider = appCtx.getBean("mySystemProviderR4", JpaSystemProviderR4.class);
+        } else {
+            throw new IllegalStateException();
+        }
+        registerProviders(resourceProviders);
+        registerProvider(systemProvider);
+
+        /*
+         * The conformance provider exports the supported resources, search parameters, etc for
+         * this server. The JPA version adds resourceProviders counts to the exported statement, so it
+         * is a nice addition.
+         *
+         * You can also create your own subclass of the conformance provider if you need to
+         * provide further customization of your server's CapabilityStatement
+         */
+        if (fhirVersion == FhirVersionEnum.DSTU2) {
+            IFhirSystemDao<ca.uhn.fhir.model.dstu2.resource.Bundle, MetaDt> systemDao = appCtx.getBean("mySystemDaoDstu2", IFhirSystemDao.class);
+            JpaConformanceProviderDstu2 confProvider = new JpaConformanceProviderDstu2(this, systemDao, appCtx.getBean(DaoConfig.class));
+            confProvider.setImplementationDescription("HAPI FHIR DSTU2 Server");
+            setServerConformanceProvider(confProvider);
+        } else if (fhirVersion == FhirVersionEnum.DSTU3) {
+            IFhirSystemDao<Bundle, Meta> systemDao = appCtx.getBean("mySystemDaoDstu3", IFhirSystemDao.class);
+            JpaConformanceProviderDstu3 confProvider = new JpaConformanceProviderDstu3(this, systemDao, appCtx.getBean(DaoConfig.class));
+            confProvider.setImplementationDescription("HAPI FHIR DSTU3 Server");
+            setServerConformanceProvider(confProvider);
+        } else if (fhirVersion == FhirVersionEnum.R4) {
+            IFhirSystemDao<org.hl7.fhir.r4.model.Bundle, org.hl7.fhir.r4.model.Meta> systemDao = appCtx.getBean("mySystemDaoR4", IFhirSystemDao.class);
+            JpaConformanceProviderR4 confProvider = new JpaConformanceProviderR4(this, systemDao, appCtx.getBean(DaoConfig.class));
+            confProvider.setImplementationDescription("HAPI FHIR R4 Server");
+            setServerConformanceProvider(confProvider);
+        } else {
+            throw new IllegalStateException();
+        }
+
+        /*
+         * ETag Support
+         */
+        setETagSupport(HapiProperties.getEtagSupport());
+
+        /*
+         * This server tries to dynamically generate narratives
+         */
+        FhirContext ctx = getFhirContext();
+        ctx.setNarrativeGenerator(new DefaultThymeleafNarrativeGenerator());
+
+        /*
+         * Default to JSON and pretty printing
+         */
+        setDefaultPrettyPrint(HapiProperties.getDefaultPrettyPrint());
+
+        /*
+         * Default encoding
+         */
+        setDefaultResponseEncoding(HapiProperties.getDefaultEncoding());
+
+        /*
+         * 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(appCtx.getBean(DatabaseBackedPagingProvider.class));
+
+        /*
+         * This interceptor formats the output using nice colourful
+         * HTML output when the request is detected to come from a
+         * browser.
+         */
+        ResponseHighlighterInterceptor responseHighlighterInterceptor = appCtx.getBean(ResponseHighlighterInterceptor.class);
+        this.registerInterceptor(responseHighlighterInterceptor);
+
+        /*
+         * 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:
+         */
+        String serverAddress = HapiProperties.getServerAddress();
+        if (serverAddress != null && serverAddress.length() > 0) {
+            setServerAddressStrategy(new HardcodedServerAddressStrategy(serverAddress));
+        }
+
+        /*
+         * 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 (false) { // <-- DISABLED RIGHT NOW
+            if (fhirVersion == FhirVersionEnum.DSTU3) {
+                registerProvider(appCtx.getBean(TerminologyUploaderProviderDstu3.class));
+            } else if (fhirVersion == FhirVersionEnum.R4) {
+                registerProvider(appCtx.getBean(TerminologyUploaderProviderR4.class));
+            }
+        }
+
+        // If you want to enable the $trigger-subscription operation to allow
+        // manual triggering of a subscription delivery, enable this provider
+        if (false) { // <-- DISABLED RIGHT NOW
+            SubscriptionTriggeringProvider retriggeringProvider = appCtx.getBean(SubscriptionTriggeringProvider.class);
+            registerProvider(retriggeringProvider);
+        }
+    }
+
+}