public SupportedSearchParameterDefinitionManager(ISearchParameterDefinitionManager inner)
        {
            EnsureArg.IsNotNull(inner, nameof(inner));

            _inner = inner;
        }
 protected ParallelTaskWorker(TOptions options, int maxParallelism = 1)
 {
     _options        = EnsureArg.IsNotNull(options, nameof(options));
     _maxParallelism = EnsureArg.IsGt(maxParallelism, 0, nameof(maxParallelism));
 }
Exemple #3
0
        public SearchParameterInfo(string name)
        {
            EnsureArg.IsNotNullOrWhiteSpace(name, nameof(name));

            Name = name;
        }
 public static string CompartmentTypeToResourceType(string compartmentType)
 {
     EnsureArg.IsTrue(Enum.IsDefined(typeof(CompartmentType), compartmentType), nameof(compartmentType));
     return(compartmentType);
 }
Exemple #5
0
 /// <summary>
 /// Initializes a new instance of the class <see cref="FigureInfoFactory"/>.
 /// </summary>
 public FigureInfoFactory(IFigureInfoTypeProvider figureInfoTypeProvider)
 {
     _figureInfoTypeProvider = EnsureArg.IsNotNull(figureInfoTypeProvider, nameof(figureInfoTypeProvider));
 }
Exemple #6
0
 public static Task <RetrieveMetadataResponse> RetrieveDicomInstanceMetadataAsync(
     this IMediator mediator, string studyInstanceUid, string seriesInstanceUid, string sopInstanceUid, string ifNoneMatch, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new RetrieveMetadataRequest(studyInstanceUid, seriesInstanceUid, sopInstanceUid, ifNoneMatch), cancellationToken));
 }
 public NormalizationDataMappingException(Exception ex)
     : base(BuildMessage(ex), ex)
 {
     EnsureArg.IsNotNull(ex, nameof(ex));
 }
        /// <inheritdoc />
        public ReferenceSearchValue Parse(string s)
        {
            EnsureArg.IsNotNullOrWhiteSpace(s, nameof(s));

            Match match = ReferenceRegex.Match(s);

            if (match.Success)
            {
                string resourceTypeInString = match.Groups[ResourceTypeCapture].Value;

                ModelInfoProvider.EnsureValidResourceType(resourceTypeInString, nameof(s));

                string resourceId = match.Groups[ResourceIdCapture].Value;

                int resourceTypeStartIndex = match.Groups[ResourceTypeCapture].Index;

                if (resourceTypeStartIndex == 0)
                {
                    // This is relative URL.
                    return(new ReferenceSearchValue(
                               ReferenceKind.InternalOrExternal,
                               null,
                               resourceTypeInString,
                               resourceId));
                }

                Uri baseUri = null;

                try
                {
                    baseUri = new Uri(s.Substring(0, resourceTypeStartIndex), UriKind.RelativeOrAbsolute);

                    if (baseUri == _fhirRequestContextAccessor.FhirRequestContext.BaseUri)
                    {
                        // This is an absolute URL pointing to an internal resource.
                        return(new ReferenceSearchValue(
                                   ReferenceKind.Internal,
                                   null,
                                   resourceTypeInString,
                                   resourceId));
                    }
                    else if (baseUri.IsAbsoluteUri &&
                             SupportedSchemes.Contains(baseUri.Scheme, StringComparer.OrdinalIgnoreCase))
                    {
                        // This is an absolute URL pointing to an external resource.
                        return(new ReferenceSearchValue(
                                   ReferenceKind.External,
                                   baseUri,
                                   resourceTypeInString,
                                   resourceId));
                    }
                }
                catch (UriFormatException)
                {
                    // The reference is not a relative reference but is not a valid absolute reference either.
                }
            }

            return(new ReferenceSearchValue(
                       ReferenceKind.InternalOrExternal,
                       baseUri: null,
                       resourceType: null,
                       resourceId: s));
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="SearchParameterNotSupportedException"/> class.
        /// </summary>
        /// <param name="definitionUri">The search parameter definition URL.</param>
        public SearchParameterNotSupportedException(Uri definitionUri)
        {
            EnsureArg.IsNotNull(definitionUri, nameof(definitionUri));

            AddIssue(string.Format(Core.Resources.SearchParameterByDefinitionUriNotSupported, definitionUri.ToString()));
        }
 public SqlRootExpressionRewriter(NormalizedSearchParameterQueryGeneratorFactory normalizedSearchParameterQueryGeneratorFactory)
 {
     EnsureArg.IsNotNull(normalizedSearchParameterQueryGeneratorFactory, nameof(normalizedSearchParameterQueryGeneratorFactory));
     _normalizedSearchParameterQueryGeneratorFactory = normalizedSearchParameterQueryGeneratorFactory;
 }
        public ReferenceSearchValueParser(IFhirRequestContextAccessor fhirRequestContextAccessor)
        {
            EnsureArg.IsNotNull(fhirRequestContextAccessor, nameof(fhirRequestContextAccessor));

            _fhirRequestContextAccessor = fhirRequestContextAccessor;
        }
        protected override Observation MergeObservationImpl(CodeValueFhirTemplate template, IObservationGroup grp, Observation existingObservation)
        {
            EnsureArg.IsNotNull(grp, nameof(grp));
            EnsureArg.IsNotNull(existingObservation, nameof(existingObservation));

            existingObservation.Status = ObservationStatus.Amended;

            existingObservation.Category = null;
            if (template?.Category?.Count > 0)
            {
                existingObservation.Category = ResolveCategory(template.Category);
            }

            var values = grp.GetValues();

            (DateTime start, DateTime end)observationPeriod = GetObservationPeriod(existingObservation);

            // Update observation value
            if (!string.IsNullOrWhiteSpace(template?.Value?.ValueName) && values.TryGetValue(template?.Value?.ValueName, out var obValues))
            {
                existingObservation.Value = _valueProcessor.MergeValue(template.Value, CreateMergeData(grp.Boundary, observationPeriod, obValues), existingObservation.Value);
            }

            // Update observation component values
            if (template?.Components?.Count > 0)
            {
                if (existingObservation.Component == null)
                {
                    existingObservation.Component = new List <Observation.ComponentComponent>(template.Components.Count);
                }

                foreach (var component in template.Components)
                {
                    if (values.TryGetValue(component.Value.ValueName, out var compValues))
                    {
                        var foundComponent = existingObservation.Component
                                             .Where(c => c.Code.Coding.Any(code => code.Code == component.Value.ValueName && code.System == FhirImportService.ServiceSystem))
                                             .FirstOrDefault();

                        if (foundComponent == null)
                        {
                            existingObservation.Component.Add(
                                new Observation.ComponentComponent
                            {
                                Code  = ResolveCode(component.Value.ValueName, component.Codes),
                                Value = _valueProcessor.CreateValue(component.Value, CreateMergeData(grp.Boundary, observationPeriod, compValues)),
                            });
                        }
                        else
                        {
                            foundComponent.Value = _valueProcessor.MergeValue(component.Value, CreateMergeData(grp.Boundary, observationPeriod, compValues), foundComponent.Value);
                        }
                    }
                }
            }

            // Update observation effective period if merge values exist outside the current period.
            if (grp.Boundary.Start < observationPeriod.start)
            {
                observationPeriod.start = grp.Boundary.Start;
            }

            if (grp.Boundary.End > observationPeriod.end)
            {
                observationPeriod.end = grp.Boundary.End;
            }

            existingObservation.Effective = observationPeriod.ToPeriod();

            return(existingObservation);
        }
 public CodeValueFhirTemplateProcessor(IFhirValueProcessor <IObservationData, Element> valueProcessor)
 {
     EnsureArg.IsNotNull(valueProcessor);
     _valueProcessor = valueProcessor;
 }
 public MetadataResult(RetrieveMetadataResponse response)
     : base(EnsureArg.IsNotNull(response, nameof(response)).ResponseMetadata)
 {
     _response = response;
 }
Exemple #15
0
 public static Task <UpdateExtendedQueryTagResponse> UpdateExtendedQueryTagAsync(
     this IMediator mediator, string tagPath, UpdateExtendedQueryTagEntry newValue, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new UpdateExtendedQueryTagRequest(tagPath, newValue), cancellationToken));
 }
        protected override bool CanReadType(Type type)
        {
            EnsureArg.IsNotNull(type, nameof(type));

            return(typeof(Resource).IsAssignableFrom(type));
        }
