public async Task GetUsBank() { IPlaidClient plaidClient = new HttpPlaidClient(new Uri(Plaid_Sandbox_URL), QF_Plaid_Client_ID, QF_Plaid_Client_Secret, QF_Plaid_Public_Key); PlaidResult <ListOfInstitutionsResponse> result = await plaidClient.SearchInstitutions("us bank"); Assert.IsFalse(result.IsError); }
public async Task GetCategories() { IPlaidClient plaidClient = new HttpPlaidClient(new Uri(Plaid_Sandbox_URL), QF_Plaid_Client_ID, QF_Plaid_Client_Secret, QF_Plaid_Public_Key); PlaidResult <ListOfCategoriesResponse> result = await plaidClient.GetListOfCategoriesAsync(); Assert.IsFalse(result.IsError); }
public async Task GetInstitutions() { IPlaidClient plaidClient = new HttpPlaidClient(new Uri(Plaid_Sandbox_URL), QF_Plaid_Client_ID, QF_Plaid_Client_Secret, QF_Plaid_Public_Key); PlaidResult <ListOfInstitutionsWithTotalResponse> result = await plaidClient.GetListOfInstitutionsAsync(500, 0); Assert.IsFalse(result.IsError); }
/// <inheritdoc /> public async Task <PlaidResult <ListOfCategoriesResponse> > GetListOfCategoriesAsync() { //create the payload to pass var payload = string.Empty; //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync("categories/get", content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <ListOfCategoriesResponse> result = new PlaidResult <ListOfCategoriesResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { ListOfCategoriesResponse listCategoriesResponse = JsonConvert.DeserializeObject <ListOfCategoriesResponse>(responseJson); result.Value = listCategoriesResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
public async Task GetItem() { IPlaidClient plaidClient = new HttpPlaidClient(new Uri(Plaid_Sandbox_URL), QF_Plaid_Client_ID, QF_Plaid_Client_Secret, QF_Plaid_Public_Key); PlaidResult <ItemResponse> result = await plaidClient.GetItemAsync(Plaid_Sandbox_Access_Token); Assert.IsFalse(result.IsError); }
/// <inheritdoc /> public async Task <PlaidResult <RotateAccessTokenResponse> > RotateAccessTokenAsync(string accessToken) { //conditions Condition.Requires(accessToken).IsNotNullOrWhiteSpace(); //create the payload to pass PlaidRequest rotateTokenRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken); //pass and get response HttpResponseMessage response = await this.httpClient.PostAsJsonAsync(PlaidInformation.ItemManagement_RotateAccessToken, rotateTokenRequest); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <RotateAccessTokenResponse> result = new PlaidResult <RotateAccessTokenResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { RotateAccessTokenResponse tokenResponse = JsonConvert.DeserializeObject <RotateAccessTokenResponse>(responseJson); result.Value = tokenResponse; return(result); } result.Exception = await this.ParseException(response, responseJson); return(result); }
/// <inheritdoc /> public async Task <PlaidResult <AccessTokenResponse> > ExchangePublicTokenForAccessTokenAsync(string publicToken) { //conditions Condition.Requires(publicToken).IsNotNullOrWhiteSpace(); //create the payload to pass var payload = new ExchangePublicTokenForAccessTokenRequest(clientId, clientSecret, publicToken); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.LinkEndpoint_ExchangePublicToken, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <AccessTokenResponse> result = new PlaidResult <AccessTokenResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { AccessTokenResponse exchangeTokenResponse = JsonConvert.DeserializeObject <AccessTokenResponse>(responseJson); result.Value = exchangeTokenResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
public async Task ExchangeToken() { IPlaidClient plaidClient = new HttpPlaidClient(new Uri(Plaid_Sandbox_URL), QF_Plaid_Client_ID, QF_Plaid_Client_Secret, QF_Plaid_Public_Key); PlaidResult <AccessTokenResponse> result = await plaidClient.ExchangePublicTokenForAccessTokenAsync(Plaid_Sandbox_Public_Token); Assert.IsFalse(result.IsError); }
/// <inheritdoc /> public async Task <PlaidResult <Institution> > GetInstitutionAsync(string id) { //conditions Condition.Requires(id).IsNotNullOrWhiteSpace(); //create the payload to pass var payload = new InstitutionRequest(clientPublicKey, id); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.Institutions_GetInstitutionsById, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <Institution> result = new PlaidResult <Institution>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { Institution institutionResponse = JsonConvert.DeserializeObject <Institution>(responseJson); result.Value = institutionResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
/// <inheritdoc /> public async Task <PlaidResult <ListOfInstitutionsResponse> > SearchInstitutions(string query, IList <string> products = null) { //conditions Condition.Requires(query).IsNotNullOrWhiteSpace(); //create the payload to pass var payload = new InstitutionSearchRequest(clientPublicKey, query, products); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.Institutions_SearchInstitutions, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <ListOfInstitutionsResponse> result = new PlaidResult <ListOfInstitutionsResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { ListOfInstitutionsResponse listOfInstitutionsResponse = JsonConvert.DeserializeObject <ListOfInstitutionsResponse>(responseJson); result.Value = listOfInstitutionsResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
/// <inheritdoc /> public async Task <PlaidResult <ListOfInstitutionsWithTotalResponse> > GetListOfInstitutionsAsync(int count = 500, int offset = 0) { //conditions Condition.Ensures(count >= 0); Condition.Ensures(offset >= 0); //create the payload to pass var payload = new ListOfInstitutionsRequest(clientId, clientSecret, count, offset); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.Institutions_GetInstitutions, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <ListOfInstitutionsWithTotalResponse> result = new PlaidResult <ListOfInstitutionsWithTotalResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { ListOfInstitutionsWithTotalResponse listOfInstitutionsResponse = JsonConvert.DeserializeObject <ListOfInstitutionsWithTotalResponse>(responseJson); result.Value = listOfInstitutionsResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
/// <inheritdoc /> public async Task <PlaidResult <ItemResponse> > UpdateWebHookAsync(string accessToken, string webhook) { //conditions Condition.Requires(accessToken).IsNotNullOrWhiteSpace(); Condition.Requires(webhook).IsNotNullOrWhiteSpace(); //create the payload to pass var payload = new UpdateWebHookRequest(clientId, clientSecret, accessToken, webhook); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.ItemManagement_UpdateWebhook, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <ItemResponse> result = new PlaidResult <ItemResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { ItemResponse itemResponse = JsonConvert.DeserializeObject <ItemResponse>(responseJson); result.Value = itemResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
public async Task GetAuthAccountSuccess() { IHttpClientWrapper httpClient = this.GetMockHttpClient("AuthUserUsBank.json", HttpStatusCode.OK, HttpMethod.Post, "auth/get"); IPlaidClient testClient = this.GetPlaidClient(httpClient); PlaidResult <IList <Account> > result = await testClient.GetAuthAccountDataAsync(new AccessToken("test_wells")); Assert.IsNotNull(result); Assert.IsFalse(result.IsError); Assert.IsNotNull(result.Value); Assert.AreEqual(4, result.Value.Count); Account account = result.Value[0]; Assert.AreEqual("QPO8Jo8vdDHMepg41PBwckXm4KdK1yUdmXOwK", account.Id); Assert.AreEqual("KdDjmojBERUKx3JkDd9RuxA5EvejA4SENO4AA", account.ItemId); Assert.AreEqual("eJXpMzpR65FP4RYno6rzuA7OZjd9n3Hna0RYa", account.UserId); Assert.AreEqual(1203.42, account.AvailableBalance); Assert.AreEqual(1274.93, account.CurrentBalance); Assert.AreEqual(new InstitutionType("fake_institution"), account.InstitutionType); Assert.AreEqual(AccountType.Depository, account.AccountType); Assert.AreEqual(AccountSubType.Savings, account.AccountSubtype); Assert.IsNotNull(account.Metadata); Assert.AreEqual("Plaid Savings", account.Metadata["name"]); Assert.AreEqual("9606", account.Metadata["number"]); }
/// <inheritdoc /> public async Task <PlaidResult <bool> > DeleteUserAsync(AccessToken accessToken, ApiType api = ApiType.Connect) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest deleteRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.DeleteAsJsonAsync(GetEndpoint(api), deleteRequest); PlaidResult <bool> result = new PlaidResult <bool>(response.StatusCode == HttpStatusCode.OK); result.Exception = await this.ParseException(response); return(result); }
public async Task GetAuthAccountError() { IHttpClientWrapper httpClient = this.GetMockHttpClient("BadAccessToken.json", HttpStatusCode.Unauthorized, HttpMethod.Post, "auth/get"); IPlaidClient testClient = this.GetPlaidClient(httpClient); PlaidResult <IList <Account> > result = await testClient.GetAuthAccountDataAsync(new AccessToken("test_bad")); Assert.IsNotNull(result); Assert.IsNull(result.Value); Assert.IsTrue(result.IsError); Assert.IsNotNull(result.Exception); Assert.AreEqual((int)HttpStatusCode.Unauthorized, result.Exception.HttpStatusCode); Assert.AreEqual(ErrorCode.BadAccessToken, result.Exception.ErrorCode); Assert.IsFalse(string.IsNullOrWhiteSpace(result.Exception.Message)); Assert.IsFalse(string.IsNullOrWhiteSpace(result.Exception.Resolution)); }
/// <inheritdoc /> public async Task <PlaidResult <IList <Institution> > > GetInstitutionsAsync() { HttpResponseMessage response = await this.httpClient.GetAsync("institutions"); string responseJson = await response.Content.ReadAsStringAsync(); PlaidResult <IList <Institution> > result = new PlaidResult <IList <Institution> >(); if (response.StatusCode == HttpStatusCode.OK) { IList <InstitutionResponse> instResponse = JsonConvert.DeserializeObject <IList <InstitutionResponse> >(responseJson); result.Value = instResponse?.Select(x => x.ToInstitution()).ToList(); } result.Exception = await this.ParseException(response, responseJson); return(result); }
/// <inheritdoc /> public async Task <PlaidResult <Institution> > GetInstitutionAsync(string id) { Condition.Requires(id).IsNotNullOrWhiteSpace(); HttpResponseMessage response = await this.httpClient.GetAsync("institutions/" + id); string responseJson = await response.Content.ReadAsStringAsync(); PlaidResult <Institution> result = new PlaidResult <Institution>(); if (response.StatusCode == HttpStatusCode.OK) { InstitutionResponse instResponse = JsonConvert.DeserializeObject <InstitutionResponse>(responseJson); result.Value = instResponse?.ToInstitution(); } result.Exception = await this.ParseException(response, responseJson); return(result); }
/// <inheritdoc /> public async Task <PlaidResult <IList <Account> > > GetAccountsAsync(AccessToken accessToken) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest balanceRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.PostAsJsonAsync("balance", balanceRequest); // Re-use add user result since it contains the account objects of interest AddUserResult userResult = await this.ProcessAddOrAuthResponse(response); PlaidResult <IList <Account> > result = new PlaidResult <IList <Account> >(); if (userResult.Accounts != null) { result.Value = new List <Account>(userResult.Accounts); } result.Exception = userResult.Exception; return(result); }
/// <inheritdoc /> public async Task <PlaidResult <IList <Account> > > GetAuthAccountDataAsync(AccessToken accessToken) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest dataRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.PostAsJsonAsync(GetEndpoint(ApiType.Auth, "get"), dataRequest); string responseJson = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.OK) { // Can re-use AddUserResponse since it has accounts, just ignore transactions AddUserResponse dataResponse = JsonConvert.DeserializeObject <AddUserResponse>(responseJson); return(new PlaidResult <IList <Account> >(dataResponse?.Accounts?.Select(a => a.ToAccount()).ToList())); } PlaidResult <IList <Account> > errorResult = new PlaidResult <IList <Account> >(); errorResult.Exception = await this.ParseException(response, responseJson); return(errorResult); }
/// <inheritdoc /> public async Task <PlaidResult <RetrieveTransactionsResponse> > RetrieveTransactionsAsync(string accessToken, DateTimeOffset startDate, DateTimeOffset endDate, int count = 250, int offset = 0) { //conditions Condition.Requires(accessToken).IsNotNullOrWhiteSpace(); Condition.Requires(startDate).IsLessOrEqual(endDate); Condition.Requires(count).IsGreaterThan(0); Condition.Requires(offset).IsGreaterOrEqual(0); //create the payload to pass var payload = new RetrieveTransactionsRequest(clientId, clientSecret, accessToken, startDate, endDate, count, offset); //serialize object HttpContent content = ContentExtensions.ToJsonContent(payload); //post it and get the response HttpResponseMessage response = await this.httpClient.PostAsync(PlaidInformation.ProductAccessEndpoint_GetTransactions, content); //read the string string responseJson = await response.Content.ReadAsStringAsync(); //create the result PlaidResult <RetrieveTransactionsResponse> result = new PlaidResult <RetrieveTransactionsResponse>(responseJson); //is it ok if (response.StatusCode == HttpStatusCode.OK) { RetrieveTransactionsResponse retAccsResponse = JsonConvert.DeserializeObject <RetrieveTransactionsResponse>(responseJson); result.Value = retAccsResponse; } //parse the exception result.Exception = await this.ParseException(response, responseJson); //return return(result); }
/// <inheritdoc /> public async Task<PlaidResult<bool>> DeleteUserAsync(AccessToken accessToken, ApiType api = ApiType.Connect) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest deleteRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.DeleteAsJsonAsync(GetEndpoint(api), deleteRequest); PlaidResult<bool> result = new PlaidResult<bool>(response.StatusCode == HttpStatusCode.OK); result.Exception = await this.ParseException(response); return result; }
/// <inheritdoc /> public async Task<PlaidResult<Institution>> GetInstitutionAsync(string id) { Condition.Requires(id).IsNotNullOrWhiteSpace(); HttpResponseMessage response = await this.httpClient.GetAsync("institutions/" + id); string responseJson = await response.Content.ReadAsStringAsync(); PlaidResult<Institution> result = new PlaidResult<Institution>(); if (response.StatusCode == HttpStatusCode.OK) { InstitutionResponse instResponse = JsonConvert.DeserializeObject<InstitutionResponse>(responseJson); result.Value = instResponse?.ToInstitution(); } result.Exception = await this.ParseException(response, responseJson); return result; }
/// <inheritdoc /> public async Task<PlaidResult<IList<Institution>>> GetInstitutionsAsync() { HttpResponseMessage response = await this.httpClient.GetAsync("institutions"); string responseJson = await response.Content.ReadAsStringAsync(); PlaidResult<IList<Institution>> result = new PlaidResult<IList<Institution>>(); if (response.StatusCode == HttpStatusCode.OK) { IList<InstitutionResponse> instResponse = JsonConvert.DeserializeObject<IList<InstitutionResponse>>(responseJson); result.Value = instResponse?.Select(x => x.ToInstitution()).ToList(); } result.Exception = await this.ParseException(response, responseJson); return result; }
/// <inheritdoc /> public async Task<PlaidResult<IList<Account>>> GetAuthAccountDataAsync(AccessToken accessToken) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest dataRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.PostAsJsonAsync(GetEndpoint(ApiType.Auth, "get"), dataRequest); string responseJson = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.OK) { // Can re-use AddUserResponse since it has accounts, just ignore transactions AddUserResponse dataResponse = JsonConvert.DeserializeObject<AddUserResponse>(responseJson); return new PlaidResult<IList<Account>>(dataResponse?.Accounts?.Select(a => a.ToAccount()).ToList()); } PlaidResult<IList<Account>> errorResult = new PlaidResult<IList<Account>>(); errorResult.Exception = await this.ParseException(response, responseJson); return errorResult; }
/// <inheritdoc /> public async Task<PlaidResult<IList<Account>>> GetAccountsAsync(AccessToken accessToken) { Condition.Requires(accessToken).IsNotNull(); PlaidRequest balanceRequest = new PlaidRequest(this.clientId, this.clientSecret, accessToken.Value); HttpResponseMessage response = await this.httpClient.PostAsJsonAsync("balance", balanceRequest); // Re-use add user result since it contains the account objects of interest AddUserResult userResult = await this.ProcessAddOrAuthResponse(response); PlaidResult<IList<Account>> result = new PlaidResult<IList<Account>>(); if (userResult.Accounts != null) result.Value = new List<Account>(userResult.Accounts); result.Exception = userResult.Exception; return result; }