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;
}
