public IContextUpdater CreateContextUpdater(string taskId, string runId) { EnsureArg.IsNotEmptyOrWhiteSpace(taskId, nameof(taskId)); EnsureArg.IsNotEmptyOrWhiteSpace(runId, nameof(runId)); return(new SqlServerTaskContextUpdater(taskId, runId, _sqlConnectionWrapperFactory, _loggerFactory.CreateLogger <SqlServerTaskContextUpdater>())); }
public DataBaseFunctionalityValidator(IDataSource dataSource, IOptions <ConnectionStrings> configuration) { _dataSource = dataSource; _configuration = configuration.Value; EnsureArg.IsNotEmptyOrWhiteSpace(_configuration.DefaultConnection); }
public RetrieveResourceResponse(IEnumerable <Stream> responseStreams, string contentType) { EnsureArg.IsNotNull(responseStreams, nameof(responseStreams)); EnsureArg.IsNotEmptyOrWhiteSpace(contentType, nameof(contentType)); ResponseStreams = responseStreams; ContentType = contentType; }
public DataBaseFunctionalityValidator(ITokenDbContextFactory dbContextFactory, IOptions <ConnectionStrings> configuration) { _dbContextFactory = dbContextFactory; EnsureArg.IsNotEmptyOrWhiteSpace(_configuration.DefaultConnection); _configuration = configuration.Value; }
public async Task <string> GetFirmwareUrlAsync(string deviceType) { EnsureArg.IsNotEmptyOrWhiteSpace(deviceType); var gitUrl = await _deviceServiceManager.GetFirmwareGitUrlAsync(deviceType).ConfigureAwait(false); return(gitUrl); }
/// <summary> /// Creates the configuration asynchronous. /// </summary> /// <param name="model">The model.</param> /// <returns></returns> public async Task <string> CreateConfigAsync(ConfigReadModel model) { EnsureArg.IsNotNull(model); EnsureArg.IsNotEmptyOrWhiteSpace(model.Block); EnsureArg.IsNotEmptyOrWhiteSpace(model.Module); return(await _service.CreateConfigTomlAsync(model)); }
public void IsNotEmptyOrWhiteSpace_WhenPartialWhiteSpace_It_should_not_throw() { string value = " string with whitespace in it "; ShouldNotThrow( () => Ensure.String.IsNotEmptyOrWhiteSpace(value, ParamName), () => EnsureArg.IsNotEmptyOrWhiteSpace(value, ParamName), () => Ensure.That(value, ParamName).IsNotEmptyOrWhiteSpace()); }
public void IsNotEmptyOrWhiteSpace_WhenNull_It_should_not_throw() { string value = null; ShouldNotThrow( () => Ensure.String.IsNotEmptyOrWhiteSpace(value, ParamName), () => Ensure.That(value, ParamName).IsNotEmptyOrWhiteSpace(), () => EnsureArg.IsNotEmptyOrWhiteSpace(value, ParamName)); }
/// <summary> /// Gets the modules asynchronous. /// </summary> /// <param name="configTomlFileContent">Content of the configuration toml file.</param> /// <returns></returns> private async Task <IEnumerable <ModuleReadModel> > GetModulesAsync(string configTomlFileContent) { EnsureArg.IsNotEmptyOrWhiteSpace(configTomlFileContent); // get list of all modules. var modules = GetListOfModules(configTomlFileContent).ToList(); await _defaultValueManager.MergeValuesWithModulesAsync(configTomlFileContent, modules).ConfigureAwait(false); return(modules); }
/// <summary> /// Initializes a new instance of the <see cref="ManagerResponseBase{TErrorCode}"/> class. /// </summary> /// <param name="errorCode">The error code.</param> /// <param name="message">The message.</param> public ManagerResponseBase(TErrorCode errorCode, string message) { EnsureArg.IsNotNull <TErrorCode>(errorCode, nameof(errorCode)); EnsureArg.IsNotEmptyOrWhiteSpace(message, nameof(message)); ErrorRecords = new ErrorRecords <TErrorCode> { new ErrorRecord <TErrorCode>(errorCode, message) }; }
public (Channel <ImportResource> resourceChannel, Task loadTask) LoadResources(string resourceLocation, long startIndex, string resourceType, Func <long, long> sequenceIdGenerator, CancellationToken cancellationToken) { EnsureArg.IsNotEmptyOrWhiteSpace(resourceLocation, nameof(resourceLocation)); Channel <ImportResource> outputChannel = Channel.CreateBounded <ImportResource>(ChannelMaxCapacity); Task loadTask = Task.Run(async() => await LoadResourcesInternalAsync(outputChannel, resourceLocation, startIndex, resourceType, sequenceIdGenerator, cancellationToken), cancellationToken); return(outputChannel, loadTask); }
public void IsNotEmptyOrWhiteSpace_WhenWhiteSpace_ThrowsArgumentException() { string value = " "; ShouldThrow <ArgumentException>( ExceptionMessages.Strings_IsNotEmptyOrWhiteSpace_Failed, () => Ensure.String.IsNotEmptyOrWhiteSpace(value, ParamName), () => Ensure.That(value, ParamName).IsNotEmptyOrWhiteSpace(), () => EnsureArg.IsNotEmptyOrWhiteSpace(value, ParamName)); }
public IExpressionEvaluator Create(TemplateExpression expression) { EnsureArg.IsNotEmptyOrWhiteSpace(expression?.Value, nameof(expression.Value)); EnsureArg.IsNotNull(expression?.Language, nameof(expression.Language)); return(expression.Language switch { TemplateExpressionLanguage.JsonPath => new JsonPathExpressionEvaluator(expression.Value), TemplateExpressionLanguage.JmesPath => new JmesPathExpressionEvaluator(_jmesPath, expression.Value), _ => throw new TemplateExpressionException($"Unsupported Expression Language: {expression?.Language}") });
/// <summary> /// Initializes a new instance of the <see cref="ErrorRecord{TErrorCode}"/> class. /// </summary> /// <param name="errorCode">The error code.</param> /// <param name="message">The message.</param> public ErrorRecord(TErrorCode errorCode, string message) { EnsureArg.IsNotNull <TErrorCode>(errorCode, nameof(errorCode)); EnsureArg.IsNotEmptyOrWhiteSpace(message, nameof(message)); var errorMessages = new ErrorMessages <TErrorCode> { new ErrorMessage <TErrorCode>(errorCode, message) }; SetValues(null, 0, errorMessages); }
/// <summary> /// Gets the list of modules. /// </summary> /// <param name="configTomlFile">The configuration toml file.</param> /// <returns></returns> private static IEnumerable <ModuleReadModel> GetListOfModules(string configTomlFile) { EnsureArg.IsNotEmptyOrWhiteSpace(configTomlFile); var data = TomlFileReader.ReadDataFromString <ConfigurationReadModel>(configTomlFile); var listOfModules = data.Module; listOfModules = listOfModules.Select((module, index) => new ModuleReadModel { Id = index, Config = module.Config, Name = module.Name, UUID = module.UUID }).ToList(); return(listOfModules); }
/// <summary> /// Initializes a new instance of the <see cref="ErrorRecord{TErrorCode}"/> class. /// </summary> /// <param name="ordinalPosition">The ordinal position.</param> /// <param name="errorCode">The error code.</param> /// <param name="message">The message.</param> public ErrorRecord(int ordinalPosition, TErrorCode errorCode, string message) { EnsureArg.IsGte(ordinalPosition, 0, nameof(ordinalPosition)); EnsureArg.IsNotNull <TErrorCode>(errorCode, nameof(errorCode)); EnsureArg.IsNotEmptyOrWhiteSpace(message, nameof(message)); var errorMessages = new ErrorMessages <TErrorCode> { new ErrorMessage <TErrorCode>(errorCode, message) }; SetValues(null, ordinalPosition, errorMessages); }
public IExpressionEvaluator Create(TemplateExpression expression) { EnsureArg.IsNotEmptyOrWhiteSpace(expression?.Value, nameof(expression.Value)); var expressionLanguage = expression.Language ?? TemplateExpressionLanguage.JsonPath; if (expressionLanguage != TemplateExpressionLanguage.JsonPath) { throw new TemplateExpressionException($"Unsupported Expression Language {expressionLanguage}. Only JsonPath is supported."); } return(new JsonPathExpressionEvaluator(expression.Value)); }
/// <summary> /// Sets the git repo URL. /// </summary> /// <param name="deviceType">Type of the device.</param> /// <param name="gitUrl">The git URL.</param> public void SetGitRepoUrl(string deviceType, string gitUrl) { EnsureArg.IsNotEmptyOrWhiteSpace(deviceType); EnsureArg.IsNotEmptyOrWhiteSpace(gitUrl); _firmwareVersionGitConnection.GitRemoteLocation = gitUrl; _logger.LogInformation("Setting git repository connection"); var appPath = GlobalMethods.GetCurrentAppPath(); var temp = Path.Combine(appPath, _firmwareVersionGitConnection.GitLocalFolder + "-" + deviceType); _repoManager.SetConnectionOptions(_firmwareVersionGitConnection, temp); }
public Stream TranscodeFrame(DicomFile dicomFile, int frameIndex, string requestedTransferSyntax) { EnsureArg.IsNotNull(dicomFile, nameof(dicomFile)); EnsureArg.IsNotEmptyOrWhiteSpace(requestedTransferSyntax, nameof(requestedTransferSyntax)); DicomDataset dataset = dicomFile.Dataset; // Validate requested frame index exists in file. dicomFile.GetPixelDataAndValidateFrames(new[] { frameIndex }); var parsedDicomTransferSyntax = DicomTransferSyntax.Parse(requestedTransferSyntax); IByteBuffer resultByteBuffer = TranscodeFrame(dataset, frameIndex, parsedDicomTransferSyntax); return(_recyclableMemoryStreamManager.GetStream("RetrieveDicomResourceHandler.GetFrameAsDicomData", resultByteBuffer.Data, 0, resultByteBuffer.Data.Length)); }
/// <summary> /// Initializes a new instance of the <see cref="SearchModifier"/> class. /// </summary> /// <param name="searchModifierCode"><see cref="SearchModifierCode"/></param> /// <param name="resourceType">Resource type used to constrain abstract modifier code (e.g. <see cref="SearchModifierCode.Type"/>)</param> public SearchModifier(SearchModifierCode searchModifierCode, string resourceType = null) { if (searchModifierCode == SearchModifierCode.Type) { EnsureArg.IsNotEmptyOrWhiteSpace(resourceType, nameof(resourceType)); } else { EnsureArg.Is(resourceType, null, nameof(resourceType)); } SearchModifierCode = searchModifierCode; ResourceType = resourceType; }
public static StringSegment GetParameter(this MediaTypeHeaderValue headerValue, string parameterName, bool tryRemoveQuotes = true) { EnsureArg.IsNotNull(headerValue, nameof(headerValue)); EnsureArg.IsNotEmptyOrWhiteSpace(parameterName, nameof(parameterName)); foreach (NameValueHeaderValue parameter in headerValue.Parameters) { if (StringSegment.Equals(parameter.Name, parameterName, StringComparison.OrdinalIgnoreCase)) { return(tryRemoveQuotes ? HeaderUtilities.RemoveQuotes(parameter.Value) : parameter.Value); } } return(StringSegment.Empty); }
protected T EvalExpression <T>(JToken token, string name, bool isRequired = false, params TemplateExpression[] expressions) { EnsureArg.IsNotNull(token, nameof(token)); EnsureArg.IsNotEmptyOrWhiteSpace(name, nameof(name)); if (expressions?.Any(e => e != null) == true) { var exceptions = new List <Exception>(); foreach (var expression in expressions) { if (expression == null) { continue; } var evaluator = ExpressionEvaluatorFactory.Create(expression); var evaluatedToken = evaluator.SelectToken(token); if (evaluatedToken != null) { try { return(evaluatedToken.Value <T>()); } catch (Exception e) { exceptions.Add(new IncompatibleDataException($"Encounted an error while extracting value for [{name}] using expression {expression.Value}", e)); } } } if (isRequired) { if (exceptions.Count > 0) { throw new IncompatibleDataException($"Unable to extract required value for [{name}]", new AggregateException(exceptions)); } throw new IncompatibleDataException($"Unable to extract required value for [{name}] using {string.Join(",", expressions.Select(e => e.Value).ToArray())}"); } } else if (isRequired) { throw new IncompatibleDataException($"An expression must be set for [{name}]"); } return(default);
public async Task <IEnumerable <string> > GetAllFirmwareVersionsAsync(string deviceType) { EnsureArg.IsNotEmptyOrWhiteSpace(deviceType); _logger.LogInformation($"{Prefix}: methodName: {nameof(GetAllFirmwareVersionsAsync)} Getting list of all firmware versions for device type {deviceType}."); var gitUrl = await GetFirmwareUrlAsync(deviceType).ConfigureAwait(false); _logger.LogInformation($"{Prefix}: methodName: {nameof(GetAllFirmwareVersionsAsync)} Git Repo url for device type {deviceType} is {gitUrl}."); SetGitRepoUrl(deviceType, gitUrl); // clone git repository. await CloneGitRepoAsync().ConfigureAwait(false); var listFirmwareVersions = await GetAllFirmwareVersionsAsync() .ConfigureAwait(false); return(listFirmwareVersions); }
public AcceptHeaderDescriptor(PayloadTypes payloadType, string mediaType, bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, ISet <string> acceptableTransferSyntaxes) { EnsureArg.IsNotEmptyOrWhiteSpace(mediaType, nameof(mediaType)); // When transfersyntax is not mandatory, transferSyntaxWhenMissing has to be presented if (!isTransferSyntaxMandatory) { EnsureArg.IsNotEmptyOrWhiteSpace(transferSyntaxWhenMissing, nameof(transferSyntaxWhenMissing)); } EnsureArg.IsNotNull(acceptableTransferSyntaxes, nameof(acceptableTransferSyntaxes)); PayloadType = payloadType; MediaType = mediaType; IsTransferSyntaxMandatory = isTransferSyntaxMandatory; TransferSyntaxWhenMissing = transferSyntaxWhenMissing; AcceptableTransferSyntaxes = acceptableTransferSyntaxes; }
public static string GetEventHubFQDN(string host) { EnsureArg.IsNotEmptyOrWhiteSpace(host); if (Uri.IsWellFormedUriString(host, UriKind.Absolute)) { var uri = new Uri(host); host = uri.Host; } if (Uri.CheckHostName(host) != UriHostNameType.Unknown) { return(host); } else { throw new Exception($"The event hub FQDN: {host} is not valid"); } }
/// <summary> /// Reads the data from string. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data">The data.</param> /// <param name="settings">The settings.</param> /// <returns></returns> /// <exception cref="CustomArgumentException"></exception> public static T ReadDataFromString <T>(string data, TomlSettings settings = null) where T : class, new() { EnsureArg.IsNotEmptyOrWhiteSpace(data, nameof(data)); T fileData; try { settings ??= LoadLowerCaseTomlSettings(); fileData = Toml.ReadString <T>(data, settings); } catch (Exception exception) { throw new CustomArgumentException(Resource.TomlParsingError, exception); } return(fileData); }
/// <summary> /// Determines whether [is path URL]. /// </summary> /// <param name="path">The path.</param> /// <returns> /// <c>true</c> if [is path URL] [the specified path]; otherwise, <c>false</c>. /// </returns> public static bool IsPathUrl(this string path) { EnsureArg.IsNotEmptyOrWhiteSpace(path); if (System.IO.File.Exists(path)) { return(false); } try { var uri = new Uri(path); return(true); } catch (Exception) { return(false); } }
public async Task <Stream> TranscodeFileAsync(Stream stream, string requestedTransferSyntax) { EnsureArg.IsNotNull(stream, nameof(stream)); EnsureArg.IsNotEmptyOrWhiteSpace(requestedTransferSyntax, nameof(requestedTransferSyntax)); var parsedDicomTransferSyntax = DicomTransferSyntax.Parse(requestedTransferSyntax); DicomFile dicomFile; try { dicomFile = await DicomFile.OpenAsync(stream, FileReadOption.ReadLargeOnDemand); } catch (DicomFileException) { throw; } stream.Seek(0, SeekOrigin.Begin); return(await TranscodeFileAsync(dicomFile, parsedDicomTransferSyntax)); }
private static IServiceCollection AddFunctionsOptions <T>( this IServiceCollection services, IConfiguration configuration, string sectionName, bool bindNonPublicProperties = false) where T : class { EnsureArg.IsNotNull(services, nameof(services)); EnsureArg.IsNotNull(configuration, nameof(configuration)); EnsureArg.IsNotEmptyOrWhiteSpace(sectionName, nameof(sectionName)); services .AddOptions <T>() .Bind( configuration .GetSection(DicomFunctionsConfiguration.SectionName) .GetSection(sectionName), x => x.BindNonPublicProperties = bindNonPublicProperties) .ValidateDataAnnotations(); return(services); }
public async Task <Asset> CreateOutputAssetAsync(string inputAssetName, string outputAssetName) { EnsureArg.IsNotEmptyOrWhiteSpace(inputAssetName, nameof(inputAssetName)); EnsureArg.IsNotEmptyOrWhiteSpace(outputAssetName, nameof(outputAssetName)); var asset = new Asset(); // Asset outputAsset = // await _azureMediaServicesClient // .Assets // .GetAsync( // _clientSettings.ResourceGroup, // _clientSettings.AccountName, // inputAssetName); return(await _azureMediaServicesClient.Assets.CreateOrUpdateAsync( _clientSettings.ResourceGroup, _clientSettings.AccountName, outputAssetName, asset)); // TODO: Hypothetically we should be able to check if the asset exists and if it does we should not add anything // Check if an asset already exists. }