public override async Task <GetBalanceReply> GetBalance(GetBalanceRequest request, ServerCallContext context)
{
try
{
var client = LyraRestClient.Create(_config["network"], Environment.OSVersion.ToString(), "LyraBroker", "1.0");
var wallet = new TransitWallet(request.PrivateKey, client);
var result = await wallet.ReceiveAsync();
if (result == Lyra.Core.Blocks.APIResultCodes.Success)
{
var blances = await wallet.GetBalanceAsync();
if (blances != null)
{
var msg = new GetBalanceReply {
AccountId = wallet.AccountId
};
foreach (var kvp in blances)
{
msg.Balances.Add(new LyraBalance {
Ticker = kvp.Key, Balance = kvp.Value / 100000000
});
}
return(msg);
}
}
}
catch (Exception ex)
{
_logger.LogWarning("In OpenWallet: " + ex.ToString());
}
return(new GetBalanceReply());
}
public GetBalanceResponseContainer GetBalance(GetBalanceRequest request)
{
var result = _walletRepository.GetBalance(new Internal.Wallet.DTO.GetBalanceRequest()
{
Currency = request.Currency,
MerchantId = _merchantAuthInfo.MerchantId,
Token = request.Token,
UserId = request.UserId,
});
if (200 != result.StatusCode)
{
return(new GetBalanceResponseContainer {
StatusCode = (StatusCodes)result.StatusCode
});
}
return(new GetBalanceResponseContainer
{
StatusCode = (StatusCodes)result.StatusCode,
Data = new GetBalanceResponse
{
Balance = result.Data.Balance
}
});
}
internal GetBalanceResponseContainer GetBalance(GetBalanceRequest model)
{
var client = new RestClient
{
BaseUrl = new Uri(AuthInfo.BaseUrl)
};
var request = new RestRequest
{
Resource = "GetBalance",
Method = Method.POST
};
var rawHash = $"{model.Currency}|{model.MerchantId}|{model.Token}|{model.UserId}|{AuthInfo.PrivateKey}";
var hash = GetSha256(rawHash);
model.Hash = hash;
request.AddJsonBody(model);
var response = client.Execute <GetBalanceResponseContainer>(request);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new CantConnectToServerException(response);
}
return(response.Data);
}
public Task <GetBalanceResponse> GetBalance(GetBalanceRequest request)
{
var response = new GetBalanceResponse();
try
{
var wallet = (from p in _context.WalletType
join c in _context.Wallets
on p.WalletTypeId equals c.WalletTypeId
where p.WalletTypeName == request.AccountType
select new
{
Balance = c.Balance,
}).FirstOrDefault();
response.Data.Balance = wallet.Balance;
}
catch (Exception ex)
{
response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key;
response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value;
Logger.Error(ex);
}
return(Task.FromResult(response));
}
public async Task <GetBalanceResponse> GetBalanceAsync(GetBalanceRequest request)
{
var unspentAddressResponse =
await this.GetUnspentAddressesAsync(new GetUnspentAddressesRequest(request.Seed, request.AccountIndex,
request.AddressOptions));
return(new GetBalanceResponse(unspentAddressResponse.UnspentAddresses.Sum(a => a.Balance)));
}
public async Task <Result <GetBalanceResponse> > GetBalanceAsync_Success()
{
GetBalanceRequest request = CreateGetBalanceRequest();
var response = (await cardsService.GetBalanceSrvAsync(request));
Assert.NotNull(response);
return(response);
}
public ActionResult GetBalance(GetBalanceRequest request)
{
var balance = new PlayerBalance {
DiamondBalance = 100, StarBalance = 1000
};
return(Ok(balance));
}
public GetBalanceResponse GetVendorBalance(GetBalanceRequest getBalanceRequest)
{
string content = JsonConvert.SerializeObject(getBalanceRequest);
string path = string.Format("/vendorwallet/{0}/GetBalance", _vendorName);
string response = Post(content, path);
GetBalanceResponse balanceResponse = JsonConvert.DeserializeObject <GetBalanceResponse>(response);
return(balanceResponse);
}
public GetBalanceResponse GetWalletBalance(GetBalanceRequest getBalanceRequest)
{
string content = JsonConvert.SerializeObject(getBalanceRequest);
string path = "/vendorwallet/GetBalance";
string response = Post(content, path);
GetBalanceResponse balanceResponse = JsonConvert.DeserializeObject <GetBalanceResponse>(response);
return(balanceResponse);
}
private GetBalanceRequest CreateGetBalanceRequest()
{
GetBalanceRequest request = new GetBalanceRequest();
request.UserName = "******";
request.TransactionType = "1";
request.CardNumber = "1234567891234567";
return(request);
}
public void GetBalanceRequest()
{
string expected = File.ReadAllText(@"TestData\GetBalance\GetBalanceRequestCommand1.xml");
var command = new GetBalanceRequest();
command.BuildOpsEnvelope("version", "registrantIp");
var xml = command.RequestXml();
Assert.AreEqual(expected, xml);
}
public override async Task <GetBalanceResponse> GetBalance(GetBalanceRequest request, ServerCallContext context)
{
var tokenClaims = tokenClaimsAccessor.TokenClaims;
var user = await dbContext.Users.FindIfNullThrowAsync(tokenClaims.UserId);
return(new GetBalanceResponse
{
Balance = user.Balance,
});
}
//end of authorize request
//get balance
public Wallet GetBalanceRequest(GetBalanceRequest request)
{
string connection = ConfigurationManager.ConnectionStrings["SqlConnection"].ToString();
using (var con = new SqlConnection(connection))
{
DynamicParameters param = new DynamicParameters();
param.Add("acctId", request.AcctId);
var execute = con.Query <Wallet>("authorizeRequest", param, commandType: CommandType.StoredProcedure).FirstOrDefault();
return(execute);
}
}
public override async Task <GetBalanceResponse> GetBalance(GetBalanceRequest request, ServerCallContext context)
{
var balances = await _b2C2RestClient.BalanceAsync(context.CancellationToken);
var result = new GetBalanceResponse {
Timestamp = DateTime.UtcNow.ToTimestamp()
};
result.AssetBalances.AddRange(Map(balances));
return(result);
}
public override async Task <BalanceResponse> GetBalance(GetBalanceRequest request, ServerCallContext context)
{
var balance = await _enrolledBalanceRepository.TryGetAsync(
new DepositWalletKey(
request.WalletKey.BlockchainAssetId,
request.WalletKey.BlockchainId,
request.WalletKey.WalletAddress));
return(new BalanceResponse()
{
Block = balance?.Block ?? 0,
Balance = balance?.Balance.ToString() ?? "0",
WalletKey = request.WalletKey
});
}
public async Task FetchAccountBalanceAsync_should_retrieve_the_account_balances_of_an_user()
{
// Arrange
using PlaidClient client = new PlaidClient { Environment = Environment.Sandbox };
// Act
GetBalanceRequest request = new GetBalanceRequest {
};
GetBalanceResponse result = await client.FetchAccountBalanceAsync(request);
// Assert
result.Request.ShouldNotBeNullOrEmpty();
result.Accounts.Length.ShouldBeGreaterThanOrEqualTo(1);
result.Accounts[0].Balance.Current.ShouldBeGreaterThanOrEqualTo(1);
}
private void ValidategetBalanceRequest(GetBalanceRequest request)
{
ValidateRequest(request);
if (String.IsNullOrWhiteSpace(request.TransactionType))
{
throw new Exception("Choose a valid transaction method.");
}
if (!request.TransactionType.Equals("0") || !request.TransactionType.Equals("1"))
{
throw new Exception("Choose a valid transaction method.");
}
if (String.IsNullOrWhiteSpace(request.CardNumber))
{
throw new Exception("Choose a card number.");
}
}
public async Task <IActionResult> GetBalance(GetBalanceRequest request)
{
var response = new GetBalanceResponse();
try
{
response = await _accountQueries.GetBalance(request);
}
catch (Exception ex)
{
response.Code = ErrorCode.GetError(ErrorCode.SystemError).Key;
response.Message = ErrorCode.GetError(ErrorCode.SystemError).Value;
Logger.Error($"Exception: {ex} , Method:GetBalance");
}
return(Ok(response));
}
/// <summary>
/// Look up account balance.
/// </summary>
/// <param name="acountId">the account id</param>
/// <param name="keyLevel">the key level</param>
/// <returns>the account balance</returns>
/// <exception cref="StepUpRequiredException"></exception>
public Task <Balance> GetBalance(string acountId, Level keyLevel)
{
var request = new GetBalanceRequest {
AccountId = acountId
};
return(gateway(authenticateOnBehalfOf(keyLevel)).GetBalanceAsync(request)
.ToTask(response =>
{
if (response.Status.Equals(RequestStatus.SuccessfulRequest))
{
return response.Balance;
}
throw new StepUpRequiredException("Balance step up required.");
}));
}
public ActionResult GetBalanceRequest()
{
GetBalanceRequest getRequest = new GetBalanceRequest();
acctRepository acctRepo = new acctRepository();
GetBalanceResponse response = new GetBalanceResponse();
//Input stream
using (Stream stream = Request.InputStream)
{
using (StreamReader reader = new StreamReader(stream))
{
getRequest = JsonConvert.DeserializeObject <GetBalanceRequest>(reader.ReadToEnd());
}
}
//end of Input stream
var balance = acctRepo.GetBalanceRequest(getRequest);
//validation
if (balance == null)
{
response.merchantCode = getRequest.MerchantCode;
response.serialNo = getRequest.SerialNo;
response.msg = "Account Not Found ";
response.code = 50100;
return(Json(response));
}
response.acctInfo = balance;
response.merchantCode = getRequest.MerchantCode;
response.serialNo = getRequest.SerialNo;
response.msg = "Success";
response.code = 0;
//end of validation
return(Json(response));
}
public void GetBalance(NodeCoreAdminClient adminClient)
{
Console.WriteLine("GetBalance");
Console.WriteLine("NC_CLI command: getbalance [address]");
String address = "V9pNg1wCSadKrBJiGKchpMGAtD7cT3";
GetBalanceRequest request = new GetBalanceRequest();
request.Addresses.Add(Utils.ConvertAddressToByteString(address));
GetBalanceReply reply = adminClient.AdminClient.GetBalance(request);
if (reply.Success)
{
Console.WriteLine("Confirmed={0}", Utils.ConvertAtomicToVbkUnits(reply.Confirmed[0].UnlockedAmount));
Console.WriteLine("Pending={0}", Utils.ConvertAtomicToVbkUnits(reply.Unconfirmed[0].Amount));
}
Console.WriteLine("--------------------");
Console.WriteLine();
}
public async Task <Result <GetBalanceResponse> > GetBalanceSrvAsync(GetBalanceRequest request)
{
Result <GetBalanceResponse> result = new Result <GetBalanceResponse>();
GetBalanceResponse response = new GetBalanceResponse();
List <Limit> limit = new List <Limit>();
try
{
ValidategetBalanceRequest(request);
limit = await RetrieveLimitFromDb(request);
response = CreateGetBalanceResponse(response, limit);
result.Payload = response;
}
catch (Exception ex)
{
logger.LogError(ex.Message);
GetExeptionResult(result, ex.Message);
}
return(result);
}
/// <summary>
/// Look up account balance.
/// </summary>
/// <param name="accountId">the account id</param>
/// <param name="keyLevel">the key level</param>
/// <returns>the account balance</returns>
/// <exception cref="StepUpRequiredException"></exception>
public Task <Balance> GetBalance(string accountId, Level keyLevel)
{
var request = new GetBalanceRequest {
AccountId = accountId
};
return(gateway(authenticateOnBehalfOf(keyLevel)).GetBalanceAsync(request)
.ToTask(response =>
{
switch (response.Status)
{
case RequestStatus.SuccessfulRequest:
return response.Balance;
case RequestStatus.MoreSignaturesNeeded:
throw new StepUpRequiredException("Balance step up required.");
default:
throw new RequestException(response.Status);
}
}));
}
public Task <GetBalanceResponse> GetBalance(GetBalanceRequest request, CancellationToken cts = default(CancellationToken))
{
return(SendCommandAsync <GetBalanceRequest, GetBalanceResponse>("get_balance", request, cts));
}
public GetBalanceResponse GetBalance(GetBalanceRequest request)
{
return(WrapResponse <GetBalanceResponse, GetBalanceResponseBody>(
new ServiceExecutionDelegator <GetBalanceResponseBody, GetBalanceRequestBody>().ResolveRequest(request.Request, (request.Request.Platform ?? ConfigurationManager.AppSettings["DefaultPlatform"]), ApiServiceName.GetBalance)));
}
public async Task <Result <GetBalanceResponse> > GetBalanceAsync(GetBalanceRequest request)
{
var result = await cardsService.GetBalanceSrvAsync(request);
return(result);
}
public Task <BalanceResponse> GetBalanceAsync(GetBalanceRequest Address) => GetSimpleJsonAsync <BalanceResponse, GetBalanceRequest>(Address, Api.GetAccountBalance);
public BalanceResponse GetBalance(GetBalanceRequest Address) => GetBalanceAsync(Address).ConfigureAwait(false).GetAwaiter().GetResult();
private async Task <List <Limit> > RetrieveLimitFromDb(GetBalanceRequest request)
{
List <Limit> limit = await dbContext.Set <Limit>().Where(c => c.CardNumber == request.CardNumber).ToListAsync();
return(limit);
}
public GetBalanceResponse GetBalance(GetBalanceRequest request)
{
request.BuildOpsEnvelope(_version, _registrantIp);
return(new GetBalanceResponse(SendRequest(request.RequestXml())));
}
