/// <summary>
/// Gets merchant account. Privatbank API reference: <https://api.privatbank.ua/#p24/balance>.
/// </summary>
/// <param name="password">Private merchant password.</param>
/// <param name="merchantId">Merchant id.</param>
/// <param name="cardNumber">Merchant assossiated card number.</param>
/// <returns></returns>
public async Task <PrivatbankAccount> GetMerchantAccountAsync(string password, string merchantId, string cardNumber)
{
AccountBalanceRequest request = new AccountBalanceRequest(password, merchantId, cardNumber);
HttpResponseMessage response = await _privatbankClient.GetMerchantDataAsync("balance", request.Xml);
string xml = await response.Content.ReadAsStringAsync();
AccountParser parser = new AccountParser();
PrivatbankAccount account = parser.Parse(xml);
return(account);
}
/// <summary>
/// Get Account Balance
/// </summary>
/// <returns></returns>
public async Task <ClientResponse <AccountBalanceResponse> > AccountBalance()
{
var token = await GetToken();
var accountBalanceRquest = new AccountBalanceRequest
{
SubscriptionKey = remittanceConfig.SubscriptionKey,
RequestUri = RemittanceRequestUri.AccountBalance,
Token = token?.AccessToken
};
return(await accountBalanceClient.AccountBalance(accountBalanceRquest));
}
public virtual Response <object> AccountBalance(AccountBalanceRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.AccountBalance");
scope.Start();
try
{
return(RestClient.AccountBalance(body, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual async Task <Response <object> > AccountBalanceAsync(AccountBalanceRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.AccountBalance");
scope.Start();
try
{
return(await RestClient.AccountBalanceAsync(body, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public AccountBalanceDataPackage Query(int beginYear, int beginPeriod, int endYear, int endPeriod)
{
var request = new AccountBalanceRequest
{
BeginPeriod = beginPeriod,
BeginYear = beginYear,
EndPeriod = endPeriod,
EndYear = endYear
};
AccountBalanceResponse rsp = Execute(request);
AccountBalanceDataPackage package = new AccountBalanceDataPackage();
package.ListBeginBalnace = rsp.ListBeginBalnace;
package.ListCurrentOccurs = rsp.ListCurrentOccurs;
return(package);
}
public void GetFromJson_WhenRequestIsNotValid_ThrowsInvalidOperationException()
{
var json = "validJson";
var accountBalanceRequest = new AccountBalanceRequest();
string reason;
accountRequestParser.Setup(p => p.GetAccountBalanceRequestFromString(json))
.Returns(accountBalanceRequest);
validator.Setup(v => v.IsValid(It.IsAny <AccountBalanceRequest>(), out reason)).Returns(false);
TestDelegate act = () => service.GetFromJson(json);
Assert.That(act, Throws.InvalidOperationException);
accountRequestParser.Verify(p => p.GetAccountBalanceRequestFromString(json), Times.Once);
validator.Verify(v => v.IsValid(It.IsAny <AccountBalanceRequest>(), out reason), Times.Once);
reportGenerator.Verify(r => r.Generate(It.IsAny <Account>(), It.IsAny <DateTime>()), Times.Never);
}
public async Task <IActionResult> GetAccountBalance()
{
Mpesa mpesa = new Mpesa();
AccountBalanceRequest accountBalanceRequest = new AccountBalanceRequest
{
Initiator = "testapi",
Password = "******",
PartyA = "600214",
Remarks = "Test",
QueueTimeOutURL = "https://testurl.co.ke",
ResultURL = "https://testurl.co.ke"
};
var response = await mpesa.AccountBalanceAsync(_options.ConsumerKey, _options.ConsumerSecret, accountBalanceRequest);
return(Json(response));
}
public void IsValid_WhenRequestIsValid_ReturnsTrue()
{
var request = new AccountBalanceRequest
{
Accounts = new List <Account>
{
new Account {
CurrencyCode = "GBP"
},
}
};
var result = validator.IsValid(request, out string reason);
Assert.That(result, Is.True);
Assert.That(reason, Is.Null);
}
public void IsValid_WhenRequestContainsMultipleCurrencies_ReturnsFalse()
{
var request = new AccountBalanceRequest
{
Accounts = new List <Account>
{
new Account {
CurrencyCode = "GBP"
},
new Account {
CurrencyCode = "HUF"
},
}
};
var result = validator.IsValid(request, out string reason);
Assert.That(result, Is.False);
Assert.That(reason, Is.EqualTo("Accounts using different currency."));
}
/// <summary>
/// Get account balance for Product
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ClientResponse <AccountBalanceResponse> > AccountBalance(AccountBalanceRequest request)
{
if (string.IsNullOrEmpty(request.Token))
{
return(new ClientResponse <AccountBalanceResponse> {
Status = Status.Failed.ToString(), StatusCode = HttpStatusCode.Unauthorized
});
}
var headers = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>(Constants.SubKeyHeader, request.SubscriptionKey),
new KeyValuePair <string, string>(Constants.AuthHeader, $"Bearer {request.Token}"),
};
var response = await baseClient.GetAsync <AccountBalanceResponse>(request.RequestUri, Constants.MtnClient, headers);
response.Status = response.StatusCode == HttpStatusCode.OK ? Status.Successful.ToString() : Status.Failed.ToString();
return(response);
}
public void GetFromFile_ReturnsReport()
{
var filePath = "validFilePath";
var accountBalanceRequest = new AccountBalanceRequest {
Accounts = new List <Account> {
new Account()
}
};
string reason;
accountRequestParser.Setup(p => p.GetAccountBalanceRequestFromFile(filePath))
.Returns(accountBalanceRequest);
validator.Setup(v => v.IsValid(It.IsAny <AccountBalanceRequest>(), out reason)).Returns(true);
TestDelegate act = () => service.GetFromFile(filePath);
Assert.That(act, Throws.Nothing);
accountRequestParser.Verify(p => p.GetAccountBalanceRequestFromFile(It.IsAny <string>()), Times.Once);
validator.Verify(v => v.IsValid(It.IsAny <AccountBalanceRequest>(), out reason), Times.Once);
reportGenerator.Verify(r => r.Generate(It.IsAny <Account>(), It.IsAny <DateTime>()), Times.Once);
}
public FinanceResponse Query(AccountBalanceRequest request)
{
if (request == null)
{
throw new FinanceException(FinanceResult.NULL);
}
var beginYear = request.BeginYear;
var beginPeriod = request.BeginPeriod;
var endYear = request.EndYear;
var endPeriod = request.EndPeriod;
var prevPeriod = CommonUtils.CalcPrevPeriod(new PeridStrunct {
Year = beginYear, Period = beginPeriod
});
List <AccountAmountItem> lstBegin = service.QuerySettled(prevPeriod.Year, prevPeriod.Period);
List <AccountAmountItem> lstCurrent = service.QueryOccurs(beginYear, beginPeriod, endYear, endPeriod);
return(new AccountBalanceResponse {
ListBeginBalnace = lstBegin, ListCurrentOccurs = lstCurrent
});
}
static async Task <AccountBalanceResponse> AccountBalanceAsync()
{
AccountBalanceRequest _accountBalanceRequest = new AccountBalanceRequest()
.AsSecurityCredential("Safaricom474!")
.AsEntity("testapi474", "600474")
.AsCommandID("AccountBalance")
.AsEndpoints("https://safaricom.api", "https://safaricom.api")
.AsComments("Test")
.AsIdentifierType(4);
AccountBalanceResponse _response = await _safaricomApiClient.PostPaymentRequestAsync(_accountBalanceRequest);
if (_response.ErrorCode == null)
{
Console.WriteLine("===========================================");
Console.WriteLine("=====Account Balance Success Response======");
Console.WriteLine("===========================================");
Console.WriteLine(Environment.NewLine);
Console.WriteLine(_response.OriginatorConversationID + Environment.NewLine + _response.ConversationID + Environment.NewLine + _response.ResponseDescription);
Console.WriteLine(Environment.NewLine);
}
else
{
Console.WriteLine("===========================================");
Console.WriteLine("======Account Balance Error Response=======");
Console.WriteLine("===========================================");
Console.WriteLine(Environment.NewLine);
Console.WriteLine(_response.ErrorCode + Environment.NewLine + _response.ErrorMessage + Environment.NewLine + _response.ErrorRequestId);
Console.WriteLine(Environment.NewLine);
}
return(_response);
}
public async Task <string[]> AccountBalanceAsync(string consumerKey, string consumersecret, AccountBalanceRequest accountBalance, bool isSandbox = true)
{
string security = Encryption(accountBalance.Password.Trim());
accountBalance.SecurityCredential = security;
accountBalance.IdentifierType = IdentifierType.OrganizationShortCode;
accountBalance.CommandID = "AccountBalance";
JObject jObject = JObject.FromObject(accountBalance);
string auth = Authenticate(consumerKey, consumersecret, isSandbox);
string baseUrl = getBaseUrl(isSandbox);
return(await SendApiRequestAsync(auth, baseUrl, "mpesa/accountbalance/v1/query", jObject));
}
private void HandleBalanceRequest(AccountBalanceRequest msg)
{
Sender.Tell(_balance);
}
public void GetAccountRequestFromString_WhenInputIsGood_ReturnsAccountRequest(string input, AccountBalanceRequest expected)
{
var result = parser.GetAccountBalanceRequestFromString(input);
Assert.That(result, Is.Not.Null);
Assert.That(result.BrandName, Is.EqualTo(expected.BrandName));
Assert.That(result.DataSourceName, Is.EqualTo(expected.DataSourceName));
Assert.That(result.RequestDate, Is.EqualTo(expected.RequestDate));
Assert.That(result.Accounts.Count, Is.EqualTo(expected.Accounts.Count));
//...
}
