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