public async Task <IActionResult> GetConversion(string from, double quantity, string to)
{
try
{
var conversionRequest = new ConversionRequest
{
From = from,
Quantity = quantity,
To = to
};
ConversionResult response = await _conversionClient.GetConversionAsync(conversionRequest);
return(Ok(response));
}
catch (ArgumentNullException e)
{
_logger.LogInformation(e.Message);
return(BadRequest(e.Message));
}
catch (RpcException e)
{
_logger.LogInformation(e.Message);
return(NotFound(e.Status.Detail));
}
}
public void CanRetrieveSavedConversionRequest()
{
var network = new SmartContractsPoARegTest();
var dataFolder = TestBase.CreateDataFolder(this, network: network);
var serializer = new DBreezeSerializer(network.Consensus.ConsensusFactory);
var kvs = new ConversionRequestKeyValueStore(dataFolder, serializer);
var repo = new ConversionRequestRepository(kvs);
var request = new ConversionRequest()
{
RequestId = "requestId",
RequestType = ConversionRequestType.Mint,
Processed = false,
RequestStatus = ConversionRequestStatus.Unprocessed,
Amount = 100000000,
BlockHeight = 123,
DestinationAddress = ""
};
repo.Save(request);
var request2 = repo.Get(request.RequestId);
Assert.Equal(request.RequestId, request2.RequestId);
Assert.Equal(request.RequestType, request2.RequestType);
Assert.Equal(request.Processed, request2.Processed);
Assert.Equal(request.RequestStatus, request2.RequestStatus);
Assert.Equal(request.Amount, request2.Amount);
Assert.Equal(request.BlockHeight, request2.BlockHeight);
Assert.Equal(request.DestinationAddress, request2.DestinationAddress);
}
public override Task <ConversionReply> ConvertShoeSize(ConversionRequest request, ServerCallContext context)
{
return(Task.FromResult(new ConversionReply
{
Size = (Gender)request.Gender == Gender.Women ? ConvertWomenShoeSize(request.Size) : ConvertMenShoeSize(request.Size)
}));
}
public override async Task <ConversionResult> GetConversion(ConversionRequest request, ServerCallContext context)
{
ConversionResult baseConversion;
try
{
baseConversion = await GetBaseConversion(request.From, request.Quantity);
}
catch (RpcException e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
throw new RpcException(e.Status);
}
ConversionResult conversionResult;
try
{
conversionResult = await GetConversionResult(baseConversion, request.To);
}
catch (RpcException e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
throw new RpcException(e.Status);
}
return(conversionResult);
}
DownloadConversionFilesResult DownloadConversionFiles(ConversionRequest request, string storageConnString, string decryptKey)
{
if (string.IsNullOrEmpty(decryptKey))
{
var msg = "AESKEY to encrypt/decrypt file is required.";
return(DownloadConversionFilesResult.FailFast(msg));
}
try
{
var primaryFileContent = BlobHelper.DownloadFileToArrayByte(storageConnString, request.containerName, request.blobHeaderName, decryptKey);
if (primaryFileContent == null)
{
var msg = $"Can't find the content of the BLOB file [{request.blobHeaderName}].";
DownloadConversionFilesResult.FailFast(msg);
}
byte[] remittanceFileContent = null;
if (!string.IsNullOrEmpty(request.blobDetailName))
{
remittanceFileContent = BlobHelper.DownloadFileToArrayByte(storageConnString, request.containerName, request.blobDetailName, decryptKey);
}
return(DownloadConversionFilesResult.Successful(primaryFileContent, remittanceFileContent));
}
catch (ApplicationException ex)
{
_logger.Error(ex.ToString());
return(DownloadConversionFilesResult.FailFast(ex.Message));
}
}
bool ValidateRequest(ConversionRequest request, out string msg)
{
msg = string.Empty;
if (request == null)
{
msg = "[blobHeaderName, blobOutputName, containerName] are required.";
return(false);
}
request.containerName = request.containerName?.Trim();
request.blobHeaderName = request.blobHeaderName?.Trim();
request.blobOutputName = request.blobOutputName?.Trim();
if (string.IsNullOrEmpty(request.blobHeaderName))
{
msg = "Blob file input is required.";
return(false);
}
if (string.IsNullOrEmpty(request.blobOutputName))
{
msg = "Blob file output is required.";
return(false);
}
if (string.IsNullOrEmpty(request.containerName))
{
msg = "Blob container is required.";
return(false);
}
return(true);
}
public void Should_not_find_path_with_currencies_in_two_unconnected_graphs()
{
// ARRANGE
// two unconnected graphs : EUR-ARS-UAH and CHF-RON-USD-BGN-JPY
List <ExchangeRate> exchangeRates = new List <ExchangeRate> {
new ExchangeRate("RON", "CHF", 0.2322m),
new ExchangeRate("USD", "RON", 4.2841m),
new ExchangeRate("USD", "CHF", 0.9946m),
new ExchangeRate("EUR", "ARS", 65.9057m),
new ExchangeRate("ARS", "UAH", 0.4229m),
new ExchangeRate("UAH", "EUR", 0.0359m),
new ExchangeRate("BGN", "JPY", 61.8563m),
new ExchangeRate("BGN", "USD", 0.5677m)
};
var conversionRequest = new ConversionRequest("ARS", "JPY", 35);
var mock = new Mock <IDijkstraService <string> >();
mock.Setup(m => m.GetShortestPath(It.IsAny <Vertex <string> >(), It.IsAny <Vertex <string> >(), It.IsAny <Graph <string> >()))
.Returns(new Dijkstra.Result.DijkstraShortestPathResult <string>(false, null));
var svc = new DijkstraAdapter(mock.Object);
// ACT
var result = svc.Get(conversionRequest, exchangeRates);
// ASSERT
result.IsFound.Should().BeFalse();
result.Path.Should().BeNull();
}
/// <summary>
/// Resolves the best media streams for the specified video, downloads them and processes into a single file.
/// </summary>
public static async ValueTask DownloadAsync(
this VideoClient videoClient,
VideoId videoId,
ConversionRequest request,
IProgress <double>?progress = null,
CancellationToken cancellationToken = default)
{
public ShortestPathResult Get(ConversionRequest conversionRequest, IEnumerable <ExchangeRate> exchangeRates)
{
var graph = ToGraph(exchangeRates);
Vertex <string> vSource = new Vertex <string>(conversionRequest.SourceCurrency);
Vertex <string> vTarget = new Vertex <string>(conversionRequest.TargetCurrency);
var result = _dijkstraService.GetShortestPath(vSource, vTarget, graph);
return(ToShortestPathResult(result));
}
public override void HandleConversion(ConversionRequest currentRequest)
{
if (currentRequest.Unit == "Mile")
{
currentRequest.Output = currentRequest.Input * 0.621371;
}
else
{
successor.HandleConversion(currentRequest);
}
}
public override void HandleConversion(ConversionRequest currentRequest)
{
if (currentRequest.Unit == "Foot")
{
currentRequest.Output = currentRequest.Input * 3280.84;
}
else
{
successor.HandleConversion(currentRequest);
}
}
public override void HandleConversion(ConversionRequest currentRequest)
{
if (currentRequest.Unit == "Yard")
{
currentRequest.Output = currentRequest.Input * 1093.61;
}
else
{
successor.HandleConversion(currentRequest);
}
}
public ActionResult <ConversionRequest> GetExample()
{
ConversionRequest request = new ConversionRequest();
request.FromUnitId = 1;
request.ToUnitId = 2;
request.TypeId = 3;
request.Value = 4;
return(request);
}
/// <summary>
/// Downloads specified media streams and processes them into a single file.
/// </summary>
public static async ValueTask DownloadAsync(
this VideoClient videoClient,
IReadOnlyList <IStreamInfo> streamInfos,
ConversionRequest request,
IProgress <double>?progress = null,
CancellationToken cancellationToken = default) =>
await videoClient.DownloadAsync(
streamInfos,
Array.Empty <ClosedCaptionTrackInfo>(),
request,
progress,
cancellationToken
);
public Conversion CreateConversion(ConversionRequest conversionRequest, bool?overrideMaxCookieTime)
{
var url = GetRequestUrl("/conversions/");
if (overrideMaxCookieTime != null)
{
url = AddQueryStringToUrl(url, "override_max_cookie_time", Convert.ToString(overrideMaxCookieTime));
}
var payLoad = JsonConvert.SerializeObject(conversionRequest);
var response = HttpClient.PostAsync(url, new StringContent(payLoad)).Result;
return(GetResponse <Conversion>(response));
}
public static ConversionRequest convert(string from, string to, float amount)
{
var convertionRequest = new ConversionRequest();
var data = DataSetup.setUpDummyData();
var rate = data.First(x => x.currencyCode == from).convertionRate.First(x => x.currencyTo == to).rate;
convertionRequest.currencyFrom = from;
convertionRequest.currencyTo = to;
convertionRequest.rate = rate;
convertionRequest.amountToChange = amount;
convertionRequest.amountConverted = amount * rate;
return(convertionRequest);
}
public IHttpActionResult Index(ConversionRequest model)
{
var request = new ConversionInfo {
Amount = model.Amount, Name = model.Name
};
var result = _amountToTextService.Convert(request);
if (result == null)
{
// or internal server ?
return(BadRequest());
}
else
{
return(Ok(result));
}
}
public ActionResult <ConversionRespond> Get([FromQuery] ConversionRequest request)
{
try
{
var output = _converter.AmountToString(request.Amount);
return(Ok(new ConversionRespond
{
Name = request.Name,
AmountString = output
}));
}
catch (Exception e)
{
// TODO log here
// log...
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public ConversionResult Convert(ConversionRequest request, IEnumerable <ExchangeRate> exchangeRates)
{
var shorterPathResult = _shortestPathService.Get(request, exchangeRates);
if (shorterPathResult.IsFound)
{
// Process the conversion request
var convertedAmount = ApplyRates(request.Amount, exchangeRates, shorterPathResult.Path.ToList());
// round
convertedAmount = Math.Round(convertedAmount, MidpointRounding.AwayFromZero);
return(new ConversionResult(true, Decimal.ToInt32(convertedAmount)));
}
else
{
return(new ConversionResult(false, null, ConversionErrorMessage.NoPath));
}
}
static async Task Main(string[] args)
{
var httpClientHandler = new HttpClientHandler();
httpClientHandler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
var httpClient = new HttpClient(httpClientHandler);
var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions {
HttpClient = httpClient
});
var client = new ShoeSizeConversion.ShoeSizeConversionClient(channel);
var conversionRequest = new ConversionRequest {
Size = 11.5, Gender = ConversionRequest.Types.Gender.Women
};
var conversionReply = await client.ConvertShoeSizeAsync(conversionRequest);
Console.WriteLine($"{conversionRequest.Size} {conversionRequest.Gender} US → {conversionReply.Size} EU");
Console.ReadKey();
}
/// <summary>
/// Downloads specified media streams and closed captions and processes them into a single file.
/// </summary>
public static async ValueTask DownloadAsync(
this VideoClient videoClient,
IReadOnlyList <IStreamInfo> streamInfos,
IReadOnlyList <ClosedCaptionTrackInfo> closedCaptionTrackInfos,
ConversionRequest request,
IProgress <double>?progress = null,
CancellationToken cancellationToken = default)
{
var ffmpeg = new FFmpeg(request.FFmpegCliFilePath);
var converter = new Converter(videoClient, ffmpeg, request.Preset);
await converter.ProcessAsync(
request.OutputFilePath,
request.Container,
streamInfos,
closedCaptionTrackInfos,
progress,
cancellationToken
);
}
public void Should_conversion_EUR_USD_49_fail_with_not_connected_currencies()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesNotConnected;
var conversionRequest = new ConversionRequest("USD", "UAH", 1);
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(false, null));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeFalse();
result.Amount.Should().BeNull();
result.ErrorMessage.Should().Be(ConversionErrorMessage.NoPath);
}
internal MessageResponse ProcessRequest(ConversionRequest request)
{
string errorMsg;
if (!ValidateRequest(request, out errorMsg))
{
return(MessageResponse.info(errorMsg));
}
try
{
var storageConnString = AzureKeyVaultProvider.StorageConnectionString;
var decryptKey = AzureKeyVaultProvider.AESKeyBLOB;
//download file
var downloadResult = DownloadConversionFiles(request, storageConnString, decryptKey);
if (!downloadResult.Success)
{
return(MessageResponse.info(downloadResult.ErrorMessage));
}
_psTool.SetCurrentConversionRequest(request);
var sbStandardFile = _psTool.ProcessDataFile(downloadResult.PrimaryFileContent, downloadResult.RemittanceFileContent);
var listErrors = _psTool.GetErrors();
if (listErrors.Any())
{
return(MessageResponse.error(listErrors));
}
BlobHelper.UploadFile(storageConnString, request.containerName, request.blobOutputName, sbStandardFile, decryptKey);
return(MessageResponse.ok(request.blobOutputName));
}
catch (Exception ex)
{
_logger.Error(ex.ToString());
return(MessageResponse.error(ex.Message));
}
}
public void Should_find_path_with_currencies_in_connected_graph()
{
// ARRANGE
List <ExchangeRate> exchangeRates = new List <ExchangeRate> {
new ExchangeRate("EUR", "CHF", 1.1046m),
new ExchangeRate("RON", "CHF", 0.2322m),
new ExchangeRate("USD", "RON", 4.2841m),
new ExchangeRate("USD", "CHF", 0.9946m),
new ExchangeRate("EUR", "ARS", 65.9057m),
new ExchangeRate("ARS", "UAH", 0.4229m),
new ExchangeRate("UAH", "EUR", 0.0359m),
new ExchangeRate("BGN", "UAH", 14.2381m),
new ExchangeRate("BGN", "JPY", 61.8563m),
new ExchangeRate("BGN", "USD", 0.5677m)
};
var conversionRequest = new ConversionRequest("ARS", "JPY", 35);
var mock = new Mock <IDijkstraService <string> >();
mock.Setup(m => m.GetShortestPath(It.IsAny <Vertex <string> >(), It.IsAny <Vertex <string> >(), It.IsAny <Graph <string> >()))
.Returns(new Dijkstra.Result.DijkstraShortestPathResult <string>(true,
new List <Vertex <string> > {
new Vertex <string>("ARS"),
new Vertex <string>("UAH"),
new Vertex <string>("BGN"),
new Vertex <string>("JPY")
}.AsEnumerable()));
var svc = new DijkstraAdapter(mock.Object);
// ACT
var result = svc.Get(conversionRequest, exchangeRates);
// ASSERT
result.IsFound.Should().BeTrue();
result.Path.Should().BeEquivalentTo(new[] { "ARS", "UAH", "BGN", "JPY" }, options => options.WithStrictOrdering());
}
public override async Task <Unit> Handle(GetRateAction aGetRateAction, CancellationToken aCancellationToken)
{
var conversionRequest = new ConversionRequest()
{
FromCurrency = aGetRateAction.FromCurrency, ToCurrency = aGetRateAction.ToCurrency
};
string uri = $"{ConversionRequest.Route}?{conversionRequest.ToQueryString()}";
ConversionResponse conversionResponse = await HttpClient.GetJsonAsync <ConversionResponse>(uri);
Conversion?conversion = RateState.Conversions.FirstOrDefault
(
aConversion => aConversion.FromCurrency == aGetRateAction.FromCurrency &&
aConversion.ToCurrency == aGetRateAction.ToCurrency
);
RateState._Conversions.Remove(conversion);
RateState._Conversions.Add(new Conversion(
conversionRequest.FromCurrency,
conversionRequest.ToCurrency,
conversionResponse.Rate));
return(Unit.Value);
}
public void Should_conversion_45_EUR_return_50_USD_with_connected_currencies()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesConnected;
var conversionRequest = new ConversionRequest("EUR", "USD", 45);
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(true, new List <string> {
"EUR", "CHF", "USD"
}.AsEnumerable()));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeTrue();
result.Amount.Should().Be(50);
result.ErrorMessage.Should().BeNull();
}
public ConversionResponse ConvertTubeToTune(ConversionRequest ConversionRequest)
{
if (ConversionRequest == null)
{
throw new AudioExtractionException("Please enter a YouTube link.");
}
IList <VideoConversionErrorDetailsDto> conversionErrors = new List <VideoConversionErrorDetailsDto>();
IList <string> convertedVideoLinks = new List <string>();
foreach (VideoConversionDetailsDto videoConversionDetail in ConversionRequest.VideoConversionDetails)
{
try
{
IEnumerable <VideoInfo> videoInfos = DownloadUrlResolver.GetDownloadUrls(videoConversionDetail.VideoLink, false);
VideoInfo video = videoInfos
.Where(info => info.CanExtractAudio)
.OrderByDescending(info => info.AudioBitrate)
.First();
string convertedAudioFileName = FileNameGenerationHelper.RemoveIllegalPathCharacters(video.Title) + video.AudioExtension;
convertedVideoLinks.Add(convertedAudioFileName);
if (video.RequiresDecryption)
{
DownloadUrlResolver.DecryptDownloadUrl(video);
}
new AudioDownloader(video, Path.Combine(HttpContext.Current.Server.MapPath("~/App_Data"), convertedAudioFileName)).Execute();
}
catch (Exception e) { conversionErrors.Add(BuildVideoConversionError(e.Message, videoConversionDetail.VideoId)); }
}
return(BuildConversionResponse(convertedVideoLinks, conversionErrors, ConversionRequest.VideoConversionDetails.Count()));
}
public void Should_conversion_550_EUR_return_59033_JPY_with_connected_currencies_of_exam_instructions()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesOfExamInstructions;
var conversionRequest = new ConversionRequest("EUR", "JPY", 550);
// create dependency mock
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(true, new List <string> {
"EUR", "CHF", "AUD", "JPY"
}.AsEnumerable()));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeTrue();
result.Amount.Should().Be(59033);
result.ErrorMessage.Should().BeNull();
}
//ko cho truyền IConfiguration configuration chổ này??????????????????????
public MessageResponse PaymentImport([FromForm] ConversionRequest request)
{
PaymentConversionService service = new PaymentConversionService(new PaymentPsTool());
return(service.ProcessRequest(request));
}
public Request(ConversionRequest conversionRequest, string fileName)
{
ConversionRequest = conversionRequest;
FileName = fileName;
}
public MessageResponse convert(ConversionRequest reqValue)
{
LOGGER.Info("Conversion processing...");
if (reqValue == null || string.IsNullOrEmpty(reqValue.blobHeaderName) || string.IsNullOrEmpty(reqValue.blobOutputName) || string.IsNullOrEmpty(reqValue.containerName))
{
return(MessageResponse.info("[blobHeaderName, blobOutputName, containerName] are required."));
}
string BlobContainer = reqValue.containerName.Trim();
string BlobInputName = reqValue.blobHeaderName.Trim();
string BlobOutputName = reqValue.blobOutputName.Trim();
string AESKey = Vault.Current.AESKeyBLOB;
string storageConnectionString = Vault.Current.StorageConnectionString;
//validate parameter
if (string.IsNullOrEmpty(BlobContainer))
{
return(MessageResponse.info("Blob container is required."));
}
if (string.IsNullOrEmpty(BlobInputName))
{
return(MessageResponse.info("Blob file input is required."));
}
if (string.IsNullOrEmpty(BlobOutputName))
{
return(MessageResponse.info("Blob file output is required."));
}
if (string.IsNullOrEmpty(AESKey))
{
return(MessageResponse.info("AESKEY to encrypt/decrypt file is required."));
}
try
{
// Retrieve reference to a previously created container.
CloudBlobContainer blobContainer = BlobHelper.GetCloudBlobContainer(storageConnectionString, BlobContainer);
Task <bool> IsExitBlobContainer = blobContainer.ExistsAsync();
if (blobContainer == null || !IsExitBlobContainer.Result)
{
return(MessageResponse.info(string.Format("Can't find the BLOB container [{0}].", BlobContainer)));
}
// Retrieve reference to a blob named "myblob".
CloudBlockBlob blockBlobInput = blobContainer.GetBlockBlobReference(BlobInputName);
Task <bool> IsExitblockBlobInput = blockBlobInput.ExistsAsync();
if (blockBlobInput == null || !IsExitblockBlobInput.Result)
{
return(MessageResponse.info(string.Format("Can't find the BLOB file [{0}].", BlobInputName)));
}
//download file
byte[] fileInput = BlobHelper.DownloadFileToArrayByte(blockBlobInput, AESKey);
if (fileInput == null)
{
return(MessageResponse.info(string.Format("Can't find the content of the BLOB file [{0}].", BlobInputName)));
}
//do conversion
StringBuilder sbStandardFile = this.doConvert(fileInput);
//no error: write the file standard
if (this.ListErrorVendor == null || this.ListErrorVendor.Count == 0)
{
//upload the file standard file to azure
BlobHelper.UploadFile(blobContainer, BlobOutputName, sbStandardFile, AESKey);
//return the blob output name of file saved
//LOGGER.Info(string.Format("File [{0}] converted to the file [{1}] and saved successfully in the BLOB container [{2}]", BlobInputName, BlobOutputName, BlobContainer));
return(MessageResponse.ok(reqValue.blobOutputName));
}
//report errors if have
if (this.ListErrors == null)
{
this.ListErrors = new List <string>();
}
if (this.ListErrorVendor.Count > 0)
{
this.ListErrors.AddRange(this.ListErrorVendor);
}
return(MessageResponse.error(this.ListErrors));
}
catch (Exception ex)
{
LOGGER.Error(ex);
throw;
}
}
private void NewFileFound(FileSystemInfo file)
{
try
{
var request = new ConversionRequest();
var path = File.ReadAllText(file.FullName);
Factory.ReadRequest(new StreamReader(path)); // reads all text to ensure that file is closed after reading
lock (ConversionRequestQueue)
{
Logger.TraceInfo(MethodBase.GetCurrentMethod(), "({0}) enqueue {1}", Thread.CurrentThread.Name, file.FullName);
ConversionRequestQueue.Enqueue(new Request(request, Path.GetFileName(file.FullName)));
File.Delete(file.FullName);
}
}
catch (Exception exception)
{
Logger.TraceErr(MethodBase.GetCurrentMethod(), "({0}) Exception", Thread.CurrentThread.Name);
Logger.TraceErr(MethodBase.GetCurrentMethod(), exception);
}
}