Exemple #17
0
 public static Task <StoreResponse> StoreDicomResourcesAsync(
     this IMediator mediator, Stream requestBody, string requestContentType, string studyInstanceUid, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new StoreRequest(requestBody, requestContentType, studyInstanceUid), cancellationToken));
 }
 public AccessTokenProviderException(string message)
     : base(message)
 {
     EnsureArg.IsNotNullOrWhiteSpace(message, nameof(message));
 }
Exemple #19
0
 public static Task <DeleteResourcesResponse> DeleteDicomSeriesAsync(
     this IMediator mediator, string studyInstanceUid, string seriesInstanceUid, CancellationToken cancellationToken = default)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new DeleteResourcesRequest(studyInstanceUid, seriesInstanceUid), cancellationToken));
 }
 public DevelopmentAuthEnvironmentConfigurationSource(string filePath)
 {
     EnsureArg.IsNotNullOrWhiteSpace(filePath, nameof(filePath));
     _filePath = filePath;
 }
        public CompartmentDefinitionManager(IModelInfoProvider modelInfoProvider)
        {
            EnsureArg.IsNotNull(modelInfoProvider, nameof(modelInfoProvider));

            _modelInfoProvider = modelInfoProvider;
        }
        /// <summary>
        /// Adds an in-process identity provider if enabled in configuration.
        /// </summary>
        /// <param name="services">The services collection.</param>
        /// <param name="configuration">The configuration root. The "DevelopmentIdentityProvider" section will be used to populate configuration values.</param>
        /// <returns>The same services collection.</returns>
        public static IServiceCollection AddDevelopmentIdentityProvider(this IServiceCollection services, IConfiguration configuration)
        {
            EnsureArg.IsNotNull(services, nameof(services));
            EnsureArg.IsNotNull(configuration, nameof(configuration));

            var authorizationConfiguration = new AuthorizationConfiguration();

            configuration.GetSection("FhirServer:Security:Authorization").Bind(authorizationConfiguration);

            var developmentIdentityProviderConfiguration = new DevelopmentIdentityProviderConfiguration();

            configuration.GetSection("DevelopmentIdentityProvider").Bind(developmentIdentityProviderConfiguration);
            services.AddSingleton(Options.Create(developmentIdentityProviderConfiguration));

            if (developmentIdentityProviderConfiguration.Enabled)
            {
                services.AddIdentityServer()
                .AddDeveloperSigningCredential()
                .AddInMemoryApiResources(new[]
                {
                    new ApiResource(
                        DevelopmentIdentityProviderConfiguration.Audience,
                        claimTypes: new List <string>()
                    {
                        authorizationConfiguration.RolesClaim, ClaimTypes.Name, ClaimTypes.NameIdentifier
                    })
                    {
                        UserClaims = { authorizationConfiguration.RolesClaim },
                    },
                    new ApiResource(
                        WrongAudienceClient,
                        claimTypes: new List <string>()
                    {
                        authorizationConfiguration.RolesClaim, ClaimTypes.Name, ClaimTypes.NameIdentifier
                    })
                    {
                        UserClaims = { authorizationConfiguration.RolesClaim },
                    },
                })
                .AddTestUsers(developmentIdentityProviderConfiguration.Users?.Select(user =>
                                                                                     new TestUser
                {
                    Username  = user.Id,
                    Password  = user.Id,
                    IsActive  = true,
                    SubjectId = user.Id,
                    Claims    = user.Roles.Select(r => new Claim(authorizationConfiguration.RolesClaim, r)).ToList(),
                }).ToList())
                .AddInMemoryClients(
                    developmentIdentityProviderConfiguration.ClientApplications.Select(
                        applicationConfiguration =>
                        new Client
                {
                    ClientId = applicationConfiguration.Id,

                    // client credentials and ROPC for testing
                    AllowedGrantTypes = GrantTypes.ResourceOwnerPasswordAndClientCredentials,

                    // secret for authentication
                    ClientSecrets = { new Secret(applicationConfiguration.Id.Sha256()) },

                    // scopes that client has access to
                    AllowedScopes = { DevelopmentIdentityProviderConfiguration.Audience, WrongAudienceClient },

                    // app roles that the client app may have
                    Claims = applicationConfiguration.Roles.Select(r => new Claim(authorizationConfiguration.RolesClaim, r)).Concat(new[] { new Claim("appid", applicationConfiguration.Id) }).ToList(),

                    ClientClaimsPrefix = string.Empty,
                }));
            }

            return(services);
        }
        private static Dictionary <CompartmentType, (CompartmentType, Uri, IList <(string, IList <string>)>)> ValidateAndGetCompartmentDict(BundleWrapper bundle)
        {
            EnsureArg.IsNotNull(bundle, nameof(bundle));

            var issues = new List <OperationOutcomeIssue>();
            var validatedCompartments = new Dictionary <CompartmentType, (CompartmentType, Uri, IList <(string, IList <string>)>)>();

            IReadOnlyList <BundleEntryWrapper> entries = bundle.Entries;

            for (int entryIndex = 0; entryIndex < entries.Count; entryIndex++)
            {
                // Make sure resources are not null and they are Compartment.
                BundleEntryWrapper entry = entries[entryIndex];

                var compartment = entry.Resource;

                if (compartment == null || !string.Equals(KnownResourceTypes.CompartmentDefinition, compartment.InstanceType, StringComparison.Ordinal))
                {
                    AddIssue(Core.Resources.CompartmentDefinitionInvalidResource, entryIndex);
                    continue;
                }

                string code = compartment.Scalar("code")?.ToString();
                string url  = compartment.Scalar("url")?.ToString();

                if (code == null)
                {
                    AddIssue(Core.Resources.CompartmentDefinitionInvalidCompartmentType, entryIndex);
                    continue;
                }

                CompartmentType typeCode = EnumUtility.ParseLiteral <CompartmentType>(code).GetValueOrDefault();

                if (validatedCompartments.ContainsKey(typeCode))
                {
                    AddIssue(Core.Resources.CompartmentDefinitionIsDupe, entryIndex);
                    continue;
                }

                if (string.IsNullOrWhiteSpace(url) || !Uri.IsWellFormedUriString(url, UriKind.Absolute))
                {
                    AddIssue(Core.Resources.CompartmentDefinitionInvalidUrl, entryIndex);
                    continue;
                }

                var resources = compartment.Select("resource")
                                .Select(x => (x.Scalar("code")?.ToString(), (IList <string>)x.Select("param").AsStringValues().ToList()))
                                .ToList();

                var resourceNames = resources.Select(x => x.Item1).ToArray();

                if (resourceNames.Length != resourceNames.Distinct().Count())
                {
                    AddIssue(Core.Resources.CompartmentDefinitionDupeResource, entryIndex);
                    continue;
                }

                validatedCompartments.Add(
                    typeCode,
                    (typeCode, new Uri(url), new List <(string, IList <string>)>(resources)));
            }

            if (issues.Count != 0)
            {
                throw new InvalidDefinitionException(
                          Core.Resources.CompartmentDefinitionContainsInvalidEntry,
                          issues.ToArray());
            }

            return(validatedCompartments);

            void AddIssue(string format, params object[] args)
            {
                issues.Add(new OperationOutcomeIssue(
                               OperationOutcomeConstants.IssueSeverity.Fatal,
                               OperationOutcomeConstants.IssueType.Invalid,
                               string.Format(CultureInfo.InvariantCulture, format, args)));
            }
        }
