BetfairApi/SuccessfulCode.BetfairApi/AccountApiClient.cs

using System.Net.Http;
using System.Threading.Tasks;
using SuccessfulCode.BetfairApi.AccountModels;
using SuccessfulCode.BetfairApi.AccountModels.Enums;

namespace SuccessfulCode.BetfairApi
{
    public class AccountApiClient
    {
        private readonly HttpClient _client;
        private Authentication _authentication;
        private const string _endpoint = "https://api.betfair.com/exchange/account/rest/v1.0/";

        public AccountApiClient(Authentication authentication)
        {
            _client = new HttpClient();
            _authentication = authentication;
        }


        /// <summary>
        /// Create 2 application keys for given user; one active and the other delayed
        /// </summary>
        public async Task<DeveloperApp> CreateDeveloperAppKeys(string appName)
        {
            var request = new
            {
                appName
            };
            var result = await ExecuteRequest<DeveloperApp>(_endpoint + "createDeveloperAppKeys/", request);
            return result;
        }

        /// <summary>
        /// Get all application keys owned by the given developer/vendor
        /// </summary>
        public async Task<DeveloperApp[]> GetDeveloperAppKeys()
        {
            var result = await ExecuteRequest<DeveloperApp[]>(_endpoint + "getDeveloperAppKeys/");
            return result;
        }

        /// <summary>
        /// Get available to bet amount.
        /// </summary>
        public async Task<AccountFundsResponse> GetAccountFunds(Wallet? wallet = null)
        {
            var request = new
            {
                wallet
            };
            var result = await ExecuteRequest<AccountFundsResponse>(_endpoint + "getAccountFunds/", request);
            return result;
        }

        /// <summary>
        /// Transfer funds between wallets
        /// </summary>
        public async Task<TransferResponse> TransferFunds(Wallet from, Wallet to, double amount)
        {
            var request = new
            {
                from,
                to,
                amount
            };
            var result = await ExecuteRequest<TransferResponse>(_endpoint + "transferFunds/", request);
            return result;
        }

        /// <summary>
        /// Get Account details.
        /// </summary>
        public async Task<AccountDetailsResponse> GetAccountDetails()
        {
            var result = await ExecuteRequest<AccountDetailsResponse>(_endpoint + "getAccountDetails/");
            return result;
        }

        /// <summary>
        /// Get vendor client id for customer account.
        /// </summary>
        public async Task<string> GetVendorClientId()
        {
            var result = await ExecuteRequest<string>(_endpoint + "getVendorClientId/");
            return result;
        }

        /// <summary>
        /// Returns the newly generate subscription token
        /// </summary>
        public async Task<string> GetApplicationSubscriptionToken(int? subscriptionLength = null, string clientReference = null)
        {
            var request = new
            {
                subscriptionLength,
                clientReference
            };
            var result = await ExecuteRequest<string>(_endpoint + "getApplicationSubscriptionToken/", request);
            return result;
        }

        /// <summary>
        /// Activate the subscription token for the customer
        /// </summary>
        public async Task<Status> ActivateApplicationSubscription(string subscriptionToken)
        {
            var request = new
            {
                subscriptionToken
            };
            var result = await ExecuteRequest<Status>(_endpoint + "activateApplicationSubscription/", request);
            return result;
        }

        /// <summary>
        /// Cancel application subscription
        /// </summary>
        public async Task<Status> CancelApplicationSubscription(string subscriptionToken)
        {
            var request = new
            {
                subscriptionToken
            };
            var result = await ExecuteRequest<Status>(_endpoint + "cancelApplicationSubscription/", request);
            return result;
        }

        /// <summary>
        /// Update an application subscription with a new expiry date
        /// </summary>
        public async Task<string> UpdateApplicationSubscription(string vendorClientId, int subscriptionLength)
        {
            var request = new
            {
                vendorClientId,
                subscriptionLength
            };
            var result = await ExecuteRequest<string>(_endpoint + "updateApplicationSubscription/", request);
            return result;
        }

        /// <summary>
        /// List of subscription tokens for an application
        /// </summary>
        public async Task<ApplicationSubscription[]> ListApplicationSubscriptionTokens(SubscriptionStatus? subscriptionStatus = null)
        {
            var request = new
            {
                subscriptionStatus
            };
            var result = await ExecuteRequest<ApplicationSubscription[]>(_endpoint + "listApplicationSubscriptionTokens/", request);
            return result;
        }

