mirror of
https://github.com/hanzo-fi/stack.git
synced 2026-10-30 20:34:43 +00:00
2e03d96084
Co-authored-by: Maxence Maireaux <[email protected]> Co-authored-by: David Ragot <[email protected]>
2412 lines
80 KiB
Go
2412 lines
80 KiB
Go
// Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT.
|
|
|
|
package formancesdkgo
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"github.com/formancehq/formance-sdk-go/pkg/models/operations"
|
|
"github.com/formancehq/formance-sdk-go/pkg/models/sdkerrors"
|
|
"github.com/formancehq/formance-sdk-go/pkg/models/shared"
|
|
"github.com/formancehq/formance-sdk-go/pkg/utils"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
type Payments struct {
|
|
sdkConfiguration sdkConfiguration
|
|
}
|
|
|
|
func newPayments(sdkConfig sdkConfiguration) *Payments {
|
|
return &Payments{
|
|
sdkConfiguration: sdkConfig,
|
|
}
|
|
}
|
|
|
|
// AddAccountToPool - Add an account to a pool
|
|
// Add an account to a pool
|
|
func (s *Payments) AddAccountToPool(ctx context.Context, request operations.AddAccountToPoolRequest) (*operations.AddAccountToPoolResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/pools/{poolId}/accounts", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "AddAccountToPoolRequest", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.AddAccountToPoolResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ConnectorsTransfer - Transfer funds between Connector accounts
|
|
// Execute a transfer between two accounts.
|
|
func (s *Payments) ConnectorsTransfer(ctx context.Context, request operations.ConnectorsTransferRequest) (*operations.ConnectorsTransferResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/transfers", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "TransferRequest", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ConnectorsTransferResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TransferResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TransferResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// CreateBankAccount - Create a BankAccount in Payments and on the PSP
|
|
// Create a bank account in Payments and on the PSP.
|
|
func (s *Payments) CreateBankAccount(ctx context.Context, request shared.BankAccountRequest) (*operations.CreateBankAccountResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/bank-accounts"
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "Request", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.CreateBankAccountResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.BankAccountResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.BankAccountResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// CreatePayment - Create a payment
|
|
// Create a payment
|
|
func (s *Payments) CreatePayment(ctx context.Context, request shared.PaymentRequest) (*operations.CreatePaymentResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/payments"
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "Request", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.CreatePaymentResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PaymentResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PaymentResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// CreatePool - Create a Pool
|
|
// Create a Pool
|
|
func (s *Payments) CreatePool(ctx context.Context, request shared.PoolRequest) (*operations.CreatePoolResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/pools"
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "Request", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.CreatePoolResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PoolResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PoolResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// CreateTransferInitiation - Create a TransferInitiation
|
|
// Create a transfer initiation
|
|
func (s *Payments) CreateTransferInitiation(ctx context.Context, request shared.TransferInitiationRequest) (*operations.CreateTransferInitiationResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/transfer-initiations"
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "Request", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.CreateTransferInitiationResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TransferInitiationResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TransferInitiationResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// DeletePool - Delete a Pool
|
|
// Delete a pool by its id.
|
|
func (s *Payments) DeletePool(ctx context.Context, request operations.DeletePoolRequest) (*operations.DeletePoolResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/pools/{poolId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "DELETE", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.DeletePoolResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// DeleteTransferInitiation - Delete a transfer initiation
|
|
// Delete a transfer initiation by its id.
|
|
func (s *Payments) DeleteTransferInitiation(ctx context.Context, request operations.DeleteTransferInitiationRequest) (*operations.DeleteTransferInitiationResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/transfer-initiations/{transferId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "DELETE", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.DeleteTransferInitiationResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetAccountBalances - Get account balances
|
|
func (s *Payments) GetAccountBalances(ctx context.Context, request operations.GetAccountBalancesRequest) (*operations.GetAccountBalancesResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/accounts/{accountId}/balances", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetAccountBalancesResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.BalancesCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.BalancesCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetBankAccount - Get a bank account created by user on Formance
|
|
func (s *Payments) GetBankAccount(ctx context.Context, request operations.GetBankAccountRequest) (*operations.GetBankAccountResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/bank-accounts/{bankAccountId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetBankAccountResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.BankAccountResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.BankAccountResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetConnectorTask - Read a specific task of the connector
|
|
// Get a specific task associated to the connector.
|
|
//
|
|
// Deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
|
|
func (s *Payments) GetConnectorTask(ctx context.Context, request operations.GetConnectorTaskRequest) (*operations.GetConnectorTaskResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/tasks/{taskId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetConnectorTaskResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TaskResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TaskResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetConnectorTaskV1 - Read a specific task of the connector
|
|
// Get a specific task associated to the connector.
|
|
func (s *Payments) GetConnectorTaskV1(ctx context.Context, request operations.GetConnectorTaskV1Request) (*operations.GetConnectorTaskV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}/tasks/{taskId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetConnectorTaskV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TaskResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TaskResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetPayment - Get a payment
|
|
func (s *Payments) GetPayment(ctx context.Context, request operations.GetPaymentRequest) (*operations.GetPaymentResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/payments/{paymentId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetPaymentResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PaymentResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PaymentResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetPool - Get a Pool
|
|
func (s *Payments) GetPool(ctx context.Context, request operations.GetPoolRequest) (*operations.GetPoolResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/pools/{poolId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetPoolResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PoolResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PoolResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetPoolBalances - Get pool balances
|
|
func (s *Payments) GetPoolBalances(ctx context.Context, request operations.GetPoolBalancesRequest) (*operations.GetPoolBalancesResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/pools/{poolId}/balances", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetPoolBalancesResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PoolBalancesResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PoolBalancesResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// GetTransferInitiation - Get a transfer initiation
|
|
func (s *Payments) GetTransferInitiation(ctx context.Context, request operations.GetTransferInitiationRequest) (*operations.GetTransferInitiationResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/transfer-initiations/{transferId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.GetTransferInitiationResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TransferInitiationResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TransferInitiationResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// InstallConnector - Install a connector
|
|
// Install a connector by its name and config.
|
|
func (s *Payments) InstallConnector(ctx context.Context, request operations.InstallConnectorRequest) (*operations.InstallConnectorResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "ConnectorConfig", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.InstallConnectorResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 201:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ConnectorResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ConnectorResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListAllConnectors - List all installed connectors
|
|
// List all installed connectors.
|
|
func (s *Payments) ListAllConnectors(ctx context.Context) (*operations.ListAllConnectorsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/connectors"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListAllConnectorsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ConnectorsResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ConnectorsResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListBankAccounts - List bank accounts created by user on Formance
|
|
// List all bank accounts created by user on Formance.
|
|
func (s *Payments) ListBankAccounts(ctx context.Context, request operations.ListBankAccountsRequest) (*operations.ListBankAccountsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/bank-accounts"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListBankAccountsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.BankAccountsCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.BankAccountsCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListConfigsAvailableConnectors - List the configs of each available connector
|
|
// List the configs of each available connector.
|
|
func (s *Payments) ListConfigsAvailableConnectors(ctx context.Context) (*operations.ListConfigsAvailableConnectorsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/connectors/configs"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListConfigsAvailableConnectorsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ConnectorsConfigsResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ConnectorsConfigsResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListConnectorTasks - List tasks from a connector
|
|
// List all tasks associated with this connector.
|
|
//
|
|
// Deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
|
|
func (s *Payments) ListConnectorTasks(ctx context.Context, request operations.ListConnectorTasksRequest) (*operations.ListConnectorTasksResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/tasks", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListConnectorTasksResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TasksCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TasksCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListConnectorTasksV1 - List tasks from a connector
|
|
// List all tasks associated with this connector.
|
|
func (s *Payments) ListConnectorTasksV1(ctx context.Context, request operations.ListConnectorTasksV1Request) (*operations.ListConnectorTasksV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}/tasks", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListConnectorTasksV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TasksCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TasksCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListPayments - List payments
|
|
func (s *Payments) ListPayments(ctx context.Context, request operations.ListPaymentsRequest) (*operations.ListPaymentsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/payments"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListPaymentsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PaymentsCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PaymentsCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListPools - List Pools
|
|
func (s *Payments) ListPools(ctx context.Context, request operations.ListPoolsRequest) (*operations.ListPoolsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/pools"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListPoolsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PoolsCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PoolsCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ListTransferInitiations - List Transfer Initiations
|
|
func (s *Payments) ListTransferInitiations(ctx context.Context, request operations.ListTransferInitiationsRequest) (*operations.ListTransferInitiationsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/transfer-initiations"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ListTransferInitiationsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.TransferInitiationsCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.TransferInitiationsCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// PaymentsgetAccount - Get an account
|
|
func (s *Payments) PaymentsgetAccount(ctx context.Context, request operations.PaymentsgetAccountRequest) (*operations.PaymentsgetAccountResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/accounts/{accountId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.PaymentsgetAccountResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.PaymentsAccountResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.PaymentsAccountResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// PaymentsgetServerInfo - Get server info
|
|
func (s *Payments) PaymentsgetServerInfo(ctx context.Context) (*operations.PaymentsgetServerInfoResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/_info"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.PaymentsgetServerInfoResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ServerInfo
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ServerInfo = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// PaymentslistAccounts - List accounts
|
|
func (s *Payments) PaymentslistAccounts(ctx context.Context, request operations.PaymentslistAccountsRequest) (*operations.PaymentslistAccountsResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url := strings.TrimSuffix(baseURL, "/") + "/api/payments/accounts"
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
if err := utils.PopulateQueryParams(ctx, req, request, nil); err != nil {
|
|
return nil, fmt.Errorf("error populating query params: %w", err)
|
|
}
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.PaymentslistAccountsResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.AccountsCursor
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.AccountsCursor = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ReadConnectorConfig - Read the config of a connector
|
|
// Read connector config
|
|
//
|
|
// Deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
|
|
func (s *Payments) ReadConnectorConfig(ctx context.Context, request operations.ReadConnectorConfigRequest) (*operations.ReadConnectorConfigResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/config", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ReadConnectorConfigResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ConnectorConfigResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ConnectorConfigResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ReadConnectorConfigV1 - Read the config of a connector
|
|
// Read connector config
|
|
func (s *Payments) ReadConnectorConfigV1(ctx context.Context, request operations.ReadConnectorConfigV1Request) (*operations.ReadConnectorConfigV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}/config", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "application/json")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ReadConnectorConfigV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 200:
|
|
switch {
|
|
case utils.MatchContentType(contentType, `application/json`):
|
|
var out shared.ConnectorConfigResponse
|
|
if err := utils.UnmarshalJsonFromResponseBody(bytes.NewBuffer(rawBody), &out, ""); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res.ConnectorConfigResponse = &out
|
|
default:
|
|
return nil, sdkerrors.NewSDKError(fmt.Sprintf("unknown content-type received: %s", contentType), httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// RemoveAccountFromPool - Remove an account from a pool
|
|
// Remove an account from a pool by its id.
|
|
func (s *Payments) RemoveAccountFromPool(ctx context.Context, request operations.RemoveAccountFromPoolRequest) (*operations.RemoveAccountFromPoolResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/pools/{poolId}/accounts/{accountId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "DELETE", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.RemoveAccountFromPoolResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ResetConnector - Reset a connector
|
|
// Reset a connector by its name.
|
|
// It will remove the connector and ALL PAYMENTS generated with it.
|
|
//
|
|
// Deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
|
|
func (s *Payments) ResetConnector(ctx context.Context, request operations.ResetConnectorRequest) (*operations.ResetConnectorResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/reset", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ResetConnectorResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// ResetConnectorV1 - Reset a connector
|
|
// Reset a connector by its name.
|
|
// It will remove the connector and ALL PAYMENTS generated with it.
|
|
func (s *Payments) ResetConnectorV1(ctx context.Context, request operations.ResetConnectorV1Request) (*operations.ResetConnectorV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}/reset", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.ResetConnectorV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// RetryTransferInitiation - Retry a failed transfer initiation
|
|
// Retry a failed transfer initiation
|
|
func (s *Payments) RetryTransferInitiation(ctx context.Context, request operations.RetryTransferInitiationRequest) (*operations.RetryTransferInitiationResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/transfer-initiations/{transferId}/retry", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.RetryTransferInitiationResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// UdpateTransferInitiationStatus - Update the status of a transfer initiation
|
|
// Update a transfer initiation status
|
|
func (s *Payments) UdpateTransferInitiationStatus(ctx context.Context, request operations.UdpateTransferInitiationStatusRequest) (*operations.UdpateTransferInitiationStatusResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/transfer-initiations/{transferId}/status", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "UpdateTransferInitiationStatusRequest", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.UdpateTransferInitiationStatusResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// UninstallConnector - Uninstall a connector
|
|
// Uninstall a connector by its name.
|
|
//
|
|
// Deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
|
|
func (s *Payments) UninstallConnector(ctx context.Context, request operations.UninstallConnectorRequest) (*operations.UninstallConnectorResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "DELETE", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.UninstallConnectorResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// UninstallConnectorV1 - Uninstall a connector
|
|
// Uninstall a connector by its name.
|
|
func (s *Payments) UninstallConnectorV1(ctx context.Context, request operations.UninstallConnectorV1Request) (*operations.UninstallConnectorV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "DELETE", url, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.UninstallConnectorV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// UpdateConnectorConfigV1 - Update the config of a connector
|
|
// Update connector config
|
|
func (s *Payments) UpdateConnectorConfigV1(ctx context.Context, request operations.UpdateConnectorConfigV1Request) (*operations.UpdateConnectorConfigV1Response, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/connectors/{connector}/{connectorId}/config", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, false, false, "ConnectorConfig", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.UpdateConnectorConfigV1Response{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
// UpdateMetadata - Update metadata
|
|
func (s *Payments) UpdateMetadata(ctx context.Context, request operations.UpdateMetadataRequest) (*operations.UpdateMetadataResponse, error) {
|
|
baseURL := utils.ReplaceParameters(s.sdkConfiguration.GetServerDetails())
|
|
url, err := utils.GenerateURL(ctx, baseURL, "/api/payments/payments/{paymentId}/metadata", request, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error generating URL: %w", err)
|
|
}
|
|
|
|
bodyReader, reqContentType, err := utils.SerializeRequestBody(ctx, request, true, false, "RequestBody", "json", `request:"mediaType=application/json"`)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error serializing request body: %w", err)
|
|
}
|
|
if bodyReader == nil {
|
|
return nil, fmt.Errorf("request body is required")
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "PATCH", url, bodyReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating request: %w", err)
|
|
}
|
|
req.Header.Set("Accept", "*/*")
|
|
req.Header.Set("user-agent", s.sdkConfiguration.UserAgent)
|
|
|
|
req.Header.Set("Content-Type", reqContentType)
|
|
|
|
client := s.sdkConfiguration.SecurityClient
|
|
|
|
httpRes, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error sending request: %w", err)
|
|
}
|
|
if httpRes == nil {
|
|
return nil, fmt.Errorf("error sending request: no response")
|
|
}
|
|
|
|
contentType := httpRes.Header.Get("Content-Type")
|
|
|
|
res := &operations.UpdateMetadataResponse{
|
|
StatusCode: httpRes.StatusCode,
|
|
ContentType: contentType,
|
|
RawResponse: httpRes,
|
|
}
|
|
|
|
rawBody, err := io.ReadAll(httpRes.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %w", err)
|
|
}
|
|
httpRes.Body.Close()
|
|
httpRes.Body = io.NopCloser(bytes.NewBuffer(rawBody))
|
|
switch {
|
|
case httpRes.StatusCode == 204:
|
|
case httpRes.StatusCode >= 400 && httpRes.StatusCode < 500:
|
|
fallthrough
|
|
case httpRes.StatusCode >= 500 && httpRes.StatusCode < 600:
|
|
return nil, sdkerrors.NewSDKError("API error occurred", httpRes.StatusCode, string(rawBody), httpRes)
|
|
}
|
|
|
|
return res, nil
|
|
}
|