Exemple #24
0
 public static Task <AddExtendedQueryTagResponse> AddExtendedQueryTagsAsync(
     this IMediator mediator, IEnumerable <AddExtendedQueryTagEntry> extendedQueryTags, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new AddExtendedQueryTagRequest(extendedQueryTags), cancellationToken));
 }
        public CustomerConsoleCommandEventHandler(IMediator mediator)
        {
            EnsureArg.IsNotNull(mediator, nameof(mediator));

            this.mediator = mediator;
        }
Exemple #26
0
 public static Task <GetExtendedQueryTagResponse> GetExtendedQueryTagAsync(
     this IMediator mediator, string extendedQueryTagPath, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new GetExtendedQueryTagRequest(extendedQueryTagPath), cancellationToken));
 }
Exemple #27
0
        public static bool IsSortSupported(this SearchParameterInfo searchParameterInfo)
        {
            EnsureArg.IsNotNull(searchParameterInfo, nameof(searchParameterInfo));

            return(supportedSortParameters.Contains(searchParameterInfo.Name));
        }
Exemple #28
0
 public static Task <GetExtendedQueryTagErrorsResponse> GetExtendedQueryTagErrorsAsync(
     this IMediator mediator, string extendedQueryTagPath, int limit, int offset, CancellationToken cancellationToken)
 {
     EnsureArg.IsNotNull(mediator, nameof(mediator));
     return(mediator.Send(new GetExtendedQueryTagErrorsRequest(extendedQueryTagPath, limit, offset), cancellationToken));
 }
 public CompartmentDefinitionManager(FhirJsonParser fhirJsonParser)
 {
     EnsureArg.IsNotNull(fhirJsonParser, nameof(fhirJsonParser));
     _fhirJsonParser = fhirJsonParser;
 }
        protected internal override void AcceptVisitor(IExpressionVisitor visitor)
        {
            EnsureArg.IsNotNull(visitor, nameof(visitor));

            visitor.Visit(this);
        }