dapi 2.0.0 dapi: ^2.0.0 copied to clipboard
Financial APIs to connect users' bank accounts.
import 'package:flutter/material.dart';
import 'dart:async';
import 'package:dapi/dapi.dart';
DapiConnection? connection;
void main() {
runApp(MyApp());
}
class Button extends StatelessWidget {
final void Function() onPressed;
final String text;
final bool visible;
const Button(
{required this.onPressed, required this.text, this.visible = true});
@override
Widget build(BuildContext context) {
Widget button = ElevatedButton(onPressed: onPressed, child: Text(text));
return Visibility(child: button, visible: visible);
}
}
class MyApp extends StatefulWidget {
@override
_MyAppState createState() => _MyAppState();
}
class _MyAppState extends State<MyApp> {
@override
void initState() {
super.initState();
}
@override
Widget build(BuildContext context) {
return MaterialApp(
home: Scaffold(
appBar: AppBar(
title: const Text('Dapi Connect'),
),
body: ListView(
padding: EdgeInsets.all(20),
children: [
Button(onPressed: () => startDapi(), text: "Start"),
Button(
onPressed: () => setConfigurations(new DapiConfigurations(environment: DapiEnvironment.SANDBOX, countries: List.from({"SA", "EG"}), showAddButton: true)),
text: "Set Configurations"),
Button(
onPressed: () => configurations(),
text: "Get Configurations"),
Button(onPressed: () => isStarted(), text: "Is Started"),
Button(
onPressed: () => setClientUserID("newID"),
text: "Set Client User ID"),
Button(onPressed: () => clientUserID(), text: "Get Client User ID"),
Button(onPressed: () => presentConnect(), text: "Present Connect"),
Button(onPressed: () => getConnections(), text: "Get Connections"),
Button(
onPressed: () => getIdentity(connection!),
text: "Get Identity"),
Button(
onPressed: () => getAccounts(connection!),
text: "Get Accounts"),
Button(onPressed: () => getCards(connection!), text: "Get Cards"),
Button(
onPressed: () => getTransactionsForAccount(connection!,
DateTime.parse("2021-05-01"), DateTime.parse("2021-09-10")),
text: "Get Transactions For Account"),
Button(
onPressed: () => getTransactionsForCard(connection!,
DateTime.parse("2021-05-01"), DateTime.parse("2021-09-10")),
text: "Get Transactions For Card"),
Button(
onPressed: () => getAccountsMetadata(connection!),
text: "Get Accounts Metadata"),
Button(
onPressed: () => getBeneficiaries(connection!),
text: "Get Beneficiaries"),
Button(
onPressed: () => createBeneficiary(connection!),
text: "Create Beneficiary"),
Button(
onPressed: () => createTransfer(connection!),
text: "Create Transfer"),
Button(
onPressed: () =>
createTransferToExistingBeneficiary(connection!),
text: "Create Transfer To Existing Beneficiary"),
Button(onPressed: () => delete(connection!), text: "Delete"),
],
),
),
);
}
}
Future<String?> startDapi() async {
try {
return await Dapi.start(
"1d4592c4a8dd6ff75261e57eb3f80c518d7857d6617769af3f8f04b0590baceb",
"1234ID",
configurations: new DapiConfigurations(
environment: DapiEnvironment.SANDBOX,
countries: List.from({"AE"})));
} on DapiSdkException catch (e) {
print('Error logged in Example Flutter app $e.');
}
}
Future<bool> isStarted() async {
bool isStarted = await Dapi.isStarted();
print(isStarted);
return isStarted;
}
void presentConnect() async {
Dapi.onConnectionSuccessful
.listen((m) => print("CONNECTION_SUCCESSFUl userID: ${m.userID}"));
Dapi.onConnectionFailure.listen((m) => dismissConnect());
Dapi.presentConnect();
}
void dismissConnect() {
Dapi.dismissConnect();
}
void setConfigurations(DapiConfigurations configurations) {
Dapi.setConfigurations(configurations);
}
Future<DapiConfigurations> configurations() async {
DapiConfigurations config = await Dapi.configurations();
print(config);
return config;
}
void setClientUserID(String clientUserID) {
Dapi.setClientUserID(clientUserID);
}
Future<String?> clientUserID() async {
String? id = await Dapi.clientUserID();
print(id);
return id;
}
Future<List<DapiConnection>> getConnections() async {
List<DapiConnection> connections = await Dapi.getConnections();
if (connections.isNotEmpty) {
connection = connections.first;
}
print(connections.toString());
return connections;
}
Future<DapiIdentityResponse> getIdentity(DapiConnection connection) async {
DapiIdentityResponse identityResponse = await connection.getIdentity();
print(identityResponse.identity!.emailAddress);
return identityResponse;
}
Future<DapiAccountsResponse> getAccounts(DapiConnection connection) async {
DapiAccountsResponse accountsResponse = await connection.getAccounts();
print(accountsResponse.accounts![1].id);
return accountsResponse;
}
Future<DapiCardsResponse> getCards(DapiConnection connection) async {
DapiCardsResponse cardsResponse = await connection.getCards();
print(cardsResponse.cards!.first.id);
return cardsResponse;
}
Future<DapiTransactionsResponse> getTransactionsForAccount(
DapiConnection connection, DateTime fromDate, DateTime toDate) async {
DapiTransactionsResponse transactionsResponse = await connection
.getTransactionsForAccount(connection.accounts.first, fromDate, toDate);
print(transactionsResponse.transactions!.first.amount);
return transactionsResponse;
}
Future<DapiTransactionsResponse> getTransactionsForCard(
DapiConnection connection, DateTime fromDate, DateTime toDate) async {
DapiTransactionsResponse transactionsResponse = await connection
.getTransactionsForCard(connection.cards.first, fromDate, toDate);
print(transactionsResponse.transactions!.first.amount);
return transactionsResponse;
}
Future<DapiAccountsMetadataResponse> getAccountsMetadata(
DapiConnection connection) async {
DapiAccountsMetadataResponse accountsMetadataResponse =
await connection.getAccountsMetadata();
print(accountsMetadataResponse.metadata?.swiftCode);
return accountsMetadataResponse;
}
Future<DapiResult> delete(DapiConnection connection) async {
DapiResult result = await connection.delete();
print(result);
return result;
}
Future<DapiBeneficiariesResponse> getBeneficiaries(
DapiConnection connection) async {
DapiBeneficiariesResponse beneficiariesResponse =
await connection.getBeneficiaries();
print(beneficiariesResponse.beneficiaries!.first.id);
return beneficiariesResponse;
}
Future<DapiResult> createBeneficiary(DapiConnection connection) async {
DapiResult result =
await connection.createBeneficiary(getSandboxBeneficiary());
print(result.operationID);
return result;
}
Future<CreateTransferResponse> createTransfer(DapiConnection connection) async {
CreateTransferResponse result =
await connection.createTransfer(null, getSandboxBeneficiary(), 2.0, null);
print(result.accountID);
return result;
}
Future<CreateTransferResponse> createTransferToExistingBeneficiary(
DapiConnection connection) async {
DapiBeneficiariesResponse beneficiariesResponse =
await getBeneficiaries(connection);
CreateTransferResponse result =
await connection.createTransferToExistingBeneficiary(
connection.accounts.first,
beneficiariesResponse.beneficiaries!.first.id!,
2.0,
null);
print(result.accountID);
return result;
}
DapiBeneficiary getSandboxBeneficiary() {
DapiLineAddress lineAddress = DapiLineAddress(
line1: "baniyas road", line2: "dubai", line3: "united arab emirates");
return DapiBeneficiary(
address: lineAddress,
accountNumber: "1623404370879825504324",
name: "name",
bankName: "bankName",
swiftCode: "DAPIBANK",
iban: "DAPIBANKAEENBD1623404370879825504324",
country: "UNITED ARAB EMIRATES",
branchAddress: "branchAddress",
branchName: "branchName",
phoneNumber: "xxxxxxxxxxx");
}