public async Task GivenAFhirMediator_WhenHardDeletingWithSufficientPermissions_ThenItWillBeHardDeleted() { _authorizationService.CheckAccess(Arg.Any <DataActions>(), Arg.Any <CancellationToken>()).Returns(DataActions.Delete | DataActions.HardDelete); ResourceKey resourceKey = new ResourceKey <Observation>("id1"); ResourceKey resultKey = (await _mediator.DeleteResourceAsync(resourceKey, true)).ResourceKey; await _fhirDataStore.Received(1).HardDeleteAsync(resourceKey, Arg.Any <CancellationToken>()); Assert.NotNull(resultKey); Assert.Equal(resourceKey.Id, resultKey.Id); Assert.Null(resultKey.VersionId); }
/// <summary> /// Confirm the request /// </summary> /// <param name="requestId">Request's id</param> public void Confirm(int requestId) { _authService.CheckAccess(AuthOperations.TournamentRequests.Confirm); var tournamentRequest = Get(requestId); if (tournamentRequest == null) { throw new MissingEntityException(ServiceResources.ExceptionMessages.TournamentRequestNotFound, requestId); } _tournamentRepository.AddTeamToTournament(tournamentRequest.TeamId, tournamentRequest.GroupId); _tournamentRepository.UnitOfWork.Commit(); NotifyUser(_userService.GetUser(Get(requestId).UserId).Email); _tournamentRequestRepository.Remove(requestId); _tournamentRequestRepository.UnitOfWork.Commit(); }
public async Task <CreateReindexResponse> Handle(CreateReindexRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Reindex, cancellationToken) != DataActions.Reindex) { throw new UnauthorizedFhirActionException(); } (var activeReindexJobs, var reindexJobId) = await _fhirOperationDataStore.CheckActiveReindexJobsAsync(cancellationToken); if (activeReindexJobs) { throw new JobConflictException(string.Format(Resources.OnlyOneResourceJobAllowed, reindexJobId)); } // We need to pull in latest search parameter updates from the data store before creating a reindex job. // There could be a potential delay of <see cref="ReindexJobConfiguration.JobPollingFrequency"/> before // search parameter updates on one instance propagates to other instances. If we store the reindex // job with the old hash value in _searchParameterDefinitionManager.SearchParameterHashMap, then we will // not detect the resources that need to be reindexed. await _searchParameterOperations.GetAndApplySearchParameterUpdates(cancellationToken); var jobRecord = new ReindexJobRecord( _searchParameterDefinitionManager.SearchParameterHashMap, request.MaximumConcurrency ?? _reindexJobConfiguration.DefaultMaximumThreadsPerReindexJob, request.MaximumResourcesPerQuery ?? _reindexJobConfiguration.MaximumNumberOfResourcesPerQuery, request.QueryDelayIntervalInMilliseconds ?? _reindexJobConfiguration.QueryDelayIntervalInMilliseconds, request.TargetDataStoreUsagePercentage); var outcome = await _fhirOperationDataStore.CreateReindexJobAsync(jobRecord, cancellationToken); return(new CreateReindexResponse(outcome)); }
public ResourceHandlerTests() { _fhirDataStore = Substitute.For <IFhirDataStore>(); _conformanceProvider = Substitute.For <ConformanceProviderBase>(); _searchService = Substitute.For <ISearchService>(); // TODO: FhirRepository instantiate ResourceDeserializer class directly // which will try to deserialize the raw resource. We should mock it as well. _rawResourceFactory = Substitute.For <RawResourceFactory>(new FhirJsonSerializer()); _resourceWrapperFactory = Substitute.For <IResourceWrapperFactory>(); _resourceWrapperFactory .Create(Arg.Any <ResourceElement>(), Arg.Any <bool>(), Arg.Any <bool>()) .Returns(x => CreateResourceWrapper(x.ArgAt <ResourceElement>(0), x.ArgAt <bool>(1))); _conformanceStatement = CapabilityStatementMock.GetMockedCapabilityStatement(); CapabilityStatementMock.SetupMockResource(_conformanceStatement, ResourceType.Observation, null); var observationResource = _conformanceStatement.Rest.First().Resource.Find(x => x.Type == ResourceType.Observation); observationResource.ReadHistory = false; observationResource.UpdateCreate = true; observationResource.ConditionalCreate = true; observationResource.ConditionalUpdate = true; observationResource.Versioning = CapabilityStatement.ResourceVersionPolicy.Versioned; CapabilityStatementMock.SetupMockResource(_conformanceStatement, ResourceType.Patient, null); var patientResource = _conformanceStatement.Rest.First().Resource.Find(x => x.Type == ResourceType.Patient); patientResource.ReadHistory = true; patientResource.UpdateCreate = true; patientResource.ConditionalCreate = true; patientResource.ConditionalUpdate = true; patientResource.Versioning = CapabilityStatement.ResourceVersionPolicy.VersionedUpdate; _conformanceProvider.GetCapabilityStatementOnStartup().Returns(_conformanceStatement.ToTypedElement().ToResourceElement()); var lazyConformanceProvider = new Lazy <IConformanceProvider>(() => _conformanceProvider); var collection = new ServiceCollection(); // an auth service that allows all. _authorizationService = Substitute.For <IAuthorizationService <DataActions> >(); _authorizationService.CheckAccess(Arg.Any <DataActions>(), Arg.Any <CancellationToken>()).Returns(ci => ci.Arg <DataActions>()); var referenceResolver = new ResourceReferenceResolver(_searchService, new TestQueryStringParser()); _resourceIdProvider = new ResourceIdProvider(); collection.Add(x => _mediator).Singleton().AsSelf(); collection.Add(x => new CreateResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _resourceIdProvider, referenceResolver, _authorizationService)).Singleton().AsSelf().AsImplementedInterfaces(); collection.Add(x => new UpsertResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _resourceIdProvider, _authorizationService, ModelInfoProvider.Instance)).Singleton().AsSelf().AsImplementedInterfaces(); collection.Add(x => new ConditionalCreateResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _searchService, x.GetService <IMediator>(), _resourceIdProvider, _authorizationService)).Singleton().AsSelf().AsImplementedInterfaces(); collection.Add(x => new ConditionalUpsertResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _searchService, x.GetService <IMediator>(), _resourceIdProvider, _authorizationService)).Singleton().AsSelf().AsImplementedInterfaces(); collection.Add(x => new GetResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _resourceIdProvider, _authorizationService)).Singleton().AsSelf().AsImplementedInterfaces(); collection.Add(x => new DeleteResourceHandler(_fhirDataStore, lazyConformanceProvider, _resourceWrapperFactory, _resourceIdProvider, _authorizationService)).Singleton().AsSelf().AsImplementedInterfaces(); ServiceProvider provider = collection.BuildServiceProvider(); _mediator = new Mediator(type => provider.GetService(type)); _deserializer = new ResourceDeserializer( (FhirResourceFormat.Json, new Func <string, string, DateTimeOffset, ResourceElement>((str, version, lastUpdated) => _fhirJsonParser.Parse(str).ToResourceElement()))); }
public async Task <EverythingOperationResponse> Handle(EverythingOperationRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Read, cancellationToken) != DataActions.Read) { throw new UnauthorizedFhirActionException(); } if (!string.Equals(request.EverythingOperationType, ResourceType.Patient.ToString(), StringComparison.Ordinal)) { throw new RequestNotValidException(string.Format(Core.Resources.ResourceNotSupported, request.EverythingOperationType)); } SearchResult searchResult = await _patientEverythingService.SearchAsync( request.ResourceId, request.Start, request.End, request.Since, request.ResourceTypes, request.ContinuationToken, cancellationToken); ResourceElement bundle = request.UnsupportedParameters != null && request.UnsupportedParameters.Any() ? _bundleFactory.CreateSearchBundle(new SearchResult(searchResult.Results, searchResult.ContinuationToken, searchResult.SortOrder, request.UnsupportedParameters)) : _bundleFactory.CreateSearchBundle(searchResult); return(new EverythingOperationResponse(bundle)); }
public async Task GivenUserDoesNotHavePermissionForReindex_WhenHandle_ThenUnauthorizedExceptionIsThrown() { _authorizationService.CheckAccess(Arg.Is(DataActions.Reindex), Arg.Any <CancellationToken>()).Returns(DataActions.None); var request = GetReindexRequest(HttpGetName); await Assert.ThrowsAsync <UnauthorizedFhirActionException>(() => _reindexHandler.Handle(request, _cancellationToken)); }
public async Task <CancelImportResponse> Handle(CancelImportRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Import, cancellationToken) != DataActions.Import) { throw new UnauthorizedFhirActionException(); } try { TaskInfo taskInfo = await _taskManager.CancelTaskAsync(request.TaskId, cancellationToken); if (taskInfo.Status == TaskManagement.TaskStatus.Completed) { throw new OperationFailedException(Resources.ImportOperationCompleted, HttpStatusCode.Conflict); } else { return(new CancelImportResponse(HttpStatusCode.Accepted)); } } catch (TaskNotExistException) { throw new ResourceNotFoundException(string.Format(Resources.ImportTaskNotFound, request.TaskId)); } }
private void SetPermissionForHandler(string context = "ContextA", RequestHandlerType?handlerType = null) { _authorizationService .CheckAccess( new Permission(context, (handlerType ?? _requestHandlerType).ToString())) .Returns(true); }
private void SetPermissionForHandler() { _authorizationService .CheckAccess( new Permission(nameof(IDomainFrameworkTestFixture), _handlerType.ToString())) .Returns(true); }
public async Task <CreateReindexResponse> Handle(CreateReindexRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Reindex, cancellationToken) != DataActions.Reindex) { throw new UnauthorizedFhirActionException(); } (var activeReindexJobs, var reindexJobId) = await _fhirOperationDataStore.CheckActiveReindexJobsAsync(cancellationToken); if (activeReindexJobs) { throw new JobConflictException(string.Format(Resources.OnlyOneResourceJobAllowed, reindexJobId)); } var jobRecord = new ReindexJobRecord( _searchParameterDefinitionManager.SearchParameterHashMap, request.MaximumConcurrency ?? _reindexJobConfiguration.DefaultMaximumThreadsPerReindexJob, request.MaximumResourcesPerQuery ?? _reindexJobConfiguration.MaximumNumberOfResourcesPerQuery, request.QueryDelayIntervalInMilliseconds ?? _reindexJobConfiguration.QueryDelayIntervalInMilliseconds, request.TargetDataStoreUsagePercentage); var outcome = await _fhirOperationDataStore.CreateReindexJobAsync(jobRecord, cancellationToken); return(new CreateReindexResponse(outcome)); }
public async Task <CancelReindexResponse> Handle(CancelReindexRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Reindex, cancellationToken) != DataActions.Reindex) { throw new UnauthorizedFhirActionException(); } return(await _retryPolicy.ExecuteAsync(async() => { ReindexJobWrapper outcome = await _fhirOperationDataStore.GetReindexJobByIdAsync(request.JobId, cancellationToken); // If the job is already completed for any reason, return conflict status. if (outcome.JobRecord.Status.IsFinished()) { throw new RequestNotValidException( string.Format(Resources.ReindexJobInCompletedState, outcome.JobRecord.Id, outcome.JobRecord.Status)); } // Try to cancel the job. outcome.JobRecord.Status = OperationStatus.Canceled; outcome.JobRecord.CanceledTime = Clock.UtcNow; await _fhirOperationDataStore.UpdateReindexJobAsync(outcome.JobRecord, outcome.ETag, cancellationToken); return new CancelReindexResponse(HttpStatusCode.Conflict, outcome); })); }
public async Task <CreateExportResponse> Handle(CreateExportRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Export, cancellationToken) != DataActions.Export) { throw new UnauthorizedFhirActionException(); } IReadOnlyCollection <KeyValuePair <string, string> > requestorClaims = _claimsExtractor.Extract()? .OrderBy(claim => claim.Key, StringComparer.Ordinal).ToList(); // Compute the hash of the job. var hashObject = new { request.RequestUri, RequestorClaims = requestorClaims, }; string hash = JsonConvert.SerializeObject(hashObject).ComputeHash(); string storageAccountConnectionHash = string.IsNullOrEmpty(_exportJobConfiguration.StorageAccountConnection) ? string.Empty : StringExtensions.ComputeHash(_exportJobConfiguration.StorageAccountConnection); // Check to see if a matching job exists or not. If a matching job exists, we will return that instead. // Otherwise, we will create a new export job. This will be a best effort since the likelihood of this happen should be small. ExportJobOutcome outcome = await _fhirOperationDataStore.GetExportJobByHashAsync(hash, cancellationToken); var filters = ParseFilter(request.Filters); ExportJobFormatConfiguration formatConfiguration = ParseFormat(request.FormatName, request.ContainerName != null); if (outcome == null) { var jobRecord = new ExportJobRecord( request.RequestUri, request.RequestType, formatConfiguration.Format, request.ResourceType, filters, hash, _exportJobConfiguration.RollingFileSizeInMB, requestorClaims, request.Since, request.GroupId, storageAccountConnectionHash, _exportJobConfiguration.StorageAccountUri, request.AnonymizationConfigurationLocation, request.AnonymizationConfigurationFileETag, _exportJobConfiguration.MaximumNumberOfResourcesPerQuery, _exportJobConfiguration.NumberOfPagesPerCommit, request.ContainerName); outcome = await _fhirOperationDataStore.CreateExportJobAsync(jobRecord, cancellationToken); } return(new CreateExportResponse(outcome.JobRecord.Id)); }
public static bool CheckAccess(this IAuthorizationService authorizationService, IPrincipal principal, Operation operation, Resource resource) { var claimsPrincipal = principal.AsClaimsPrincipal(); var resources = new Collection <Claim>(new Claim[] { resource }.ToList()); var operations = new Collection <Claim>(new Claim[] { operation }.ToList()); var authorizationContext = new AuthorizationContext(claimsPrincipal, resources, operations); return(authorizationService.CheckAccess(authorizationContext)); }
public void DeleteClassify(int clsId) { _authorizationService.CheckAccess(Permissions.ResourceAdmin, OrchardService.WorkContext.CurrentUser, null); var cls = GetClsById(clsId); if (cls == null) { return; } _resClassifyRepository.Delete(cls); }
public async Task <ConvertDataResponse> Handle(ConvertDataRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request); if (await _authorizationService.CheckAccess(DataActions.ConvertData, cancellationToken) != DataActions.ConvertData) { throw new UnauthorizedFhirActionException(); } return(await _convertDataEngine.Process(request, cancellationToken)); }
public void DeleteTag(int tagId) { _authorizationService.CheckAccess(Permissions.ManageTags, _orchardServices.WorkContext.CurrentUser, null); var tag = GetTag(tagId); if (tag == null) { return; } // Delete associations to content items foreach (var tagContentItem in _contentTagRepository.Fetch(x => x.TagRecord == tag)) { _contentTagRepository.Delete(tagContentItem); } // Delete tag entity _tagRepository.Delete(tag); }
/// <summary> /// Create a new team. /// </summary> /// <param name="teamToCreate">A Team to create.</param> public Team Create(CreateTeamDto teamToCreate) { _authService.CheckAccess(AuthOperations.Teams.Create); if (teamToCreate.Captain == null) { throw new EntityInvariantViolationException("Captain can not be null"); } ThrowExceptionIfTeamWithSuchNameExists(teamToCreate.Name); var captain = GetPlayerById(teamToCreate.Captain.Id); if (captain == null) { throw new MissingEntityException(ServiceResources.ExceptionMessages.PlayerNotFound, teamToCreate.Captain.Id); } // Check if captain in teamToCreate is captain of another team var existTeam = GetTeamLedByCaptain(captain.Id); VerifyExistingTeamOrThrow(existTeam); return(_teamRepository.Add(teamToCreate)); }
public bool CreateTerm(OptionItemPart termPart) { if (GetTermByName(termPart.OptionSetId, termPart.Name) == null) { _authorizationService.CheckAccess(Permissions.CreateTerm, _services.WorkContext.CurrentUser, null); termPart.As <ICommonPart>().Container = GetOptionSet(termPart.OptionSetId).ContentItem; _contentManager.Create(termPart); return(true); } _notifier.Warning(T("The term {0} already exists in this taxonomy", termPart.Name)); return(false); }
public async Task <MemberMatchResponse> Handle(MemberMatchRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Read, cancellationToken) != DataActions.Read) { throw new UnauthorizedFhirActionException(); } ResourceElement patient = await _memberMatchService.FindMatch(request.Coverage, request.Patient, cancellationToken); return(new MemberMatchResponse(patient)); }
/// <summary> /// Confirm request by id /// </summary> /// <param name="requestId">The id of request to Confirm.</param> public void Confirm(int requestId) { _authService.CheckAccess(AuthOperations.Requests.Confirm); var request = Get(requestId); if (request == null) { throw new MissingEntityException(ServiceResources.ExceptionMessages.RequestNotFound, requestId); } var user = _userService.GetUser(request.UserId); if (user == null) { throw new MissingEntityException(ServiceResources.ExceptionMessages.UserNotFound); } user.PlayerId = request.PlayerId; _userRepository.Update(user); _requestRepository.Remove(requestId); _userRepository.UnitOfWork.Commit(); }
public EitherAsync <Error, TResponse> Handle(TRequest request) { var permissionEnabled = ExtractPermissionToCheck(RootInstance) .MapAsync(async perm => await _authZService.CheckAccess(perm)) .Map(p => p.Match( Right: allowed => allowed ? (Either <Error, Unit>)Unit.Default : Error.NotAuthorized("No permission"), Left: e => e )) .ToAsync(); return(permissionEnabled.Bind(_ => Decoratee.Handle(request))); }
public void CreateTerm(TermPart termPart) { if (GetTermByName(termPart.TaxonomyId, termPart.Name) == null) { _authorizationService.CheckAccess(Permissions.CreateTerm, _services.WorkContext.CurrentUser, null); termPart.As <ICommonPart>().Container = GetTaxonomy(termPart.TaxonomyId).ContentItem; _contentManager.Create(termPart); } else { _notifier.Warning(T("The term {0} already exists in this taxonomy", termPart.Name)); } }
public async Task GivenInvalidAuthorization_WhenHandlingRequest_ThenThrowUnauthorizedDicomActionException() { using var source = new CancellationTokenSource(); IAuthorizationService <DataActions> auth = Substitute.For <IAuthorizationService <DataActions> >(); IDicomOperationsClient client = Substitute.For <IDicomOperationsClient>(); var handler = new OperationStatusHandler(auth, client); auth.CheckAccess(DataActions.Read, source.Token).Returns(DataActions.None); await Assert.ThrowsAsync <UnauthorizedDicomActionException>(() => handler.Handle(new OperationStatusRequest(Guid.NewGuid()), source.Token)); await auth.Received(1).CheckAccess(DataActions.Read, source.Token); await client.DidNotReceiveWithAnyArgs().GetStatusAsync(default, default);
public async Task <GetImportResponse> Handle(GetImportRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Import, cancellationToken) != DataActions.Import) { throw new UnauthorizedFhirActionException(); } TaskInfo taskInfo = await _taskManager.GetTaskAsync(request.TaskId, cancellationToken); if (taskInfo == null) { throw new ResourceNotFoundException(string.Format(Resources.ImportTaskNotFound, request.TaskId)); } if (taskInfo.Status != TaskManagement.TaskStatus.Completed) { if (taskInfo.IsCanceled) { throw new OperationFailedException(Resources.UserRequestedCancellation, HttpStatusCode.BadRequest); } return(new GetImportResponse(HttpStatusCode.Accepted)); } else { TaskResultData resultData = JsonConvert.DeserializeObject <TaskResultData>(taskInfo.Result); if (resultData.Result == TaskResult.Success) { ImportTaskResult result = JsonConvert.DeserializeObject <ImportTaskResult>(resultData.ResultData); return(new GetImportResponse(HttpStatusCode.OK, result)); } else if (resultData.Result == TaskResult.Fail) { ImportTaskErrorResult errorResult = JsonConvert.DeserializeObject <ImportTaskErrorResult>(resultData.ResultData); string failureReason = errorResult.ErrorMessage; HttpStatusCode failureStatusCode = errorResult.HttpStatusCode; throw new OperationFailedException( string.Format(Resources.OperationFailed, OperationsConstants.Import, failureReason), failureStatusCode); } else { throw new OperationFailedException(Resources.UserRequestedCancellation, HttpStatusCode.BadRequest); } } }
public async Task <CreateImportResponse> Handle(CreateImportRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Import, cancellationToken) != DataActions.Import) { throw new UnauthorizedFhirActionException(); } string taskId = Guid.NewGuid().ToString("N"); // Processing task might be dispatch to different environment with differenet queueid later. string processingTaskQueueId = string.IsNullOrEmpty(_importTaskConfiguration.ProcessingTaskQueueId) ? _taskHostingConfiguration.QueueId : _importTaskConfiguration.ProcessingTaskQueueId; ImportOrchestratorTaskInputData inputData = new ImportOrchestratorTaskInputData() { RequestUri = request.RequestUri, BaseUri = new Uri(request.RequestUri.GetLeftPart(UriPartial.Authority)), Input = request.Input, InputFormat = request.InputFormat, InputSource = request.InputSource, StorageDetail = request.StorageDetail, MaxConcurrentProcessingTaskCount = _importTaskConfiguration.MaxRunningProcessingTaskCount, ProcessingTaskQueueId = processingTaskQueueId, ProcessingTaskMaxRetryCount = _importTaskConfiguration.MaxRetryCount, TaskId = taskId, TaskCreateTime = Clock.UtcNow, }; TaskInfo taskInfo = new TaskInfo() { TaskId = taskId, TaskTypeId = ImportOrchestratorTask.ImportOrchestratorTaskId, MaxRetryCount = _importTaskConfiguration.MaxRetryCount, QueueId = _taskHostingConfiguration.QueueId, InputData = JsonConvert.SerializeObject(inputData), }; try { await _taskManager.CreateTaskAsync(taskInfo, true, cancellationToken); } catch (TaskConflictException) { _logger.LogInformation("Already a running import task."); throw new OperationFailedException(Resources.ImportTaskIsRunning, HttpStatusCode.Conflict); } return(new CreateImportResponse(taskId)); }
/// <inheritdoc /> public async Task <SearchResourceResponse> Handle(SearchResourceRequest message, CancellationToken cancellationToken) { EnsureArg.IsNotNull(message, nameof(message)); if (await _authorizationService.CheckAccess(DataActions.Read, cancellationToken) != DataActions.Read) { throw new UnauthorizedFhirActionException(); } SearchResult searchResult = await _searchService.SearchAsync(message.ResourceType, message.Queries, cancellationToken); ResourceElement bundle = _bundleFactory.CreateSearchBundle(searchResult); return(new SearchResourceResponse(bundle)); }
public async Task <ReindexSingleResourceResponse> Handle(ReindexSingleResourceRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Reindex, cancellationToken) != DataActions.Reindex) { throw new UnauthorizedFhirActionException(); } var key = new ResourceKey(request.ResourceType, request.ResourceId); ResourceWrapper storedResource = await _fhirDataStore.GetAsync(key, cancellationToken); if (storedResource == null) { throw new ResourceNotFoundException(string.Format(Core.Resources.ResourceNotFoundById, request.ResourceType, request.ResourceId)); } await _searchParameterOperations.GetAndApplySearchParameterUpdates(cancellationToken); // We need to extract the "new" search indices since the assumption is that // a new search parameter has been added to the fhir server. ResourceElement resourceElement = _resourceDeserializer.Deserialize(storedResource); IReadOnlyCollection <SearchIndexEntry> newIndices = _searchIndexer.Extract(resourceElement); // If it's a post request we need to go update the resource in the database. if (request.HttpMethod == HttpPostName) { await ProcessPostReindexSingleResourceRequest(storedResource, newIndices); } // Create a new parameter resource and include the new search indices and the corresponding values. var parametersResource = new Parameters { Id = Guid.NewGuid().ToString(), VersionId = "1", Parameter = new List <Parameters.ParameterComponent>(), }; foreach (SearchIndexEntry searchIndex in newIndices) { parametersResource.Parameter.Add(new Parameters.ParameterComponent() { Name = searchIndex.SearchParameter.Code.ToString(), Value = new FhirString(searchIndex.Value.ToString()) }); } return(new ReindexSingleResourceResponse(parametersResource.ToResourceElement())); }
public ReindexSingleResourceRequestHandlerTests() { _authorizationService = Substitute.For <IAuthorizationService <DataActions> >(); _fhirDataStore = Substitute.For <IFhirDataStore>(); _searchIndexer = Substitute.For <ISearchIndexer>(); _resourceDeserializer = Substitute.For <IResourceDeserializer>(); _cancellationToken = CancellationToken.None; _authorizationService.CheckAccess(Arg.Is(DataActions.Reindex), Arg.Any <CancellationToken>()).Returns(DataActions.Reindex); _reindexHandler = new ReindexSingleResourceRequestHandler( _authorizationService, _fhirDataStore, _searchIndexer, _resourceDeserializer); }
/// <summary> /// Handles validation requests. /// </summary> /// <param name="request">The request</param> /// <param name="cancellationToken">The CancellationToken</param> public async Task <ValidateOperationResponse> Handle(ValidateOperationRequest request, CancellationToken cancellationToken) { if (await _authorizationService.CheckAccess(DataActions.ResourceValidate, cancellationToken) != DataActions.ResourceValidate) { throw new UnauthorizedFhirActionException(); } var outcome = _profileValidator.TryValidate(request.Resource.Instance, request.Profile?.ToString()); if (outcome.Length == 0) { return(new ValidateOperationResponse(ValidationPassed)); } return(new ValidateOperationResponse(outcome)); }
public async Task <GetExportResponse> Handle(GetExportRequest request, CancellationToken cancellationToken) { EnsureArg.IsNotNull(request, nameof(request)); if (await _authorizationService.CheckAccess(DataActions.Export, cancellationToken) != DataActions.Export) { throw new UnauthorizedFhirActionException(); } ExportJobOutcome outcome = await _fhirOperationDataStore.GetExportJobByIdAsync(request.JobId, cancellationToken); // We have an existing job. We will determine the response based on the status of the export operation. GetExportResponse exportResponse; if (outcome.JobRecord.Status == OperationStatus.Completed) { List <ExportFileInfo> allFiles = new List <ExportFileInfo>(); foreach (List <ExportFileInfo> fileList in outcome.JobRecord.Output.Values) { allFiles.AddRange(fileList); } var jobResult = new ExportJobResult( outcome.JobRecord.QueuedTime, outcome.JobRecord.RequestUri, requiresAccessToken: false, allFiles.Select(x => x.ToExportOutputResponse()).OrderBy(x => x.Type, StringComparer.Ordinal).ToList(), outcome.JobRecord.Error.Select(x => x.ToExportOutputResponse()).ToList(), outcome.JobRecord.Issues); exportResponse = new GetExportResponse(HttpStatusCode.OK, jobResult); } else if (outcome.JobRecord.Status == OperationStatus.Failed || outcome.JobRecord.Status == OperationStatus.Canceled) { string failureReason = outcome.JobRecord.FailureDetails != null ? outcome.JobRecord.FailureDetails.FailureReason : Resources.UnknownError; HttpStatusCode failureStatusCode = outcome.JobRecord.FailureDetails != null ? outcome.JobRecord.FailureDetails.FailureStatusCode : HttpStatusCode.InternalServerError; throw new OperationFailedException( string.Format(Resources.OperationFailed, OperationsConstants.Export, failureReason), failureStatusCode); } else { exportResponse = new GetExportResponse(HttpStatusCode.Accepted); } return(exportResponse); }