protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var value = commandLine.ReadValue(); var separatorIndex = value.IndexOf(':'); if (separatorIndex == -1) { convertResult.Warnings.Add($"Unable to parse header \"{value.ToString()}\""); return; } var headerKey = value.Slice(0, separatorIndex) .ToString() .Trim(); var headerValue = string.Empty; var valueStartIndex = separatorIndex + 1; if (value.Length > valueStartIndex) { headerValue = value.Slice(valueStartIndex) .ToString() .Trim(); } if (string.IsNullOrEmpty(headerValue) || !convertResult.Data.Headers.TryAdd(headerKey, headerValue)) { convertResult.Warnings.Add($"Unable to add header \"{headerKey}\": \"{headerValue}\""); } }
// PUBLIC CONSTRUCTORS ////////////////////////////////////////// #region Constructors public ConvertGenericTest(string name, TSource source, ConvertResult expectedResult, TTarget expectedValue, TypeConverterSettings context = null) : base(name) { this.Source = source; this.ExpectedResult = expectedResult; this.ExpectedValue = expectedValue; this.Context = context; }
public void ShouldDeconstructConvertResult() { var result = ConvertResult.Failed("Failed message"); var(success, message) = result; Assert.False(success); Assert.Equal("Failed message", message); }
public void LoadConvertResult(ConvertResult result) { m_ImageCore.IO.LoadImage(result.Image); if (result.Annotations != null) { m_ImageCore.ImageBuffer.SetMetaData(m_ImageCore.ImageBuffer.CurrentImageIndexInBuffer, EnumMetaDataType.enumAnnotation, result.Annotations, true); } }
public ConvertResult OoxToDaisy(string inputFile, string outputFile, Hashtable listMathMl, Hashtable table, string control, string output_Pipeline) { ConvertResult result = ConvertOoxToDaisy(inputFile, outputFile, listMathMl, table, control, output_Pipeline); DeleteTemporaryImages(); return(result); }
private ConvertResult ConvertOoxToDaisy(string inputFile, string outputFile, Hashtable listMathMl, Hashtable table, string control, string output_Pipeline) { try { using (ConverterForm form = new ConverterForm(this.converter, inputFile, outputFile, this.resourceManager, true, listMathMl, table, control, output_Pipeline)) { if (DialogResult.OK != form.ShowDialog()) { return(ConvertResult.Cancel()); } if (!String.IsNullOrEmpty(form.ValidationError)) { OnValidationError(form.ValidationError, inputFile, outputFile); return(ConvertResult.ValidationError(form.ValidationError)); } if (form.HasLostElements) { OnLostElements(inputFile, outputFile, form.LostElements); if (!(AddInHelper.IsSingleDaisyTranslate(control) && this.ScriptToExecute == null) && IsContinueDTBookGenerationOnLostElements()) { ExecuteScript(outputFile); } } else if (AddInHelper.IsSingleDaisyTranslate(control) && this.ScriptToExecute == null) { OnSuccess(); } else { ExecuteScript(outputFile); } } } catch (IOException e) { // this is meant to catch "file already accessed by another process", though there's no .NET fine-grain exception for this. AddinLogger.Error(e); OnUnknownError("UnableToCreateOutputLabel", e.Message); return(ConvertResult.UnknownError(e.Message + Environment.NewLine + e.StackTrace)); } catch (Exception e) { AddinLogger.Error(e); OnUnknownError("DaisyUnexpectedError", e.GetType() + ": " + e.Message + " (" + e.StackTrace + ")"); if (File.Exists(outputFile)) { File.Delete(outputFile); } return(ConvertResult.UnknownError(e.Message + Environment.NewLine + e.StackTrace)); } return(ConvertResult.Success()); }
protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var value = commandLine.ReadValue(); if (!convertResult.Data.Headers.TryAdd(HeaderNames.UserAgent, value.ToString())) { convertResult.Warnings.Add("Unable to set User-Agent header"); } }
public void Evaluate(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { commandLine = commandLine.TrimStart(Chars.Escape).Trim(); if (!CanBeEmpty && commandLine.IsEmpty) { return; } EvaluateInner(ref commandLine, convertResult); }
public void ConvertProductPrice() { var converter = new FreeCurrencyConverterApi(); foreach (var Variant in Variants) { ConvertResult result = converter.GetExchangeRate(Variant.Currency); Variant.Price = Variant.Price * result.val; Variant.Currency = CultureInfo.CurrentCulture; } }
public void Evaluate_IpWithoutProtocol_UseHttpProtocol() { var evaluator = new ProxyParameterEvaluator(); var span = new Span <char>("123.0.4.3:1234".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal(new Uri("http://123.0.4.3:1234"), convertResult.Data.ProxyUri); }
private void EvaluateUrlValue(ConvertResult <CurlOptions> convertResult, string val) { if (Uri.TryCreate(val, UriKind.Absolute, out var url) || Uri.TryCreate($"http://{val}", UriKind.Absolute, out url)) { convertResult.Data.Url = url; } else { convertResult.Warnings.Add($"Unable to parse URL \"{val}\""); } }
private void AddWarningsIfAny(CurlOptions curlOptions, ConvertResult <string> result) { if (curlOptions.HasProxy && !IsSupportedProxy(curlOptions.ProxyUri)) { result.Warnings.Add($"Proxy scheme \"{curlOptions.ProxyUri.Scheme}\" is not supported"); } if (curlOptions.HasCertificate && !IsSupportedCertificate(curlOptions.CertificateType)) { result.Warnings.Add($"Certificate type \"{curlOptions.CertificateType.ToString()}\" is not supported"); } }
public void Evaluate_OneColon_UseDefaultCredentials() { var evaluator = new ProxyCredentialsParameterEvaluator(); var span = new Span <char>(":".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.True(convertResult.Data.UseDefaultProxyCredentials); }
private void PostParsing(ConvertResult <CurlOptions> result, ParseState state) { if (result.Data.Url == null && !string.IsNullOrWhiteSpace(state.LastUnknownValue) && Uri.TryCreate($"http://{state.LastUnknownValue}", UriKind.Absolute, out Uri url)) { result.Data.Url = url; } var hasDataUpload = result.Data.DataFiles.Any() || result.Data.PayloadCollection.Any(); // This option overrides -F, --form and -I, --head and -T, --upload-file. if (hasDataUpload) { result.Data.UploadFiles.Clear(); } var hasFileUpload = result.Data.UploadFiles.Any(); if (result.Data.HttpMethod == null) { if (hasDataUpload) { result.Data.HttpMethod = HttpMethod.Post.ToString() .ToUpper(); } else if (hasFileUpload) { result.Data.HttpMethod = HttpMethod.Put.ToString() .ToUpper(); } else { result.Data.HttpMethod = HttpMethod.Get.ToString() .ToUpper(); } } if (!result.Data.Headers.GetCommaSeparatedValues(HeaderNames.ContentType).Any() && hasDataUpload) { result.Data.Headers.TryAdd(HeaderNames.ContentType, "application/x-www-form-urlencoded"); } if (!state.IsCurlCommand) { result.Errors.Add("Invalid curl command"); } if (result.Data.Url == null) { result.Errors.Add("Unable to parse URL"); } }
/// <summary> /// Convert <see cref="HttpMethod"/> to <see cref="Method"/> /// </summary> /// <param name="source">The source value</param> /// <returns>The <see cref="ConvertResult{TResult}"/> containing the converted value</returns> /// <exception cref="ArgumentException">Unsupported value</exception> public ConvertResult <Method?> Convert(HttpMethod?source) { Method?method; switch (source) { case null: method = null; break; case HttpMethod.Get: method = Method.GET; break; case HttpMethod.Post: method = Method.POST; break; case HttpMethod.Put: method = Method.PUT; break; case HttpMethod.Delete: method = Method.DELETE; break; case HttpMethod.Head: method = Method.HEAD; break; case HttpMethod.Options: method = Method.OPTIONS; break; case HttpMethod.Patch: method = Method.PATCH; break; case HttpMethod.Merge: method = Method.MERGE; break; case HttpMethod.Copy: method = Method.COPY; break; default: throw new ArgumentException("Unsupported value", nameof(source)); } return(ConvertResult.FromNullable(method)); }
public void Evaluate_InvalidHeaderWithLeadingSeparator_WarningAdded() { var evaluator = new HeaderParameterEvaluator(); var span = new Span <char>(":User-Agent: curl/7.60.0".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Empty(convertResult.Data.Headers); Assert.Equal(1, convertResult.Warnings.Count); }
public void Evaluate_CertificateWithoutPassword_Success() { var evaluator = new CertificateParameterEvaluator(); var span = new Span <char>(@"D:\\cert.p12".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("D:\\cert.p12", convertResult.Data.CertificateFileName); Assert.Null(convertResult.Data.CertificatePassword); }
public void Evaluate_CookieHeader_CookieAdded() { var evaluator = new HeaderParameterEvaluator(); var span = new Span <char>("'Cookie: login=123'".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("login=123", convertResult.Data.CookieValue); Assert.Empty(convertResult.Data.Headers); }
public void Evaluate_InvalidValue_Success() { var evaluator = new FormParameterEvaluator(); var span = new Span <char>("key=\"\\\"".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("key", convertResult.Data.FormData.First().Name); Assert.Equal("\"", convertResult.Data.FormData.First().Content); }
protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var value = commandLine.ReadValue(); if (value.IsEmpty) { convertResult.Warnings.Add("Unable to parse key"); return; } convertResult.Data.KeyFileName = value.ToString(); }
public void Evaluate_EmptyValue_Success() { var evaluator = new FormParameterEvaluator(); var span = new Span <char>("empty=".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("empty", convertResult.Data.FormData.First().Name); Assert.Equal(string.Empty, convertResult.Data.FormData.First().Content); Assert.Equal(UploadDataType.Inline, convertResult.Data.FormData.First().Type); }
public void Evaluate_ValidValue_ParsedCorrectly() { var evaluator = new ProxyCredentialsParameterEvaluator(); var span = new Span <char>("user:pass".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.False(convertResult.Data.UseDefaultProxyCredentials); Assert.Equal("user", convertResult.Data.ProxyUserName); Assert.Equal("pass", convertResult.Data.ProxyPassword); }
protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var certificateTypeString = commandLine.ReadValue().ToString(); if (Enum.TryParse(certificateTypeString, true, out CertificateType certificateType)) { convertResult.Data.CertificateType = certificateType; } else { convertResult.Warnings.Add($"Unable to parse certificate type {certificateTypeString}, PEM type will be used"); convertResult.Data.CertificateType = CertificateType.Pem; } }
protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var value = commandLine.ReadValue().ToString(); if (Enum.TryParse(value, true, out KeyType keyType)) { convertResult.Data.KeyType = keyType; } else { convertResult.Warnings.Add($"Unable to parse key type {value}, PEM type will be used"); convertResult.Data.KeyType = KeyType.Pem; } }
public void Evaluate_InlineFile_Success() { var evaluator = new FormParameterEvaluator(); var span = new Span <char>("story=<hugefile.txt".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("story", convertResult.Data.FormData.First().Name); Assert.Equal("hugefile.txt", convertResult.Data.FormData.First().Content); Assert.Equal(UploadDataType.InlineFile, convertResult.Data.FormData.First().Type); }
public void Evaluate_BinaryFile_Success() { var evaluator = new FormParameterEvaluator(); var span = new Span <char>("[email protected]".ToCharArray()); var convertResult = new ConvertResult <CurlOptions> { Data = new CurlOptions() }; evaluator.Evaluate(ref span, convertResult); Assert.Equal("web", convertResult.Data.FormData.First().Name); Assert.Equal("index.html", convertResult.Data.FormData.First().Content); Assert.Equal(UploadDataType.BinaryFile, convertResult.Data.FormData.First().Type); }
public void AddToResultList(ConvertCommand cmd, ConvertResult result) { string encodingName = "Unchanged"; string lineEndingName = "Unchanged"; if (result == ConvertResult.OK) { encodingName = Program.GetEncodingName(cmd.newEncoding); lineEndingName = Program.GetLineEndingName(cmd.newLineEnding); } resultListView.Items.Add(new ListViewItem(new string[] { cmd.path, encodingName, lineEndingName, result.ToString() })); }
private void Currency2_SelectionChanged(object sender, RoutedEventArgs e) { ConvertResult convertResult = new ConvertResult(); WarningRegex warningRegex = new WarningRegex(); if (RegexClass.RegexSum(Currency2.Text)) { Currency1.Text = convertResult.Result(Currency2.Text, Currency1.Text, Variables.currency2, Variables.currency1); } else { Currency2.Text = warningRegex.Warning(Currency2.Text); } Currency2.SelectionStart = Currency2.Text.Length; }
protected override void EvaluateInner(ref Span <char> commandLine, ConvertResult <CurlOptions> convertResult) { var value = commandLine.ReadValue(); var stringValue = value.ToString(); if (Uri.TryCreate(stringValue, UriKind.Absolute, out var url) || Uri.TryCreate( $"http://{stringValue}", UriKind.Absolute, out url)) { convertResult.Data.Url = url; } else { convertResult.Warnings.Add($"Unable to parse URL \"{stringValue}\""); } }
public void IsConvertingToMp3() { MediaDownloader downloader = new MediaDownloader(); MediaFile mediaFile = MediaFile.CreateNew(VboxDownloadConvertTests.VboxDownloadVideo); string existingPath = Path.Combine(Directory.GetCurrentDirectory(), mediaFile.Metadata.FileName + mediaFile.Metadata.FileExtension); if (!File.Exists(existingPath)) { downloader.Download(mediaFile, Directory.GetCurrentDirectory()); } MediaConverter converter = new MediaConverter(); ConvertResult result = converter.Convert(mediaFile, existingPath, Directory.GetCurrentDirectory(), new MediaConverterMetadata(Bitrates.Kbps192)); Assert.IsTrue(result.IsConverted); Assert.IsTrue(File.Exists(result.ConvertedPath)); }
public ConvertResult Convert() { ConvertResult result = new ConvertResult(); List<CurrencyInfo> sourceDataList = this.GetData(); CurrencyInfo firstData = sourceDataList.First(); List<CurrencyInfo> newDataList = this.Filter(sourceDataList); result.DeviceNumber = firstData.DeviceNumber; result.CollectDate = firstData.OperateTime.ToString("yyyyMMdd"); result.BeforeCount = sourceDataList.Count; result.AfterCount = newDataList.Count; result.TargetFile = "{0}_{1}_{2}_{3}_{4}_{5}.{6}".FormatWith(result.CollectDate, this.BankCode, this.RecordNumber, this.BusinessType, result.AfterCount.ToString().PadLeft(10, '0'), this.FormatVersion, this.FilePostfix); this.Save(newDataList, this.SaveFileFullPath + @"\" + result.TargetFile); return result; }