public async Task Should_Return401Or404_When_UnauthorizedRequest( CreateTransferRequest createTransferRequest, string region, IDictionary <string, string> headers, IAccessTokenResult accessTokenResult, Transfer transfer, bool throws ) { mockAccessTokenValidator.SetupValidateToken(accessTokenResult); mockCoreContext.SetupRegion(region); var response = await mockFunction.Run(createTransferRequest, headers, region); switch (accessTokenResult) { case ExpiredAccessTokenResult _: Assert.That(response, Is.InstanceOf <UnauthorizedResult>()); break; default: Assert.That(response, Is.InstanceOf <NotFoundResult>()); break; } }
public async Task Should_Return500Or404_When_InvalidRequest( CreateTransferRequest createTransferRequest, string region, IDictionary <string, string> headers, IAccessTokenResult accessTokenResult, Transfer transfer, bool throws ) { var(_, _, _, localization) = createTransferRequest; mockAccessTokenValidator.SetupValidateToken(accessTokenResult); mockCoreContext.SetupRegion(region); mockCoreContext.SetupLocalization(localization); mockTransfersService.SetupCreateTransfer(transfer, throws); var response = await mockFunction.Run(createTransferRequest, headers, region); switch (accessTokenResult) { case ValidAccessTokenResult _: Assert.That(response, Is.InstanceOf <InternalServerErrorMessageResult>()); break; default: Assert.That(response, Is.InstanceOf <NotFoundResult>()); break; } }
public async Task ShouldCreateTransferFromWebUrls() { /// Arrange var transferName = "UrlImport " + new Random().Next(1000, 9999); var urls = new List <string> { "https://picturepark.com/wp-content/uploads/2013/06/home-marquee.jpg", "http://cdn1.spiegel.de/images/image-733178-900_breitwand_180x67-zgpe-733178.jpg", "http://cdn3.spiegel.de/images/image-1046236-700_poster_16x9-ymle-1046236.jpg" }; /// Act var request = new CreateTransferRequest { Name = transferName, TransferType = TransferType.WebDownload, WebLinks = urls.Select(url => new TransferWebLink { Url = url, Identifier = Guid.NewGuid().ToString() }).ToList() }; var result = await _client.Transfers.CreateAndWaitForCompletionAsync(request); /// Assert Assert.NotNull(result.Transfer); }
private async Task <CreateTransferResult> UpdateFileTransferAsync(PictureparkAsset asset) { var transferIdentifier = $"Smint.io Update Import {Guid.NewGuid().ToString()}"; var localFile = await asset.GetDownloadedFileAsync(); var filePaths = new FileLocations[] { new FileLocations(localFile.FullName, asset.RecommendedFileName, asset.RecommendedFileName) }; var request = new CreateTransferRequest { Name = transferIdentifier, TransferType = TransferType.FileUpload, Files = new TransferUploadFile[] { new TransferUploadFile() { FileName = asset.RecommendedFileName } } }; var uploadOptions = new UploadOptions { ChunkSize = 1024 * 1024, ConcurrentUploads = 4, SuccessDelegate = Console.WriteLine, ErrorDelegate = ErrorDelegate, WaitForTransferCompletion = true }; return(await _client.Transfer.UploadFilesAsync(transferIdentifier, filePaths, uploadOptions)); }
/// <summary>Creates a transfer and waits for its completion.</summary> /// <param name="request">The create request.</param> /// <param name="timeout">The timeout to wait for completion.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The transfer.</returns> public async Task <CreateTransferResult> CreateAndWaitForCompletionAsync(CreateTransferRequest request, TimeSpan?timeout = null, CancellationToken cancellationToken = default(CancellationToken)) { var transfer = await CreateAsync(request, cancellationToken).ConfigureAwait(false); await _businessProcessClient.WaitForCompletionAsync(transfer.BusinessProcessId, timeout, cancellationToken).ConfigureAwait(false); return(new CreateTransferResult(transfer, request.Files)); }
public async Task TransfersCreateCreate() { var request = new CreateTransferRequest { Amount = 100000 }; var transfer = await Client.Transfers.Create(request); Assert.AreEqual(100000, transfer.Amount); }
public async Task TransfersCreateCreateWithRecipient() { var request = new CreateTransferRequest { Amount = 100000, Recipient = "recp_test_52yeov3bkjqpun3b4sm", }; var transfer = await Client.Transfers.Create(request); Assert.AreEqual(100000, transfer.Amount); Assert.AreEqual(request.Recipient, transfer.Recipient); }
internal static IEnumerable <TestCaseData> ValidRequests() { accessTokenResult = new Mock <ValidAccessTokenResult>().Object; yield return(GetTestCaseWhen("Token and body are valid and client is requesting")); createTransferRequest = new CreateTransferRequest { Name = "name", Customer = "customer" }; yield return(GetTestCaseWhen("Token is valid, body is missing template and client is requesting")); }
public PaymentCallback CreateTransfer(RenderContext context) { var fundingSourceResponse = JsonConvert.DeserializeObject <AddFundingSourceResponse>(context.Request.Body); PaymentCallback response = null; var fundingSourceLink = fundingSourceResponse.Links.FundingSource.Href; if (fundingSourceLink != null) { var dwollaApi = new DwollaApi(Setting); var webhookApi = PaymentHelper.GetCallbackUrl(this, nameof(Notify), context); var isNeedSubscribe = true; var webhookSubscriptionList = dwollaApi.GetWebhookSubscription().Result; foreach (var subscription in webhookSubscriptionList.Embedded.WebhookSubscriptions) { if (subscription.Url == webhookApi) { isNeedSubscribe = false; } } if (isNeedSubscribe) { var issubscribed = dwollaApi.CreateWebhookSubscription(webhookApi, "kooboodwollasecret").Result; } var request = new CreateTransferRequest() { Links = new Dictionary <string, Link> { { "source", new Link { Href = fundingSourceLink } }, { "destination", new Link { Href = new Uri(dwollaApi.ApiBaseAddress + "/funding-sources/" + Setting.FundingSourceId) } } }, Amount = fundingSourceResponse.Money }; var createTransferResult = dwollaApi.CreateTransfer(request).Result; if (createTransferResult.Status == "Created") { response = new PaymentCallback(); var storedRequest = PaymentManager.GetRequest(fundingSourceResponse.RequestId, context); storedRequest.ReferenceId = createTransferResult.TransferURL.ToString(); PaymentManager.UpdateRequest(storedRequest, context); } } return(response); }
public async Task <IActionResult> Transfer([FromBody] CreateTransferRequest cmd, Guid id) { await _operationsClient.Transfer(id, new CreateTransferCommand { ClientId = new Guid(_requestContext.ClientId), Amount = cmd.Amount, SourceWalletId = cmd.SourceWalletId, WalletId = cmd.WalletId, AssetId = cmd.AssetId }); return(Created(Url.Action("Get", new { id }), id)); }
private async Task <CreateTransferResult> CreateWebTransferAsync(List <string> urls) { var transferName = "UrlImport " + new Random().Next(1000, 9999); var request = new CreateTransferRequest { Name = transferName, TransferType = TransferType.WebDownload, WebLinks = urls.Select(url => new TransferWebLink { Url = url, Identifier = Guid.NewGuid().ToString() }).ToList() }; return(await _client.Transfer.CreateAndWaitForCompletionAsync(request).ConfigureAwait(false)); }
/// <summary> /// Creates a transfer redeeming a transfer token. /// </summary> /// <param name="payload">the transfer payload</param> /// <returns></returns> public Task <Transfer> CreateTransfer(TransferPayload payload) { var signer = cryptoEngine.CreateSigner(Level.Low); var request = new CreateTransferRequest { Payload = payload, PayloadSignature = new Signature { MemberId = MemberId, KeyId = signer.GetKeyId(), Signature_ = signer.Sign(payload) } }; return(gateway(authenticationContext()).CreateTransferAsync(request) .ToTask(response => response.Transfer)); }
public async Task <IActionResult> Run( [HttpTrigger( "post", Route = Routes.CreateTransfer )] CreateTransferRequest createTransferRequest, IDictionary <string, string> headers, string region ) { try { coreContext.SetRegion(region); AccessTokenResult = await accessTokenValidator.ValidateToken(headers); switch (AccessTokenResult) { case ValidAccessTokenResult _: var(name, customer, template, localization) = createTransferRequest; if (localization != null) { coreContext.Localization = localization; } var transfer = await transfersService.CreateTransfer(new CreateTransferParameters { Name = name, Customer = customer, TemplateItemCodename = template }); return(LogOkObject(transfer)); default: return(LogUnauthorized()); } } catch (Exception ex) { return(LogException(ex)); } }
public async Task Should_Return200_When_ValidRequest( CreateTransferRequest createTransferRequest, string region, IDictionary <string, string> headers, IAccessTokenResult accessTokenResult, Transfer transfer, bool throws ) { var(_, _, _, localization) = createTransferRequest; mockAccessTokenValidator.SetupValidateToken(accessTokenResult); mockCoreContext.SetupRegion(region); mockCoreContext.SetupLocalization(localization); mockTransfersService.SetupCreateTransfer(transfer, throws); var response = await mockFunction.Run(createTransferRequest, headers, region); Assert.That(response, Is.InstanceOf <OkObjectResult>()); }
/// <summary>Creates a transfer and waits for its completion.</summary> /// <param name="transferName">The name of the transfer.</param> /// <param name="files">The file names of the transfer.</param> /// <param name="timeout">The timeout to wait for completion.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The transfer.</returns> public async Task <CreateTransferResult> CreateAndWaitForCompletionAsync(string transferName, IEnumerable <FileLocations> files, TimeSpan?timeout = null, CancellationToken cancellationToken = default(CancellationToken)) { var filteredFileNames = await FilterFilesByBlacklist(files).ConfigureAwait(false); var request = new CreateTransferRequest { Name = !string.IsNullOrEmpty(transferName) ? transferName : new Random().Next(1000, 9999).ToString(), TransferType = TransferType.FileUpload, Files = filteredFileNames.Select(f => new TransferUploadFile { Identifier = f.Identifier, FileName = f.UploadAs }).ToList() }; var transfer = await CreateAsync(request, cancellationToken).ConfigureAwait(false); await _businessProcessClient.WaitForStatesAsync(transfer.BusinessProcessId, new[] { TransferState.Created.ToString() }, timeout, cancellationToken).ConfigureAwait(false); return(new CreateTransferResult(transfer, request.Files)); }
/* * private async Task<CreateTransferResult> CreateWebTransferAsync(string transferIdentifier, IList<PictureparkAsset> assets) * { * var request = new CreateTransferRequest * { * Name = transferIdentifier, * * TransferType = TransferType.WebDownload, * * WebLinks = assets.Select(asset => new TransferWebLink * { * Url = asset.DownloadUrl, * Identifier = asset.Id * }).ToList() * }; * return await _client.Transfer.CreateAndWaitForCompletionAsync(request); * } */ private async Task <CreateTransferResult> CreateFileTransferAsync(string transferIdentifier, IList <PictureparkAsset> assets) { var filePaths = new List <FileLocations>(); foreach (var asset in assets) { if (asset.IsCompoundAsset) { continue; } var localFile = await asset.GetDownloadedFileAsync(); var filePath = new FileLocations(localFile.FullName, asset.RecommendedFileName, asset.RecommendedFileName); filePaths.Add(filePath); } var request = new CreateTransferRequest { Name = transferIdentifier, TransferType = TransferType.FileUpload, Files = assets.Select(asset => new TransferUploadFile() { FileName = asset.RecommendedFileName }).ToList() }; var uploadOptions = new UploadOptions { ChunkSize = 1024 * 1024, ConcurrentUploads = 4, SuccessDelegate = Console.WriteLine, ErrorDelegate = ErrorDelegate, WaitForTransferCompletion = true }; return(await _client.Transfer.UploadFilesAsync(transferIdentifier, filePaths, uploadOptions)); }
public async Task <ActionResult> Create(CreateMoneyTransferViewModel viewModel) { var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId); if (project == null) { return(HttpNotFound()); } Fill(viewModel, project); if (!ModelState.IsValid) { return(View(viewModel)); } var request = new CreateTransferRequest() { ProjectId = viewModel.ProjectId, Sender = viewModel.Sender, Receiver = viewModel.Receiver, Amount = viewModel.Money, OperationDate = viewModel.OperationDate, Comment = viewModel.CommentText, }; try { await FinanceService.CreateTransfer(request); } catch (Exception e) { ModelState.AddException(e); return(View(viewModel)); } return(RedirectToAction("MoneySummary", "Finances", new { viewModel.ProjectId })); }
internal static IEnumerable <TestCaseData> InvalidRequests() { createTransferRequest = new CreateTransferRequest { Customer = "customer", Template = "template" }; accessTokenResult = new Mock <ValidAccessTokenResult>().Object; throws = true; yield return(GetTestCaseWhen("Token is valid, body is missing name and client is requesting")); createTransferRequest = new CreateTransferRequest { Name = "name", Template = "template" }; yield return(GetTestCaseWhen("Token is valid, body is missing customer and client is requesting")); createTransferRequest = new CreateTransferRequest { Customer = "customer", Template = "template" }; accessTokenResult = new Mock <NoAccessTokenResult>().Object; yield return(GetTestCaseWhen("Token is invalid, body is missing name and client is requesting")); createTransferRequest = new CreateTransferRequest { Name = "name", Template = "template" }; yield return(GetTestCaseWhen("Token is invalid, body is missing customer and client is requesting")); }
public async Task <IActionResult> Transfer([FromBody] CreateTransferRequest cmd, [FromQuery] Guid?id) { var check2FaResult = await _google2FaService.Check2FaAsync <string>(_requestContext.ClientId, cmd.Code2Fa); if (check2FaResult != null) { return(Ok(check2FaResult)); } var operationId = id ?? Guid.NewGuid(); await _operationsClient.Transfer(operationId, new CreateTransferCommand { ClientId = new Guid(_requestContext.ClientId), Amount = cmd.Amount, SourceWalletId = cmd.SourceWalletId, WalletId = cmd.WalletId, AssetId = cmd.AssetId }); return(Ok(Google2FaResultModel <string> .Success(id.ToString()))); }
public IResponse PostOperationTransfer(CreateTransferRequest transferRequest, string id, string authorization) { return(Request.Post($"/operations/transfer/{id}") .WithBearerToken(authorization) .AddJsonBody(transferRequest).Build().Execute()); }
public async Task CreateTransfer(CreateTransferRequest request) { var project = await ProjectRepository.GetProjectForFinanceSetup(request.ProjectId); project.RequestMasterAccess(CurrentUserId); project.RequestMasterAccess(request.Sender); project.RequestMasterAccess(request.Receiver); if (request.Sender == request.Receiver) { throw new DbEntityValidationException(); } if (request.Sender != CurrentUserId && request.Receiver != CurrentUserId) { project.RequestMasterAccess(CurrentUserId, acl => acl.CanManageMoney); } CheckOperationDate(request.OperationDate); if (request.Amount <= 0) { throw new DbEntityValidationException(); } var transfer = new MoneyTransfer() { SenderId = request.Sender, Amount = request.Amount, Changed = DateTimeOffset.UtcNow, Created = DateTimeOffset.UtcNow, ChangedById = CurrentUserId, CreatedById = CurrentUserId, OperationDate = request.OperationDate, ProjectId = request.ProjectId, ReceiverId = request.Receiver, TransferText = new TransferText() { Text = new MarkdownString(Required(request.Comment)), }, }; if (CurrentUserId == request.Sender) { transfer.ResultState = MoneyTransferState.PendingForReceiver; } else if (CurrentUserId == request.Receiver) { transfer.ResultState = MoneyTransferState.PendingForSender; } else { transfer.ResultState = MoneyTransferState.PendingForBoth; } project.MoneyTransfers.Add(transfer); //TODO send email await UnitOfWork.SaveChangesAsync(); }
public async Task CreateTransfer(CreateTransferRequest request) { throw new NotImplementedException(); }