/// <summary> /// Creates a transfer token using some other options. /// </summary> /// <param name="payer">payer Token member</param> /// <param name="payeeId">payee Token member Id</param> /// <returns>a transfer Token</returns> public static Token CreateTransferTokenWithOtherOptions( UserMember payer, string payeeId) { long now = Util.CurrentMillis(); // Set the details of the token. TransferTokenBuilder builder = payer.CreateTransferTokenBuilder( 120.0, // amount "EUR") // currency .SetAccountId(payer.GetAccountsBlocking()[0].Id()) .SetToMemberId(payeeId) .SetToMemberId(payeeId) // effective in one second: .SetEffectiveAtMs(now + 1000) // expires in 300 seconds: .SetExpiresAtMs(now + (300 * 1000)) .SetRefId("a713c8a61994a749") .SetChargeAmount(10.0) .SetDescription("Book purchase"); // Get the token redemption policy and resolve the token payload. PrepareTokenResult result = payer.PrepareTransferTokenBlocking(builder); // Create the token, signing with the payer's STANDARD-level key Token transferToken = payer.CreateTokenBlocking(result.TokenPayload, Level.Standard); return(transferToken); }
/// <summary> /// Creates transfer token to a destination. /// </summary> /// <param name="payer">Payer who has no linked bank accounts</param> /// <param name="payeeAlias">Alias of payee member</param> /// <returns>a transfer Token</returns> public static Token CreateTransferTokenToDestination( UserMember payer, Alias payeeAlias) { // Set SEPA destination. TransferDestination sepaDestination = new TransferDestination { Sepa = new TransferDestination.Types.Sepa { Bic = "XUIWC2489", Iban = "DE89 3704 0044 0532 0130 00" } }; // Set the destination and other details. TransferTokenBuilder builder = payer.CreateTransferTokenBuilder( 100.0, // amount "EUR") // currency .SetAccountId(payer.GetAccountsBlocking()[0].Id()) .SetToAlias(payeeAlias) .AddDestination(sepaDestination); // Get the token redemption policy and resolve the token payload. PrepareTokenResult result = payer.PrepareTransferTokenBlocking(builder); // Create the token, signing with the payer's STANDARD-level key Token transferToken = payer.CreateTokenBlocking(result.TokenPayload, Level.Standard); return(transferToken); }
/// <summary> /// Creates the transfer token. /// </summary> /// <returns>The transfer token.</returns> /// <param name="payer">Payer.</param> /// <param name="payeeAlias">Payee alias.</param> public static Token CreateTransferToken( UserMember payer, Alias payeeAlias) { // We'll use this as a reference ID. Normally, a payer who // explicitly sets a reference ID would use an ID from a db. // E.g., a bill-paying service might use ID of a "purchase". // We don't have a db, so we fake it with a random string: string purchaseId = Tokenio.User.Utils.Util.Nonce(); // Create a transfer token. var tokenPayload = payer.CreateTransferTokenBuilder( 100.0, // amount "EUR") // currency // source account: .SetAccountId(payer.GetAccountsBlocking()[0].Id()) // payee token alias: .SetToAlias(payeeAlias) // optional description: .SetDescription("Book purchase") // ref id (if not set, will get random ID) .SetRefId(purchaseId) .BuildPayload(); var transferToken = payer.CreateTokenBlocking(tokenPayload, new List <Signature>()); // Payer endorses a token to a payee by signing it // with her secure private key. transferToken = payer.EndorseTokenBlocking(transferToken, Key.Types.Level.Standard).Token; return(transferToken); }
/// <summary> /// Creates a transfer token and authorizes a money transfer from a payer to a payee. /// </summary> /// <param name="payer">payer Token member</param> /// <param name="payeeAlias">payee Token member alias</param> /// <returns>a transfer Token</returns> public static Token CreateTransferToken( UserMember payer, Alias payeeAlias) { // Create an access token for the grantee to access bank string purchaseId = Util.Nonce(); // Create a transfer token. TransferTokenBuilder builder = payer.CreateTransferTokenBuilder( 10.0, // amount "EUR") // currency // source account: .SetAccountId(payer.GetAccountsBlocking()[0].Id()) // payee token alias: .SetToAlias(payeeAlias) // optional description: .SetDescription("Book purchase") // ref id (if not set, will get random ID) .SetRefId(purchaseId); PrepareTokenResult result = payer.PrepareTransferTokenBlocking(builder); // Payer endorses a token to a payee by signing it // with her secure private key. Token transferToken = payer.CreateTokenBlocking( result.TokenPayload, Key.Types.Level.Low); return(transferToken); }
/// <summary> /// Creates a transfer token and authorizes a money transfer from a payer to a payee. /// </summary> /// <param name="payer">payer Token member</param> /// <param name="payeeAlias">payee Token member alias</param> /// <param name="keyLevel">the level of signature to provide</param> /// <returns>a transfer Token</returns> public static Token CreateTransferToken( UserMember payer, Alias payeeAlias, Level keyLevel) { // We'll use this as a reference ID. Normally, a payer who // explicitly sets a reference ID would use an ID from a db. // E.g., a bill-paying service might use ID of a "purchase". // We don't have a db, so we fake it with a random string: string purchaseId = Util.Nonce(); // Set the details of the token. TransferTokenBuilder builder = payer.CreateTransferTokenBuilder( 10.0, // amount "EUR") // currency // source account: .SetAccountId(payer.GetAccountsBlocking()[0].Id()) // payee token alias: .SetToAlias(payeeAlias) // optional description: .SetDescription("Book purchase") // ref id (if not set, will get random ID) .SetRefId(purchaseId); PrepareTokenResult result = payer.PrepareTransferTokenBlocking(builder); // Create the token: Default behavior is to provide the member's signature // at the specified level. In other cases, it may be necessary to provide // additional signatures with payer.createToken(payload, signatures). Token transferToken = payer.CreateTokenBlocking(result.TokenPayload, keyLevel); return(transferToken); }
public void NotifyPaymentRequestSampleTest() { using (Tokenio.User.TokenClient tokenClient = TestUtil.CreateClient()) { UserMember payer = TestUtil.CreateMemberAndLinkAccounts(tokenClient); UserMember payee = PollNotificationsSample.CreateMember(tokenClient); Alias payeeAlias = payee.GetFirstAliasBlocking(); Tokenio.User.Account account = LinkMemberAndBankSample.LinkBankAccounts(payer); LinkMemberAndBankSample.LinkBankAccounts(payee); TransferDestination tokenDestination = new TransferDestination { Token = new TransferDestination.Types.Token { MemberId = payee.MemberId() } }; TransferTokenBuilder builder = payer.CreateTransferTokenBuilder(100.00, "EUR") .SetAccountId(account.Id()) .SetToAlias(payeeAlias) .AddDestination(tokenDestination); PrepareTokenResult result = payer.PrepareTransferTokenBlocking(builder); Token token = payer.CreateTokenBlocking(result.TokenPayload, Key.Types.Level.Standard); Transfer transfer = payee.RedeemTokenBlocking(token); var notification = PollNotificationsSample.Poll(payee); Assert.NotNull(notification); } }
/// <summary> /// Finds a previously-created access token from grantor to grantee. /// </summary> /// <param name="tokenClient">initialized SDK</param> /// <param name="grantor">Token member granting access to her accounts</param> /// <param name="granteeAlias">Token member alias acquiring information access</param> /// <returns>an access Token</returns> public static Token FindAccessToken( Tokenio.User.TokenClient tokenClient, UserMember grantor, Alias granteeAlias) { string granteeMemberId = tokenClient.GetMemberIdBlocking(granteeAlias); return(grantor.GetActiveAccessTokenBlocking(granteeMemberId)); }
/// <summary> /// Creates the user member. /// </summary> /// <returns>The user member.</returns> public static UserMember CreateUserMember() { Tokenio.User.TokenClient client = Tokenio.User.TokenClient.Create(Tokenio.TokenCluster.DEVELOPMENT, DEV_KEY); Alias alias = RandomUserAlias(); UserMember member = client.CreateMemberBlocking(alias); member.CreateTestBankAccountBlocking(1000.0, "EUR"); return(member); }
/// <summary> /// Creates a standing order token and authorizes a money transfer from a payer to a payee. /// </summary> /// <param name="payer">payer Token member</param> /// <param name="payeeAlias">payee Token member alias</param> /// <param name="keyLevel">the level of signature to provide</param> /// <returns>a standing order Token</returns> public static Token CreateStandingOrderToken( UserMember payer, Alias payeeAlias, Level keyLevel) { // We'll use this as a reference ID. Normally, a payer who // explicitly sets a reference ID would use an ID from a db. // E.g., a bill-paying service might use ID of a "purchase". // We don't have a db, so we fake it with a random string: string purchaseId = Util.Nonce(); // Set SEPA destination. TransferDestination sepaDestination = new TransferDestination { Sepa = new TransferDestination.Types.Sepa { Bic = "XUIWC2489", Iban = "DE89 3704 0044 0532 0130 00" } }; // Set the details of the token. StandingOrderTokenBuilder builder = payer.CreateStandingOrderTokenBuilder( 10.0, // amount "EUR", // currency "DAIL", // frequency of the standing order DateTime.Now, // start date DateTime.Now.AddDays(7)) // end date // source account: .SetAccountId(payer.GetAccountsBlocking()[0].Id()) // payee token alias: .SetToAlias(payeeAlias) // optional description: .SetDescription("Credit card statement payment") // ref id (if not set, will get random ID) .SetRefId(purchaseId) .AddDestination(sepaDestination); // Get the token redemption policy and resolve the token payload. PrepareTokenResult result = payer.PrepareStandingOrderTokenBlocking(builder); // Create the token: Default behavior is to provide the member's signature // at the specified level. In other cases, it may be necessary to provide // additional signatures with payer.createToken(payload, signatures). Token token = payer.CreateTokenBlocking(result.TokenPayload, keyLevel); return(token); }
/// <summary> /// Replaces a previously-created access token. /// </summary> /// <param name="grantor">Token member granting access to her accounts</param> /// <param name="granteeAlias">Token member alias acquiring information access</param> /// <param name="oldToken">token to replace</param> /// <returns>success or failure</returns> public static TokenOperationResult ReplaceAccessToken( UserMember grantor, Alias granteeAlias, Token oldToken) { string accountId = grantor.CreateTestBankAccountBlocking(1000.0, "EUR") .Id(); // Replace the old access token Token newToken = grantor.ReplaceAccessTokenBlocking( oldToken, AccessTokenBuilder .FromPayload(oldToken.Payload) .ForAccount(accountId)) .Token; // Endorse the new access token TokenOperationResult status = grantor.EndorseTokenBlocking(newToken, Key.Types.Level.Standard); return(status); }
/// <summary> /// Creates the access token. /// </summary> /// <returns>The access token.</returns> /// <param name="grantor">Grantor.</param> /// <param name="accountId">Account identifier.</param> /// <param name="granteeAlias">Grantee alias.</param> public static Token CreateAccessToken( UserMember grantor, string accountId, Alias granteeAlias) { // Create an access token for the grantee to access bank // account names of the grantor. Token accessToken = grantor.CreateAccessTokenBlocking( AccessTokenBuilder .Create(granteeAlias) .ForAccount(accountId) .ForAccountBalances(accountId)); // Grantor endorses a token to a grantee by signing it // with her secure private key. accessToken = grantor.EndorseTokenBlocking( accessToken, Key.Types.Level.Standard).Token; return(accessToken); }