public async Task <IActionResult> Post([FromBody] ConvertRequest todo)
{
var languages = todo.requestedConversion.Split('2');
string fromLanguage = "C#";
string toLanguage = "Visual Basic";
int fromVersion = 6;
int toVersion = 14;
if (languages.Length == 2)
{
fromLanguage = ParseLanguage(languages[0]);
fromVersion = GetDefaultVersionForLanguage(languages[0]);
toLanguage = ParseLanguage(languages[1]);
toVersion = GetDefaultVersionForLanguage(languages[1]);
}
var codeWithOptions = new CodeWithOptions(todo.code)
.WithTypeReferences(DefaultReferences.NetStandard2)
.SetFromLanguage(fromLanguage, fromVersion)
.SetToLanguage(toLanguage, toVersion);
var result = await ICSharpCode.CodeConverter.CodeConverter.Convert(codeWithOptions);
var response = new ConvertResponse()
{
conversionOk = result.Success,
convertedCode = result.ConvertedCode,
errorMessage = result.GetExceptionsAsString()
};
return(Ok(response));
}
public PdfHtmConverter(ConvertRequest convertRequest)
{
_convertRequest = convertRequest;
var registeredFontCounts = PdfFontFactory.RegisterDirectory(FONT_DIRECTORY);
Console.WriteLine($"Number of the font registered: {registeredFontCounts}");
}
public void SendMessage(ConvertRequest message)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "convert_tasks",
type: "topic",
durable: true);
var routingKey = "convert." + _routingKey.GetRoutingKey(message.Type);
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
channel.BasicPublish(exchange: "convert_tasks",
routingKey: routingKey,
basicProperties: null,
body: body);
//Debug.WriteLine(" [x] Sent '{0}'", routingKey);
}
}
public async Task <FileStreamResult> ExportToPdf(string htmlContent, bool rotate)
{
var pageSize = rotate ? PageSize.A4.Rotate() : PageSize.A4;
var convertRequest = new ConvertRequest
{
Content = htmlContent,
Footer = PdfFormation.PageNumberFooterTemplate
};
var pdfConverter = new PdfHtmConverter(convertRequest);
var memoryStream = pdfConverter.ManipulatePdf(pageSize);
var guid = Guid.NewGuid();
var outputFilePath = $"report_{guid}.pdf";
var finalOutputFilePath = $"final_report_{guid}.pdf";
await PdfFileWriter.SaveToFile(memoryStream, outputFilePath);
_logger.LogInformation($"Saved pdf file {outputFilePath}");
pdfConverter.DecoratePdf(outputFilePath, finalOutputFilePath);
var response = PdfFileReader.ReadFrom(finalOutputFilePath);
FileOperator.Delete(outputFilePath);
_logger.LogInformation($"Deleted pdf file {outputFilePath}");
FileOperator.Delete(finalOutputFilePath);
_logger.LogInformation($"Deleted pdf file {finalOutputFilePath}");
return(new FileStreamResult(response, "application/pdf"));
}
public static async Task <ConvertResponse> ConvertAsync(ConvertRequest todo)
{
var languages = todo.requestedConversion.Split('2');
string fromLanguage = LanguageNames.CSharp;
string toLanguage = LanguageNames.VisualBasic;
int fromVersion = 6;
int toVersion = 14;
if (languages.Length == 2)
{
fromLanguage = ParseLanguage(languages[0]);
fromVersion = GetDefaultVersionForLanguage(languages[0]);
toLanguage = ParseLanguage(languages[1]);
toVersion = GetDefaultVersionForLanguage(languages[1]);
}
var codeWithOptions = new CodeWithOptions(todo.code)
.WithTypeReferences(DefaultReferences.NetStandard2)
.SetFromLanguage(fromLanguage, fromVersion)
.SetToLanguage(toLanguage, toVersion);
var result = await CodeConverter.ConvertAsync(codeWithOptions);
return(new ConvertResponse(result.Success, result.ConvertedCode, result.GetExceptionsAsString()));
}
public void Convert()
{
// Упорядочение
using (ConverterController controller = new ConverterController(new MediaProvider(Directory.GetCurrentDirectory(), null), null))
{
controller.Configuration = new HttpConfiguration();
controller.Request = new HttpRequestMessage();
HttpResponseMessage result = controller.Convert(new ConvertRequest()
{
Data = File.ReadAllBytes(Path.Combine(Directory.GetCurrentDirectory(), "demo.wav")),
InFormat = "wav",
OutFormat = "mp3"
}).Result;
// Утверждение
Assert.AreEqual(result.StatusCode, HttpStatusCode.OK);
string content = result.Content.ReadAsStringAsync().Result;
ConvertRequest convertRequest = JsonConvert.DeserializeObject <ConvertRequest>(content);
Assert.IsNotNull(convertRequest?.Data);
}
// Действие
}
/// <summary>
/// Converts the requested file to a designated format.
/// </summary>
/// <param name="request"><c>ConvertRequest</c> object.</param>
/// <param name="convertUrl">Process URL to convert.</param>
/// <returns></returns>
public async Task <ConvertResponse> ConvertAsync(ConvertRequest request, string convertUrl)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if (String.IsNullOrWhiteSpace(convertUrl))
{
throw new ArgumentNullException("convertUrl");
}
var serialised = this.Serialise(request);
ConvertResponse deserialised;
using (var client = new HttpClient())
using (var content = new StringContent(serialised, Encoding.UTF8, "application/json"))
using (var response = await client.PostAsync(convertUrl, content))
{
var result = await response.Content.ReadAsStringAsync();
if (response.StatusCode != HttpStatusCode.OK)
{
var error = this.Deserialise <ErrorResponse>(result);
throw new ErrorResponseException(error);
}
deserialised = this.Deserialise <ConvertResponse>(result);
deserialised.Code = (int)response.StatusCode;
}
return(deserialised);
}
public async Task <HttpResponseMessage> ConvertString(string fromCurrency, string toCurrency, decimal amount)
{
var request = new ConvertRequest {
Amount = amount, FromCurrency = fromCurrency, ToCurrency = toCurrency
};
return(await this.ProcessActionAsync(request, this.currencyService.Convert));
}
/// <summary>
/// returns the conversion rate for given crypto
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public async override Task <ConvertResponse> Get(ConvertRequest request, ServerCallContext context)
{
var mappedRequest = _mapper.Map <Crypto>(request);
var convrtResult = await _webExchangeRepository.GetRate(mappedRequest.Name);
var result = _mapper.Map <ConvertResponse>(convrtResult);
return(result);
}
public ConvertResponse GetBySymbol(ConvertRequest request)
{
var currencyRate = _currencyRateRepository.GetBySymbol(request.From, request.To);
return(new ConvertResponse {
Success = true,
Rate = currencyRate.Rate
});
}
public override async Task <ConvertReply> Convert(ConvertRequest request, ServerCallContext context)
{
var data = await _generator.Generate(request.Data.ToStringUtf8());
return(await Task.FromResult(new ConvertReply
{
Data = ByteString.CopyFrom(data),
ResultStatus = ResultStatus.Success
}));
}
public async Task <IActionResult> Fahrenheit(ConvertRequest model)
{
var res = await _temp.CelsiusToFahrenheitAsync(model.Value);
return(Ok(new
{
Success = true,
Temp = $"{model.Value} degrees celsius is == to {res} degrees fahrenheit"
}));
}
public IActionResult List([FromBody] ViewParam param)
{
var result = new ResultModel();
return(this.Wrapper(ref result, () =>
{
var listParam = ConvertRequest.Convert(param, dic);
result = _blogCommentRepository.GetPageResult <BlogCommentVModel>(listParam);
}, false));
}
public IActionResult List([FromBody] ViewParam viewParam)
{
var result = new ResultModel(200);
return(Wrapper(ref result, () =>
{
var listParam = ConvertRequest.Convert(viewParam, dicVip);
result = _vipService.GetViewPager(listParam);
}, false));
}
public IActionResult List([FromBody] ViewParam param)
{
var result = new ResultModel();
return(this.Wrapper(ref result, () =>
{
var listParm = ConvertRequest.Convert(param, dic);
result = _userRepository.GetPageResult <UserVModel>(listParm);
}, true));
}
public HttpResponseMessage Post(ConvertRequest request)
{
try
{
if (request == null || String.IsNullOrWhiteSpace(request.Url))
{
throw new ArgumentNullException("url");
}
var result = _converter.Convert(request.Url);
//var audio = new AudioStream(result.FileName);
var response = new HttpResponseMessage(HttpStatusCode.OK);
var fileStream = File.Open(result.FileName, FileMode.Open, FileAccess.Read);
var memStream = new MemoryStream();
fileStream.CopyTo(memStream);
response.Content = new ByteArrayContent(memStream.Write)
response.Content.Headers.ContentType = new MediaTypeHeaderValue("audio/mp4");
//response.Content = new PushStreamContent((outputStream, content, context) =>
//{
// try
// {
// var buffer = new byte[65536];
// using (var audioFile = File.Open(result.FileName, FileMode.Open, FileAccess.Read))
// {
// audioFile.CopyTo(outputStream);
// //var length = (int)audioFile.Length;
// //var bytesRead = 1;
// //while (length > 0 && bytesRead > 0)
// //{
// // bytesRead = audioFile.ReadAsync(buffer, 0, Math.Min(length, buffer.Length));
// // await outputStream.WriteAsync(buffer, 0, bytesRead);
// // length -= bytesRead;
// //}
// outputStream.Flush();
// }
// }
// catch (Exception ex)
// {
// throw new Exception("An error occurred while trying to create audio stream from video file.", ex);
// }
// finally
// {
// outputStream.Close();
// }
//}, new MediaTypeHeaderValue("audio/mp4"));
return(response);
}
catch (Exception ex)
{
var ret = new HttpResponseMessage(HttpStatusCode.InternalServerError);
ret.Content = new StringContent(ex.ToString());
return(ret);
}
}
private static void PrintConvertRequest(ConvertRequest convertRequest)
{
if (convertRequest == null)
{
Console.WriteLine("ConvertRequest should not be null");
return;
}
Console.WriteLine("======== JSon Request Body =======");
Console.WriteLine(convertRequest.ToJson());
Console.WriteLine("==================================");
}
public void ConvertShouldCrash(string from, string to, decimal amount)
{
var input = new ConvertRequest {
Amount = amount, FromCurrency = from, ToCurrency = to
};
var result = this.service.Convert(input);
Assert.Multiple(() =>
{
Assert.IsTrue(result.Status == TaskStatus.Faulted);
Assert.IsTrue(result.Exception != null);
});
}
public IHttpActionResult Post([FromBody] ConvertRequest todo)
{
string code = todo.code;
var response = new ConvertResponse()
{
conversionOk = false,
convertedCode = "",
errorMessage = "Not implemented"
};
return(Ok(response));
}
public static async Task <HttpResponseMessage> HttpStart(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] ConvertRequest request,
[OrchestrationClient] DurableOrchestrationClient starter,
ILogger log)
{
var instanceId = await starter.StartNewAsync(nameof(RunOrchestrator), request);
log.LogInformation($"Started orchestration with ID = '{instanceId}'.");
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(instanceId)
});
}
public void Execute(ConvertRequestLog requestLog)
{
ConvertRequest data = new ConvertRequest
{
ConvertRequestId = requestLog.RequestId,
RequestDateUtc = requestLog.RequestDateUtc,
SenderIp = requestLog.SenderIp,
FileExtension = requestLog.FileExtension,
FileSize = requestLog.FileSize,
FileType = this.convertLogRepository.GetFileTypeByExtension(requestLog.FileExtension),
CustomAttributes = requestLog.CustomAttributes == null ? null : string.Join(";", requestLog.CustomAttributes.Select(p => $"{p.Key}=\"{p.Value}\""))
};
this.convertLogRepository.CreateConvertRequest(data);
}
public void ConvertShouldReturnConvertedValue(string from, string to, decimal amount, decimal expected)
{
var input = new ConvertRequest {
Amount = amount, FromCurrency = from, ToCurrency = to
};
var result = this.service.Convert(input);
Assert.Multiple(() =>
{
Assert.NotNull(result);
Assert.NotNull(result.Result);
Assert.IsTrue(result.Status == TaskStatus.RanToCompletion);
Assert.AreEqual(Math.Round(expected, 6, MidpointRounding.ToEven), Math.Round(result.Result, 6, MidpointRounding.ToEven));
});
}
/// <summary> Call GetConvertAsync which internally use Http Get to get data form Symbology Conversion service</summary>
/// <param name="symbologyData">EDPSymbologyClient object</param>
/// <param name="appConfig"> appConfig object to verify option tot print Json request message </param>
/// <param name="convertRequest"> ConvertRequest object contains request values</param>
/// <param name="cts"> CancellationTokenSource object </param>
public static Symbology SymbologyConvertGet(EDPSymbologyClient symbologyClient,
ConvertRequest convertRequest,
Config appConfig,
CancellationTokenSource cts)
{
if (appConfig.Verbose)
{
PrintConvertRequest(convertRequest);
}
var symbolResult = symbologyClient.GetConvertAsync(string.Join(',', convertRequest.Universe),
convertRequest.To, Format.NoMessages, cts.Token)
.GetAwaiter().GetResult();
return(symbolResult);
}
public IActionResult List([FromBody] ViewParam param)
{
var result = new ResultModel();
return(this.Wrapper(ref result, () =>
{
var listparam = ConvertRequest.Convert(param, dicBlog);
if (param.Filter?.Exists(x => x.Field == "tagId") ?? false)
{
var tagId = param.Filter.FirstOrDefault(x => x.Field == "tagId").Value;
var blogTags = _tagRepository.GetBlogByTagIds(new List <int>()
{
int.Parse(tagId)
});
if (blogTags != null && blogTags.Count > 0)
{
listparam.Filter.Add(new FilterModel()
{
Field = "id",
DbField = "Id",
Connector = "and ",
Operator = "in",
Value = string.Join(",", blogTags.Select(x => x.BlogId))
});
}
else
{
return;
}
}
var r = _blogRepository.GetPageResult <BlogVModel>(listparam);
var categroys = _categoryRepository.GetInUse();
var author = _authorRepository.GetById(1);
var tags = _tagRepository.GetByBlogIds(r.TModel?.Select(x => x.id)?.ToList());
r.TModel?.ForEach(ea =>
{
ea.categoryName = categroys?.FirstOrDefault(x => x.Id == ea.categoryId)?.Name;
ea.authorName = author?.Name;
ea.tags = tags?.FindAll(x => x.BlogId == ea.id)?.Select(x => new TagVModel()
{
tagId = x.TagId, tagName = x.TagName
}).ToList();
});
result = r;
}, false));
}
/// <summary> Call PostConvertAsync which internally use Http Post to get data form Symbology Conversion service</summary>
/// <param name="symbologyData">EDPSymbologyClient object</param>
/// <param name="appConfig"> appConfig object to verify option tot print Json request message </param>
/// <param name="convertRequest"> ConvertRequest object contains request values</param>
/// <param name="cts"> CancellationTokenSource object </param>
public static Symbology SymbologyConvertPost(EDPSymbologyClient symbologyClient,
ConvertRequest convertRequest,
Config appConfig,
CancellationTokenSource cts)
{
if (appConfig.Verbose)
{
PrintConvertRequest(convertRequest);
}
var symbologyResponse =
symbologyClient.PostConvertAsync(convertRequest, Format.NoMessages, cts.Token).GetAwaiter().GetResult() ??
throw new ArgumentNullException(
ParamName);
return(symbologyResponse);
}
public async Task <ConvertResponse> Convert(ConvertRequest request)
{
try
{
FindCurrencyRequest finCurrencyRequest = new FindCurrencyRequest
{
Currencies = new CurrencyIdentifier[] { request.From, request.To }
};
var findCurrencyResponse = await currencyService.FindCurrency(finCurrencyRequest);
if (findCurrencyResponse.Success)
{
var from = findCurrencyResponse.Currencies[0];
var to = findCurrencyResponse.Currencies[1];
var value = from.ConverterToOtherCurrency(to, request.Amount);
return(new ConvertResponse
{
Success = true,
Amount = request.Amount,
From = from,
To = to,
Value = value
});
}
return(new ConvertResponse
{
Success = false,
Error = findCurrencyResponse.Error
});
}
catch (Exception e)
{
return(new ConvertResponse
{
Success = false,
Error = new Error
{
Message = e.Message,
Type = "Unspected"
}
});
}
}
public async Task <IActionResult> Post(ConvertRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var task = new ConvertBackgroundTask
{
Title = request.Title,
SourcePath = request.SourcePath,
DestinationPath = request.DestinationPath
};
var handler = new ConvertBackgroundTaskHandler(loggerFactory, progressHubContext);
await backgroundTaskQueue.QueueBackgroundWorkItemAsync(handler.Handle, task);
return(Ok());
}
private static void DumpAppConfig(Config appConfig, ConvertRequest convertRequest)
{
if (convertRequest == null || appConfig == null)
{
Console.WriteLine("Unable to print configuration because Config or ConvertRequest object is null");
return;
}
Console.WriteLine("========= Application Configuration List =============");
Console.WriteLine("Universe:{0}",
convertRequest.Universe != null ? string.Join(",", convertRequest.Universe) : "");
Console.WriteLine("ToEnum:{0}",
(convertRequest.To != null) && (convertRequest.To.Count > 0) ? string.Join(",", convertRequest.To) : "No valid field list pass to application, returns all fields instead");
Console.WriteLine($"Use Json File:{appConfig.JsonRequestFile} {appConfig.UseJsonRequestFile}");
Console.WriteLine($"Export to CSV File:{appConfig.CsvFilePath} {appConfig.ExportToCSV} ");
if (!string.IsNullOrEmpty(appConfig.AccessToken))
{
Console.WriteLine($"Username or Client ID (hidden):{appConfig.Username}");
}
if (!string.IsNullOrEmpty(appConfig.AccessToken))
{
Console.WriteLine($"AccessToken(hidden):{appConfig.AccessToken}");
}
if (!string.IsNullOrEmpty(appConfig.RefreshToken))
{
Console.WriteLine($"RefreshToken(hidden):{appConfig.RefreshToken}");
}
if (!string.IsNullOrEmpty(appConfig.SymbologyBaseURL))
{
Console.WriteLine($"Symbology Base URL(hidden):{appConfig.SymbologyBaseURL}");
}
if (!string.IsNullOrEmpty(appConfig.AuthBaseURL))
{
Console.WriteLine($"Authorization Base URL(hidden):{appConfig.AuthBaseURL}");
}
if (!string.IsNullOrEmpty(appConfig.ProxyServer))
{
Console.WriteLine($"ProxyServer(hidden):{appConfig.ProxyServer}");
}
Console.WriteLine($"UseProxyServer(hidden):{appConfig.UseProxyServer}");
Console.WriteLine("======================================================");
}
public async Task <StatusResponse> ConvertAsync(InputParameters input, OutputParameters output, ConversionParameters conversion)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (output == null)
{
throw new ArgumentNullException("output");
}
if (conversion == null)
{
throw new ArgumentNullException("conversion");
}
var process = await this.CreateProcessAsync(input.InputFormat, conversion.OutputFormat);
var request = new ConvertRequest()
{
InputMethod = input.InputMethod,
Filepath = input.Filepath,
Filename = input.Filename,
Tag = input.Tag,
DownloadMethod = output.DownloadMethod,
Email = output.Email,
CallbackUrl = output.CallbackUrl,
Wait = output.Wait,
SaveToServer = output.SaveToServer,
OutputStorage = output.OutputStorage,
OutputFormat = conversion.OutputFormat,
ConverterOptions = conversion.ConverterOptions,
PresetId = conversion.PresetId,
Timeout = conversion.Timeout,
};
return(await this.SendAsync <StatusResponse>(process.Url, request));
}
public IActionResult List([FromBody] ViewParam param)
{
var result = new ResultModel();
return(this.Wrapper(ref result, () =>
{
var listparam = ConvertRequest.Convert(param, dicPhotoAlbum);
listparam.Filter.Add(new FilterModel()
{
Field = "userId",
DbField = "a.UserId",
Connector = "and",
Operator = "=",
Value = _claimEntity.userId.ToString()
});
var r = _photoAlbumRepository.GetPageResult <PhotoAlbumVModel>(listparam);
result = r;
}, false));
}
private void DisplayCSharpOrVBFile(string codeFileText)
{
RadTabControl tabControl = this.CodeContentTemplate.LoadContent() as RadTabControl;
// make sure tabcontrol is styled with win8 theme, as this bug regresses often
ApplicationThemeManager.EnsureFrameworkElementResourcesForTheme(tabControl, "Windows8");
RadCodeEditor codeViewer = this.PrepareCodeViewerForCSharpCode(tabControl, codeFileText);
// prepare C# tab
var tabCSharp = tabControl.Items[0] as RadTabItem;
tabCSharp.Content = codeViewer;
// prepare VB.NET tab
RadSelectionChangedEventHandler selectionChangedEventHandler = null;
RoutedEventHandler unloadedHandler = null;
unloadedHandler = (sender, args) =>
{
(sender as RadTabControl).Unloaded -= unloadedHandler;
(sender as RadTabControl).SelectionChanged -= selectionChangedEventHandler;
};
selectionChangedEventHandler = (sender, args) =>
{
if (tabControl.SelectedIndex == 1)
{
tabControl.SelectionChanged -= selectionChangedEventHandler;
using (ConvertServiceSoapClient service = new ConvertServiceSoapClient("ConvertServiceSoap"))
{
var requestBody = new ConvertRequestBody("cs2vbnet", codeFileText);
var request = new ConvertRequest(requestBody);
EventHandler<ConvertCompletedEventArgs> convertCompleted = null;
convertCompleted = (s, e) =>
{
service.ConvertCompleted -= convertCompleted;
string convertedCode = e.Result.Body.ConvertedCode.Replace("\t", " ").Replace("\n", "\r\n");
var codeEditor = tabControl.ItemTemplate.LoadContent() as RadCodeEditor;
codeEditor.Document = e.Error == null ? new TextDocument(convertedCode) : new TextDocument(e.Error.Message);
this.PrepareSyntaxHighlighting(codeEditor, "vb");
var vbTab = tabControl.Items[1] as RadTabItem;
vbTab.Content = codeEditor;
};
service.ConvertCompleted += convertCompleted;
service.ConvertAsync(request);
}
}
};
tabControl.SelectionChanged += selectionChangedEventHandler;
tabControl.Unloaded += unloadedHandler;
if (ApplicationOptions.DefaultCodeViewerLanguage == CodeViewerLanguages.VB)
{
tabControl.SelectedIndex = 1;
}
this.Content = tabControl;
}
