コード例 #1
0
ファイル: PlaidTest.cs プロジェクト: usaf-cloud/StrayG
        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);
        }
コード例 #2
0
ファイル: PlaidTest.cs プロジェクト: usaf-cloud/StrayG
        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);
        }
コード例 #3
0
ファイル: PlaidTest.cs プロジェクト: usaf-cloud/StrayG
        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);
        }
コード例 #4
0
        /// <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);
        }
コード例 #5
0
ファイル: PlaidTest.cs プロジェクト: usaf-cloud/StrayG
        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);
        }
コード例 #6
0
        /// <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);
        }
コード例 #7
0
        /// <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);
        }
コード例 #8
0
ファイル: PlaidTest.cs プロジェクト: usaf-cloud/StrayG
        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);
        }
コード例 #9
0
        /// <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);
        }
コード例 #10
0
        /// <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);
        }
コード例 #11
0
        /// <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);
        }
コード例 #12
0
        /// <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);
        }
コード例 #13
0
        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"]);
        }
コード例 #14
0
        /// <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);
        }
コード例 #15
0
        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));
        }
コード例 #16
0
        /// <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);
        }
コード例 #17
0
        /// <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);
        }
コード例 #18
0
        /// <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);
        }
コード例 #19
0
        /// <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);
        }
コード例 #20
0
        /// <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);
        }
コード例 #21
0
ファイル: HttpPlaidClient.cs プロジェクト: tyjen/Plaid.Net
        /// <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;
        }
コード例 #22
0
ファイル: HttpPlaidClient.cs プロジェクト: tyjen/Plaid.Net
        /// <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;
        }
コード例 #23
0
ファイル: HttpPlaidClient.cs プロジェクト: tyjen/Plaid.Net
        /// <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;
        }
コード例 #24
0
ファイル: HttpPlaidClient.cs プロジェクト: tyjen/Plaid.Net
        /// <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;
        }
コード例 #25
-1
ファイル: HttpPlaidClient.cs プロジェクト: tyjen/Plaid.Net
        /// <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;
        }