public static async System.Threading.Tasks.Task EnsurePatientDeviceAsync(this IFhirClient client, string userId)
{
var patient = await client.EnsureResourceByIdentifierAsync <Patient>(
userId,
FhirConstants.MyHealthSystem,
(patient, identifier) =>
{
patient.Id = userId;
patient.Identifier = new List <Identifier> {
identifier
};
});
await client.EnsureResourceByIdentifierAsync <Device>(
userId,
FhirConstants.MyHealthSystem,
(device, identifier) =>
{
device.Id = userId;
device.Identifier = new List <Identifier> {
identifier
};
device.Patient = patient.ToReference();
});
}
public static Parameters ConceptLookup(this IFhirClient client,
Code code = null, FhirUri system = null, FhirString version = null,
Coding coding = null, FhirDateTime date = null)
{
return(ConceptLookupAsync(client, code, system, version, coding, date).WaitResult());
}
public async static Task <ValidateCodeResult> ValidateCodeAsync(this IFhirClient client,
FhirUri identifier = null, FhirUri context = null, ValueSet valueSet = null, Code code = null,
FhirUri system = null, FhirString version = null, FhirString display = null,
Coding coding = null, CodeableConcept codeableConcept = null, FhirDateTime date = null,
FhirBoolean @abstract = null)
{
var par = new Parameters()
.Add(nameof(identifier), identifier)
.Add(nameof(context), context)
.Add(nameof(valueSet), valueSet)
.Add(nameof(code), code)
.Add(nameof(system), system)
.Add(nameof(version), version)
.Add(nameof(display), display)
.Add(nameof(coding), coding)
.Add(nameof(codeableConcept), codeableConcept)
.Add(nameof(date), date)
.Add(nameof(@abstract), @abstract);
var result = await client.TypeOperationAsync <ValueSet>(RestOperation.VALIDATE_CODE, par).ConfigureAwait(false);
if (result != null)
{
return(ValidateCodeResult.FromParameters(result.OperationResult <Parameters>()));
}
else
{
return(null);
}
}
public R4FhirImportService(IResourceIdentityService resourceIdentityService, IFhirClient fhirClient, IFhirTemplateProcessor <ILookupTemplate <IFhirTemplate>, Model.Observation> fhirTemplateProcessor, IMemoryCache observationCache)
{
_fhirTemplateProcessor = EnsureArg.IsNotNull(fhirTemplateProcessor, nameof(fhirTemplateProcessor));
_client = EnsureArg.IsNotNull(fhirClient, nameof(fhirClient));
_resourceIdentityService = EnsureArg.IsNotNull(resourceIdentityService, nameof(resourceIdentityService));
_observationCache = EnsureArg.IsNotNull(observationCache, nameof(observationCache));
}
/// <summary>
/// Sets the authenticated token on the <see cref="IFhirClient"/> via OpenId client credentials.
/// </summary>
/// <param name="fhirClient">The <see cref="IFhirClient"/> to authenticate.</param>
/// <param name="clientId">The clientId of the application.</param>
/// <param name="clientSecret">The clientSecret of the application.</param>
/// <param name="resource">The resource to authenticate with.</param>
/// <param name="scope">The scope to authenticate with.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
/// <returns>A <see cref="Task"/> representing the successful setting of the token.</returns>
public static async Task AuthenticateOpenIdClientCredentials(
this IFhirClient fhirClient,
string clientId,
string clientSecret,
string resource,
string scope,
CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(fhirClient, nameof(fhirClient));
EnsureArg.IsNotNullOrWhiteSpace(clientId, nameof(clientId));
EnsureArg.IsNotNullOrWhiteSpace(clientSecret, nameof(clientSecret));
EnsureArg.IsNotNullOrWhiteSpace(resource, nameof(resource));
EnsureArg.IsNotNullOrWhiteSpace(scope, nameof(scope));
var formData = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(OpenIdConnectParameterNames.ClientId, clientId),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.ClientSecret, clientSecret),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.GrantType, OpenIdConnectGrantTypes.ClientCredentials),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Scope, scope),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Resource, resource),
};
await ObtainTokenAndSetOnClient(fhirClient, formData, cancellationToken);
}
private static async Task ObtainTokenAndSetOnClient(IFhirClient fhirClient, List <KeyValuePair <string, string> > formData, CancellationToken cancellationToken)
{
using var formContent = new FormUrlEncodedContent(formData);
using HttpResponseMessage tokenResponse = await fhirClient.HttpClient.PostAsync(fhirClient.TokenUri, formContent, cancellationToken);
var openIdConnectMessage = new OpenIdConnectMessage(await tokenResponse.Content.ReadAsStringAsync());
fhirClient.SetBearerToken(openIdConnectMessage.AccessToken);
}
public static ValidateCodeResult ValidateCode(this IFhirClient client,
FhirUri identifier = null, FhirUri context = null, ValueSet valueSet = null, Code code = null,
FhirUri system = null, FhirString version = null, FhirString display = null,
Coding coding = null, CodeableConcept codeableConcept = null, FhirDateTime date = null,
FhirBoolean @abstract = null)
{
return(ValidateCodeAsync(client, identifier, context, valueSet, code, system, version, display,
coding, codeableConcept, date, @abstract).WaitResult());
}
/// <summary>
/// Sets the authenticated token on the <see cref="IFhirClient"/> to the supplied resource via Managed Identity.
/// </summary>
/// <param name="fhirClient">The <see cref="IFhirClient"/> to authenticate.</param>
/// <param name="resource">The resource to obtain a token to.</param>
/// <param name="tenantId">The optional tenantId to use when requesting a token.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
/// <returns>A <see cref="Task"/> representing the successful setting of the token.</returns>
public static async Task AuthenticateWithManagedIdentity(this IFhirClient fhirClient, string resource, string tenantId = null, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(fhirClient, nameof(fhirClient));
EnsureArg.IsNotNullOrWhiteSpace(resource, nameof(resource));
var azureServiceTokenProvider = new AzureServiceTokenProvider();
string accessToken = await azureServiceTokenProvider.GetAccessTokenAsync(resource, tenantId, cancellationToken);
fhirClient.SetBearerToken(accessToken);
}
public virtual async Task <TResource> GetResourceByIdentityAsync <TResource>(IFhirClient client, string value, string system)
where TResource : Model.Resource, new()
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNullOrWhiteSpace(value, nameof(value));
var identifier = BuildIdentifier(value, system);
return(await GetResourceByIdentityAsync <TResource>(client, identifier).ConfigureAwait(false));
}
public AccountDeletionJob(
ILoggerFactory log,
IExceptionFilter exceptionFilter,
IFhirClient fhirClient,
IConsentStore consentStore,
IVendorClient vendorClient)
{
this.log = log.CreateLogger <AccountDeletionJob>();
this.exceptionFilter = exceptionFilter;
this.fhirClient = fhirClient;
this.consentStore = consentStore;
this.vendorClient = vendorClient;
}
public ObservationsEndpoint(
ILoggerFactory log,
IExceptionFilter exceptionFilter,
IAuthentication auth,
IConsentStore consentStore,
IFhirClient fhirClient)
{
this.log = log.CreateLogger <ObservationsEndpoint>();
this.exceptionFilter = exceptionFilter;
this.auth = auth;
this.consentStore = consentStore;
this.fhirClient = fhirClient;
}
public FitbitProviderUpdateEventHandler(
IFitbitClient fitbitClient,
IFitbitTokenService fitbitTokenService,
IIoMTDataPublisher iomtDataPublisher,
IFhirClient fhirClient,
ILogger <FitbitProviderUpdateEventHandler> logger)
{
_fitbitClient = fitbitClient ?? throw new ArgumentNullException(nameof(fitbitClient));
_fitbitTokenService = fitbitTokenService ?? throw new ArgumentNullException(nameof(fitbitTokenService));
_iomtDataPublisher = iomtDataPublisher ?? throw new ArgumentNullException(nameof(iomtDataPublisher));
_fhirClient = fhirClient ?? throw new ArgumentNullException(nameof(fhirClient));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static async Task <Parameters> ConceptLookupAsync(this IFhirClient client,
Code code = null, FhirUri system = null, FhirString version = null,
Coding coding = null, FhirDateTime date = null)
{
var par = new Parameters()
.Add(nameof(code), code)
.Add(nameof(system), system)
.Add(nameof(version), version)
.Add(nameof(coding), coding)
.Add(nameof(date), date);
return((await client.TypeOperationAsync <ValueSet>(RestOperation.CONCEPT_LOOKUP, par).ConfigureAwait(false))
.OperationResult <Parameters>());
}
public StravaProviderUpdateEventHandler(
IStravaClient stravaClient,
IStravaAuthenticationService stravaAuthenticationService,
ILogger <StravaProviderUpdateEventHandler> logger,
IIntegrationRepository integrationRepository,
IIoMTDataPublisher iomtDataPublisher,
IFhirClient fhirClient)
{
_stravaClient = stravaClient;
_stravaAuthenticationService = stravaAuthenticationService;
_logger = logger;
_integrationRepository = integrationRepository;
_iomtDataPublisher = iomtDataPublisher;
_fhirClient = fhirClient;
}
public UserEndpoint(
ILoggerFactory log,
IExceptionFilter exceptionFilter,
IAuthentication auth,
IConsentStore consentStore,
IVendorClient vendorClient,
IFhirClient fhirClient,
IUserFactory userFactory,
IGuidFactory guidFactory)
{
this.log = log.CreateLogger <UserEndpoint>();
this.exceptionFilter = exceptionFilter;
this.auth = auth;
this.consentStore = consentStore;
this.vendorClient = vendorClient;
this.fhirClient = fhirClient;
this.userFactory = userFactory;
this.guidFactory = guidFactory;
}
public static async Task <bool> ValidateFhirClientAsync(
this IFhirClient client,
ITelemetryLogger logger)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(logger, nameof(logger));
try
{
await client.ReadAsync <Hl7.Fhir.Model.CapabilityStatement>("metadata?_summary=true").ConfigureAwait(false);
return(true);
}
catch (Exception exception)
{
FhirServiceExceptionProcessor.ProcessException(exception, logger);
return(false);
}
}
public MainMenuForm()
{
InitializeComponent();
// initialize resource string
fhirResourceString = "";
// set up restful client
client = new RestClient("http://hackathon.siim.org/fhir/");
client.AddDefaultHeader("Content-Type", "application/fhir+json");
client.AddDefaultHeader("apikey", Environment.GetEnvironmentVariable("SiimApiKey"));
driver = new MainMenuFormDriver(client);
// make form instances
fhirClient = new FhirClient("http://hackathon.siim.org/fhir/");
fhirClient.OnBeforeRequest += (object sender, BeforeRequestEventArgs e) => {
e.RawRequest.Headers.Add("apikey", Environment.GetEnvironmentVariable("SiimApiKey")); //requires environment variable to match
};
patientForm = new PatientForm(fhirClient);
}
public Jobs(
ILoggerFactory log,
IExceptionFilter exceptionFilter,
IFhirClient fhirClient,
IJson json,
IWithingsClient withingsClient,
IConsentStore consentStore,
INotification notification,
IGuidFactory guidFactory,
IWithingsToFhirConverter converter)
{
this.log = log.CreateLogger <Jobs>();
this.exceptionFilter = exceptionFilter;
this.fhirClient = fhirClient;
this.json = json;
this.withingsClient = withingsClient;
this.consentStore = consentStore;
this.notification = notification;
this.guidFactory = guidFactory;
this.converter = converter;
}
/// <summary>
/// Sets the authenticated token on the <see cref="IFhirClient"/> via OpenId user password.
/// </summary>
/// <param name="fhirClient">The <see cref="IFhirClient"/> to authenticate.</param>
/// <param name="clientId">The clientId of the application.</param>
/// <param name="clientSecret">The clientSecret of the application.</param>
/// <param name="resource">The resource to authenticate with.</param>
/// <param name="scope">The scope to authenticate with.</param>
/// <param name="username">The username to authenticate.</param>
/// <param name="password">The password to authenticate.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> for the request.</param>
/// <returns>A <see cref="Task"/> representing the successful setting of the token.</returns>
public static async Task AuthenticateOpenIdUserPassword(
this IFhirClient fhirClient,
string clientId,
string clientSecret,
string resource,
string scope,
string username,
string password,
CancellationToken cancellationToken)
{
var formData = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(OpenIdConnectParameterNames.ClientId, clientId),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.ClientSecret, clientSecret),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.GrantType, OpenIdConnectGrantTypes.Password),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Scope, scope),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Resource, resource),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Username, username),
new KeyValuePair <string, string>(OpenIdConnectParameterNames.Password, password),
};
await ObtainTokenAndSetOnClient(fhirClient, formData, cancellationToken);
}
public static async Task <ValidateCodeResult> ValidateCodeAsync(this IFhirClient client, String valueSetId,
FhirUri identifier = null, FhirUri context = null, ValueSet valueSet = null, Code code = null,
FhirUri system = null, FhirString version = null, FhirString display = null,
Coding coding = null, CodeableConcept codeableConcept = null, FhirDateTime date = null,
FhirBoolean @abstract = null)
{
if (valueSetId == null)
{
throw new ArgumentNullException(nameof(valueSetId));
}
var par = new Parameters()
.Add(nameof(identifier), identifier)
.Add(nameof(context), context)
.Add(nameof(valueSet), valueSet)
.Add(nameof(code), code)
.Add(nameof(system), system)
.Add(nameof(version), version)
.Add(nameof(display), display)
.Add(nameof(coding), coding)
.Add(nameof(codeableConcept), codeableConcept)
.Add(nameof(date), date)
.Add(nameof(@abstract), @abstract);
ResourceIdentity location = new ResourceIdentity("ValueSet/" + valueSetId);
var result = await client.InstanceOperationAsync(location.WithoutVersion().MakeRelative(), RestOperation.VALIDATE_CODE, par).ConfigureAwait(false);
if (result != null)
{
return(ValidateCodeResult.FromParameters(result.OperationResult <Parameters>()));
}
else
{
return(null);
}
}
public PatientController()
{
_client = new FhirClient("https://fhir.monash.edu/hapi-fhir-jpaserver/fhir/");
}
public R4DeviceAndPatientCreateIdentityService(IFhirClient fhirClient, ResourceManagementService resourceIdService)
: base(fhirClient, resourceIdService)
{
}
public ExternalTerminologyService(IFhirClient client)
{
Endpoint = client;
}
public R4DeviceAndPatientCreateIdentityService(IFhirClient fhirClient)
: base(fhirClient)
{
}
public R4DeviceAndPatientLookupIdentityService(IFhirClient fhirClient, ResourceManagementService resourceManagementService)
{
_fhirClient = EnsureArg.IsNotNull(fhirClient, nameof(fhirClient));
_resourceManagementService = EnsureArg.IsNotNull(resourceManagementService, nameof(resourceManagementService));
}
public R4DeviceAndPatientLookupIdentityService(IFhirClient fhirClient)
: this(fhirClient, new ResourceManagementService())
{
}
protected static async Task <TResource> GetResourceByIdentityAsync <TResource>(IFhirClient client, Model.Identifier identifier)
where TResource : Model.Resource, new()
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(identifier, nameof(identifier));
var searchParams = identifier.ToSearchParams();
var result = await client.SearchAsync <TResource>(searchParams).ConfigureAwait(false);
return(await result.ReadOneFromBundleWithContinuationAsync <TResource>(client));
}
public GetPatientHandler(IFhirClient client)
{
_client = client;
}
protected static async Task <TResource> CreateResourceByIdentityAsync <TResource>(IFhirClient client, Model.Identifier identifier, Action <TResource, Model.Identifier> propertySetter)
where TResource : Model.Resource, new()
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(identifier, nameof(identifier));
var resource = new TResource();
propertySetter?.Invoke(resource, identifier);
return(await client.CreateAsync <TResource>(resource).ConfigureAwait(false));
}
public static async Task <IEnumerable <TResource> > SearchWithContinuationAsync <TResource>(this IFhirClient fhirClient, SearchParams searchParams)
where TResource : Resource
{
var result = await fhirClient.SearchAsync <TResource>(searchParams).ConfigureAwait(false) as Bundle;
return(await result.ReadFromBundleWithContinuationAsync <TResource>(fhirClient, searchParams.Count).ConfigureAwait(false));
}
