public void RedeemStandingOrdersAccessTokenTest()
{
using (var tokenClient = TestUtil.CreateClient())
{
UserMember grantor = TestUtil.CreateUserMember();
string accountId = grantor.GetAccountsBlocking()[0].Id();
Alias granteeAlias = TestUtil.RandomAlias();
TppMember grantee = tokenClient.CreateMemberBlocking(granteeAlias);
// make some standing orders
Alias payeeAlias = TestUtil.RandomAlias();
TppMember payee = tokenClient.CreateMemberBlocking(payeeAlias);
for (int i = 0; i < 5; i++)
{
Token token = CreateStandingOrderTokenSample.CreateStandingOrderToken(
grantor,
payeeAlias,
Key.Types.Level.Standard);
RedeemStandingOrderTokenSample.RedeemStandingOrderToken(
payee,
token.Id);
}
Token accessToken =
CreateAndEndorseAccessTokenSample.CreateStandingOrdersAccessToken(grantor, accountId, granteeAlias);
IList <StandingOrder> standingOrders =
RedeemAccessTokenSample.RedeemStandingOrdersAccessToken(grantee, accessToken.Id);
Assert.Equal(5, standingOrders.Count);
}
}
} /* this simple sample uses a no op */
/// <summary>
/// Illustrate setting up a recovery rule more complex than "normal consumer"
/// mode, without the "normal consumer" shortcuts.
/// </summary>
/// <param name="newMember">newly-created member we are setting up</param>
/// <param name="tokenClient">SDK client</param>
/// <param name="agentAlias">Alias of recovery agent.</param>
public void SetUpComplexRecoveryRule(
TppMember newMember,
Tokenio.Tpp.TokenClient tokenClient,
Alias agentAlias)
{
// setUpComplex begin snippet to include in docs
// Someday in the future, this user might ask the recovery agent
// "Please tell Token that I am the member with ID m:12345678 ."
// While we're setting up this new member, we need to tell the
// recovery agent the new member ID so the agent can "remember" later.
TellRecoveryAgentMemberId(newMember.MemberId());
string agentId = tokenClient.GetMemberIdBlocking(agentAlias);
RecoveryRule recoveryRule = new RecoveryRule {
PrimaryAgent = agentId
};
// This example doesn't call .setSecondaryAgents ,
// but could have. If it had, then recovery would have
// required one secondary agent authorization along with
// the primary agent authorization.
newMember.AddRecoveryRuleBlocking(recoveryRule);
// setUpComplex done snippet to include in docs
}
/// <summary>
/// Stores a transfer token without setting Transfer Destinations and instead providing
/// a callback URL.
/// </summary>
/// <param name="payee">Payee Token member (the member requesting the transfer token be created)</param>
/// <param name="setTransferDestinationsCallback">callback url.</param>
/// <returns>token request id</returns>
public static string StoreTransferTokenRequestWithDestinationsCallback(
TppMember payee,
string setTransferDestinationsCallback)
{
TokenRequest tokenRequest = TokenRequest.TransferTokenRequestBuilder(250, "EUR")
.SetToMemberId(payee.MemberId())
.SetDescription("Book purchase")
// This TPP provided url gets called by Token after the user selects bank and
// country on the Token web app.
.SetSetTransferDestinationsUrl(setTransferDestinationsCallback)
// This TPP provided Redirect URL gets called after Token is ready
// for redemption.
.SetRedirectUrl("https://tpp-sample.com/callback")
.SetFromAlias(new Alias
{
Value = "*****@*****.**",
Type = Alias.Types.Type.Email
})
.SetBankId("iron") // bank ID
.SetCsrfToken(Util.Nonce()) // nonce for CSRF check
.Build();
string requestId = payee.StoreTokenRequestBlocking(tokenRequest);
return(requestId);
}
public void StoreTokenRequestAndSetTransferDestinationsTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember payee = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
string requestId = StoreAndRetrieveTokenRequestSample
.StoreTransferTokenRequestWithDestinationsCallback(
payee,
setTransferDestinationsUrl);
StoreAndRetrieveTokenRequestSample.SetTokenRequestTransferDestinations(
payee,
requestId,
tokenClient,
setTransferDestinationsCallback);
TokenRequest request = tokenClient.RetrieveTokenRequestBlocking(requestId);
Assert.NotNull(request);
Assert.NotEqual(0, request
.GetTokenRequestPayload()
.TransferBody
.Instructions
.TransferDestinations.Count);
Assert.True(request
.GetTokenRequestPayload()
.TransferBody
.Instructions
.TransferDestinations[0].FasterPayments != null);
}
}
public void RedeemTransactionsAccessTokenTest()
{
using (var tokenClient = TestUtil.CreateClient())
{
UserMember grantor = TestUtil.CreateUserMember();
string accountId = grantor.GetAccountsBlocking()[0].Id();
Alias granteeAlias = TestUtil.RandomAlias();
TppMember grantee = tokenClient.CreateMemberBlocking(granteeAlias);
// make some transactions
Alias payeeAlias = TestUtil.RandomAlias();
TppMember payee = tokenClient.CreateMemberBlocking(payeeAlias);
var payeeAccount = payee.CreateTestBankAccountBlocking(1000, "EUR");
for (int i = 0; i < 5; i++)
{
Token token = CreateTransferTokenSample.CreateTransferToken(
grantor,
payeeAlias,
Key.Types.Level.Standard);
RedeemTransferTokenSample.RedeemTransferToken(
payee,
payeeAccount.Id(),
token.Id);
}
Token accessToken =
CreateAndEndorseAccessTokenSample.CreateTransactionsAccessToken(grantor, accountId, granteeAlias);
IList <Transaction> transactions =
RedeemAccessTokenSample.RedeemTransactionsAccessToken(grantee, accessToken.Id);
Assert.Equal(5, transactions.Count);
}
}
/// <summary>
/// Gets a list of access tokens associated with the member.
/// </summary>
/// <param name="member">member</param>
/// <returns>paged list of access tokens</returns>
public static PagedList <Token> GetAccessTokens(TppMember member)
{
// last 10 tokens and offset that can be used to get the next 10
PagedList <Token> pagedList = member.GetAccessTokensBlocking("", 10);
return(pagedList);
}
public void RecoveryComplex()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
MemberRecoverySample mrs = new MemberRecoverySample();
Tokenio.Tpp.TokenClient agentTokenIO = TestUtil.CreateClient();
Alias agentAlias = TestUtil.RandomAlias();
TppMember agentMember = agentTokenIO.CreateMemberBlocking(agentAlias);
mrs.agentMember = agentMember;
// set up
Alias originalAlias = TestUtil.RandomAlias();
TppMember originalMember = tokenClient.CreateMemberBlocking(originalAlias);
mrs.SetUpComplexRecoveryRule(originalMember, tokenClient, agentAlias);
// recover
Tokenio.Tpp.TokenClient otherTokenClient = TestUtil.CreateClient();
TppMember recoveredMember = mrs.RecoverWithComplexRule(
otherTokenClient,
originalAlias);
// make sure it worked
Alias recoveredAlias = recoveredMember.GetFirstAliasBlocking();
Assert.Equal(recoveredAlias, originalAlias);
}
}
public void GetTransactionsTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
UserMember payer = TestUtil.CreateUserMember();
Alias payeeAlias = TestUtil.RandomAlias();
TppMember payee = tokenClient.CreateMemberBlocking(payeeAlias);
Account payeeAccount = payee.CreateTestBankAccountBlocking(1000, "EUR");
Token token = TestUtil.CreateTransferToken(payer, payeeAlias);
Transfer transfer = RedeemTransferTokenSample.RedeemTransferToken(
payee,
payeeAccount.Id(),
token.Id);
string transactionId = transfer.TransactionId;
Transaction transaction = payer.GetTransactionBlocking(
payer.GetAccountsBlocking()[0].Id(),
transactionId,
Key.Types.Level.Standard);
Assert.Equal(transaction.TokenId, token.Id);
}
}
/// <summary>
/// Cancels the access token.
/// </summary>
/// <param name="grantee">grantee Token member</param>
/// <param name="tokenId">token ID to cancel</param>
/// <returns>operation result</returns>
public static TokenOperationResult CancelAccessToken(TppMember grantee, string tokenId)
{
// Retrieve an access token to cancel.
Token accessToken = grantee.GetTokenBlocking(tokenId);
// Cancel access token.
return(grantee.CancelTokenBlocking(accessToken));
}
/// <summary>
/// Illustrate Member.getTransfer
/// </summary>
/// <param name="payer">payer Token member</param>
/// <param name="transferId">id of a transfe</param>
/// <returns>a Transfer</returns>
public static Transfer GetTransferSample(
TppMember payer,
string transferId)
{
Transfer transfer = payer.GetTransferBlocking(transferId);
return(transfer);
}
/// <summary>
/// Cancels the transfer token.
/// </summary>
/// <param name="payee">payee Token member</param>
/// <param name="tokenId">token ID to cancel</param>
/// <returns>operation result</returns>
public static TokenOperationResult CancelTransferToken(TppMember payee, string tokenId)
{
// Retrieve a transfer token to cancel.
Token transferToken = payee.GetTokenBlocking(tokenId);
// Cancel transfer token.
return(payee.CancelTokenBlocking(transferToken));
}
public void ProfilesTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient()) {
TppMember member = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
Profile profile = MemberMethodsSample.Profiles(member);
Assert.NotEmpty(profile.DisplayNameFirst);
}
}
/// <summary>
/// Get a member's list of balances.
/// </summary>
/// <param name="member">Member.</param>
/// <returns>list of balances</returns>
public static IList <Balance> memberGetBalanceListSample(TppMember member)
{
List <string> accountIds = member
.GetAccountsBlocking().Select(acc => acc.Id()).ToList();
var balances = member.GetBalancesBlocking(accountIds, Key.Types.Level.Standard);
return(balances);
}
public void StoreAndRetrieveAccessTokenTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember grantee = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
string requestId = StoreAndRetrieveTokenRequestSample.StoreTransferTokenRequest(grantee);
TokenRequest request = tokenClient.RetrieveTokenRequestBlocking(requestId);
Assert.NotNull(request);
}
}
public void KeysTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient()) {
IKeyStore keyStore = new InMemoryKeyStore();
ICryptoEngine cryptoEngine = new TokenCryptoEngine("member-id", keyStore);
TppMember member = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
MemberMethodsSample.Keys(cryptoEngine, member);
}
}
public void AccountGetBalanceSampleTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember member = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
member.CreateTestBankAccountBlocking(1000.0, "EUR");
var sums = GetBalanceSample.AccountGetBalanceSample(member);
Assert.Equal(sums["EUR"], 1000.0);
}
}
private static Task <Member> GetPfmMember()
{
return(pfmMember != null
? Task.FromResult(pfmMember)
: InitializeMember(tokenClient)
.Map(mem =>
{
pfmMember = mem;
return mem;
}));
}
/// <summary>
/// Set a webhook config.
/// </summary>
/// <param name="tpp">The TPP member</param>
public static void SetWebhookConfig(TppMember tpp)
{
WebhookConfig config = new WebhookConfig
{
Url = "http://example.token.io/webhook"
};
config.Type.Add(EventType.TransferStatusChanged);
tpp.SetWebhookConfigBlocking(config);
}
/// <summary>
/// Illustrate Member.getTransferTokens
/// </summary>
/// <param name="payer">payer Token member</param>
public static void GetTransferTokensSample(
TppMember payer)
{
foreach (Token token in payer.GetTransferTokensBlocking(null, 10).List)
{
TransferBody transferBody = token.Payload.Transfer;
DisplayTransferToken(
transferBody.Currency,
transferBody.LifetimeAmount);
}
}
public void TriggerBalanceStepUpNotificationTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember member = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
NotifyStatus status = member.TriggerBalanceStepUpNotificationBlocking(
(new[] { "123", "456" }).ToImmutableList());
Assert.NotNull(status);
}
}
/// <summary>
/// Gets a token by ID.
/// </summary>
/// <param name="member">member represented by the token (payer/payee/grantor/grantee)</param>
/// <param name="tokenId">token ID</param>
/// <returns>token</returns>
public static Token GetToken(TppMember member, string tokenId)
{
Token token = member.GetTokenBlocking(tokenId);
// get token payload
TokenPayload payload = token.Payload;
// get signatures
var signatures = token.PayloadSignatures;
return(token);
}
public void CancelTransferTokenByGranteeTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient()) {
UserMember grantor = TestUtil.CreateUserMember();
Alias granteeAlias = TestUtil.RandomAlias();
TppMember grantee = tokenClient.CreateMemberBlocking(granteeAlias);
Token token = TestUtil.CreateTransferToken(grantor, granteeAlias);
TokenOperationResult result = CancelTransferTokenSample.CancelTransferToken(grantee, token.Id);
Assert.Equal(result.Status, TokenOperationResult.Types.Status.Success);
}
}
/// <summary>
/// Illustrate Member.getTransfers
/// </summary>
/// <param name="payer">payer Token member</param>
public static void GetTransfers_Sample(TppMember payer)
{
var accounts = payer.GetAccountsBlocking();
string accountId = accounts[0].Id();
foreach (Transfer transfer in payer.GetTransfersBlocking(null, null, 10).List)
{
DisplayTransfer(
transfer.Status,
transfer.Payload.Description);
}
}
public void CancelAccessTokenByGranteeTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient()) {
Tokenio.User.Member grantor = TestUtil.CreateUserMember();
string accountId = grantor.GetAccountsBlocking()[0].Id();
Alias granteeAlias = TestUtil.RandomAlias();
TppMember grantee = tokenClient.CreateMemberBlocking(granteeAlias);
Token token = TestUtil.CreateAccessToken(grantor, accountId, granteeAlias);
TokenOperationResult result = CancelAccessTokenSample.CancelAccessToken(grantee, token.Id);
Assert.Equal(result.Status, TokenOperationResult.Types.Status.Success);
}
}
/// <summary>
/// Adds and removes keys.
/// </summary>
/// <param name="crypto">crypto engine</param>
/// <param name="member">member</param>
public static void Keys(ICryptoEngine crypto, TppMember member)
{
Key lowKey = crypto.GenerateKey(Key.Types.Level.Low);
member.ApproveKeyBlocking(lowKey);
Key standardKey = crypto.GenerateKey(Key.Types.Level.Standard);
Key privilegedKey = crypto.GenerateKey(Key.Types.Level.Privileged);
member.ApproveKeysBlocking(new[] { standardKey, privilegedKey });
member.RemoveKeyBlocking(lowKey.Id);
}
/// <summary>
/// Adds and removes an alias.
/// </summary>
/// <param name="member">member</param>
public static void Aliases(TppMember member)
{
Alias alias = new Alias
{
Type = Alias.Types.Type.Domain,
Value = "verified-domain.com"
};
// add the alias
member.AddAliasBlocking(alias);
// remove the alias
member.RemoveAliasBlocking(alias);
}
/// <summary>
/// Redeems a transfer token to transfer money from payer bank account to payee bank account.
/// </summary>
/// <param name="payee">payee Token member</param>
/// <param name="tokenId">ID of the token to redeem</param>
/// <returns>a transfer Transfer</returns>
public static StandingOrderSubmission RedeemStandingOrderToken(
TppMember payee,
string tokenId)
{
// Retrieve a transfer token to redeem.
Token standingOrderToken = payee.GetTokenBlocking(tokenId);
// Payee redeems a standing order token.
// Money is transferred to a payee bank account.
StandingOrderSubmission submission = payee.RedeemStandingOrderTokenBlocking(
standingOrderToken.Id);
return(submission);
}
/// <summary>
/// Recovers a TPP member and verifies its EIDAS alias using eIDAS certificate.
///
/// </summary>
/// <param name="client">token client</param>
/// <param name="memberId">id of the member to be recovered</param>
/// <param name="tppAuthNumber">authNumber of the TPP</param>
/// <param name="certificate">base64 encoded eIDAS certificate</param>
/// <param name="certificatePrivateKey">private key corresponding to the public key in the certificate</param>
/// <returns>verified business member</returns>
public static Member RecoverEidas(
Tokenio.Tpp.TokenClient client,
string memberId,
string tppAuthNumber,
string certificate,
byte[] certificatePrivateKey)
{
// create a signer using the certificate private key
Algorithm signingAlgorithm = Algorithm.Rs256;
ISigner payloadSigner = new Rs256Signer("eidas", certificatePrivateKey);
// generate a new privileged key to add to the member
ICryptoEngine cryptoEngine = new TokenCryptoEngine(memberId, new InMemoryKeyStore());
Key newKey = cryptoEngine.GenerateKey(Level.Privileged);
// construct a payload with all the required data
EidasRecoveryPayload payload = new EidasRecoveryPayload
{
MemberId = memberId,
Certificate = certificate,
Algorithm = signingAlgorithm,
Key = newKey
};
Tokenio.Tpp.Member recoveredMember = client
.RecoverEidasMember(payload, payloadSigner.Sign(payload), cryptoEngine)
.Result;
// the eidas alias becomes unverified after the recovery, so we need to verify it again
Alias eidasAlias = new Alias
{
Value = tppAuthNumber.Trim(),
RealmId = recoveredMember.RealmId(),
Type = Alias.Types.Type.Eidas
};
VerifyEidasPayload verifyPayload = new VerifyEidasPayload
{
MemberId = memberId,
Alias = eidasAlias,
Certificate = certificate,
Algorithm = signingAlgorithm
};
VerifyEidasResponse response = recoveredMember
.VerifyEidas(verifyPayload, payloadSigner.Sign(verifyPayload))
.Result;
return(recoveredMember);
}
public void WebhookTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember tpp = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
Assert.Throws <AggregateException>(() => WebhookSample.GetWebhookConfig(tpp));
WebhookSample.SetWebhookConfig(tpp);
Assert.NotNull(WebhookSample.GetWebhookConfig(tpp));
WebhookSample.DeleteWebhookConfig(tpp);
Assert.Throws <AggregateException>(() => WebhookSample.GetWebhookConfig(tpp));
}
}
public void MemberGetBalancesSampleTest()
{
using (Tokenio.Tpp.TokenClient tokenClient = TestUtil.CreateClient())
{
TppMember member = tokenClient.CreateMemberBlocking(TestUtil.RandomAlias());
member.CreateTestBankAccountBlocking(1000.0, "EUR");
member.CreateTestBankAccountBlocking(500.0, "EUR");
List <Balance> balances = (List <Balance>)GetBalanceSample.memberGetBalanceListSample(member);
Assert.Equal(balances.Count, 2);
Assert.True(balances.Exists(b => double.Parse(b.Current.Value).Equals(500.0)));
Assert.True(balances.Exists(b => double.Parse(b.Current.Value).Equals(1000.0)));
}
}