        /// <summary>
        /// List of subscription tokens associated with the account
        /// </summary>
        public async Task<AccountSubscription[]> ListAccountSubscriptionTokens()
        {
            var result = await ExecuteRequest<AccountSubscription[]>(_endpoint + "listAccountSubscriptionTokens/");
            return result;
        }

        /// <summary>
        /// Identify all subscriptions, regardless of status, for a single client for a single application key.
        /// The operation may be called by either the application key owner or a client.
        /// </summary>
        public async Task<SubscriptionHistory[]> GetApplicationSubscriptionHistory(string vendorClientId = null, string applicationKey = null)
        {
            var request = new
            {
                vendorClientId,
                applicationKey
            };
            var result = await ExecuteRequest<SubscriptionHistory[]>(_endpoint + "getApplicationSubscriptionHistory/", request);
            return result;
        }

        /// <summary>
        /// Get account statement
        /// </summary>
        public async Task<AccountStatementReport> GetAccountStatement(string locale = null, int? fromRecord = null, int? recordCount = null, TimeRange itemDateRange = null, IncludeItem? includeItem = null, Wallet? wallet = null)
        {
            var request = new
            {
                locale,
                fromRecord,
                recordCount,
                itemDateRange,
                includeItem,
                wallet
            };
            var result = await ExecuteRequest<AccountStatementReport>(_endpoint + "getAccountStatement/", request);
            return result;
        }

        /// <summary>
        /// Returns a list of currency rates based on given currency
        /// </summary>
        public async Task<CurrencyRate[]> ListCurrencyRates(string fromCurrency = null)
        {
            var request = new
            {
                fromCurrency
            };
            var result = await ExecuteRequest<CurrencyRate[]>(_endpoint + "listCurrencyRates/", request);
            return result;
        }

        /// <summary>
        /// Generate auth code for web vendor, used to get vendor session
        /// </summary>
        public async Task<AuthorisationResponse> GetAuthorisationCode(string vendorId)
        {
            var request = new
            {
                vendorId
            };
            var result = await ExecuteRequest<AuthorisationResponse>(_endpoint + "getAuthorisationCode/", request);
            return result;
        }

        /// <summary>
        /// Generate web vendor session based on a standard session identifiable by auth code, vendor secret and app key
        /// </summary>
        public async Task<VendorAccessTokenInfo> Token(string client_id, string client_secret, GrantType grant_type, string code = null, string refresh_token = null)
        {
            var request = new
            {
                client_id,
                grant_type,
                code,
                client_secret,
                refresh_token
            };
            var result = await ExecuteRequest<VendorAccessTokenInfo>(_endpoint + "token/", request);
            return result;
        }

        /// <summary>
        /// Return details about a vendor from its identifier. Response includes Vendor Name and URL.
        /// </summary>
        public async Task<VendorDetails> GetVendorDetails(string vendorId)
        {
            var request = new
            {
                vendorId
            };
            var result = await ExecuteRequest<VendorDetails>(_endpoint + "getVendorDetails/", request);
            return result;
        }

        /// <summary>
        /// Remove the link between an account and a vendor web app. This will remove the refreshToken for this user-vendor pair subscription.
        /// </summary>
        public async Task<Status> RevokeAccessToWebApp(long vendorId)
        {
            var request = new
            {
                vendorId
            };
            var result = await ExecuteRequest<Status>(_endpoint + "revokeAccessToWebApp/", request);
            return result;
        }

        /// <summary>
        /// Retrieve all vendors applications currently subscribed to by the user making the request
        /// </summary>
        public async Task<VendorDetails[]> ListAuthorizedWebApps()
        {
            var result = await ExecuteRequest<VendorDetails[]>(_endpoint + "listAuthorizedWebApps/");
            return result;
        }

        /// <summary>
        /// Return whether an account has authorised a web app.
        /// </summary>
        public async Task<bool> IsAccountSubscribedToWebApp(string vendorId)
        {
            var request = new
            {
                vendorId
            };
            var result = await ExecuteRequest<bool>(_endpoint + "isAccountSubscribedToWebApp/", request);
            return result;
        }

        /// <summary>
        /// Return relation between a list of users and an affiliate
        /// </summary>
        public async Task<AffiliateRelation[]> GetAffiliateRelation(string[] vendorClientIds)
        {
            var request = new
            {
                vendorClientIds
            };
            var result = await ExecuteRequest<AffiliateRelation[]>(_endpoint + "getAffiliateRelation/", request);
            return result;
        }

        private Task<T> ExecuteRequest<T>(string endpoint, object request = null)
        {
            return _authentication.ExecuteRequest<T>(endpoint, request);
        }
    }
}