public GetAddressResponse GetAddress(GetAddressRequest request)
{
GetAddressResponse response = new GetAddressResponse();
Consumer consumer = null;
try
{
using (UserDao dao = new UserDao())
{
consumer = GetAuthUser(dao, request.user_id, request.auth_token, true);
if (consumer == null)
{
MakeNouserResponse(response);
return(response);
}
ConsumerAddress consAddr = consumer.ConsumerAddresses.Where(a => a.AddrID == request.address_id).First();
UserAddressesDto addrDto = new UserAddressesDto();
UsersHelper.CopyFromEntity(addrDto, consAddr, consumer.Name);
response.user_address = addrDto;
response.has_resource = 1;
response.code = 0;
response.message = MessagesSource.GetMessage("addr.details");
return(response);
}
}
catch (Exception ex)
{
response.MakeExceptionResponse(ex);
}
return(response);
}
private async void btnGetAddress_Click(object sender, EventArgs e)
{
Collivery collivery = new Collivery()
{
auth = new AuthenticateRequest()
{
email = txtEmail.Text,
password = txtPassword.Text
}
};
GetAddressResponse townsResp = await collivery.get_address(new GetAddressRequest()
{
address_id = 920466,
token = authResp.token
});
if (townsResp.error != null)
{
txtResult.Text = "Error - " + townsResp.error.error;
}
else
{
txtResult.Text = "Success - Address Returned: " + townsResp.address.nice_address;
}
}
public async Task GetAddressSuccess()
{
GetAddressResponse response = await GetExplorer().GetAddress(_wallet);
Assert.True(response.Success);
Assert.True(response.Balance > 0);
}
public async Task <GetAddressResponse> Get(int idUser)
{
GetAddressResponse response = new GetAddressResponse
{
Address = await _repository.Get(idUser)
};
return(response);
}
public override Task <GetAddressResponse> GetAddress(
GetAddressRequest request, ServerCallContext context)
{
var location = GetBreakpointLocation(request.BreakpointLocation);
var response = new GetAddressResponse();
var address = location.GetAddress();
if (address != null)
{
response.Address = new GrpcSbAddress
{
Id = addressStore.AddObject(address)
};
}
return(Task.FromResult(response));
}
private async Task <IAccount> GetTransactionsDetails(string accountAddr, GetAddressResponse accnt, IAccount acc)
{
foreach (var item in accnt.Transactions)
{
//Console.WriteLine($"Transaction: {item}");
var tr = await NeblioTransactionHelpers.TransactionInfoAsync(client, TransactionTypes.Neblio, item, acc.Address);
if (tr != null)
{
acc.Transactions.TryAdd(tr.TxId, tr);
}
}
return(acc);
}
public GetAddressResponse GetAddress(GetAddressRequest getAddressRequest)
{
GetAddressResponse getAddressResponse = null;
if (getAddressRequest.Id > 0)
{
var address = _addressRepository.FindAddressById(getAddressRequest.Id);
var addressDto = _messageMapper.MapToAddressDto(address);
getAddressResponse = new GetAddressResponse
{
Address = addressDto
};
}
return(getAddressResponse);
}
public async Task <GetAddressResponse> GetAddress(string address)
{
var request = new RestRequest(Consts.GetAddressUri, Method.GET);
request.AddUrlSegment("id", address);
var response = await _client.ExecuteTaskAsync(request);
if (!response.IsSuccessful)
{
return(new GetAddressResponse()
{
Error = response.ErrorMessage
});
}
return(GetAddressResponse.FromJson(response.Content));
}
public SbAddress GetAddress()
{
GetAddressResponse response = null;
if (connection.InvokeRpc(() =>
{
response = client.GetAddress(
new GetAddressRequest {
BreakpointLocation = grpcSbBreakpointLocation
});
}))
{
if (response.Address != null && response.Address.Id != 0)
{
return(addressFactory.Create(connection, response.Address));
}
}
return(null);
}
public GetAddressResponse ExecuteAsync(GetAddressRequest request)
{
var validationResponse = _getAddressValidator.Validate(request);
if (!validationResponse.IsValid)
{
throw new BadRequestException(validationResponse);
}
var response = _addressGateway.GetSingleAddress(request.addressID);
if (response == null)
{
return(new GetAddressResponse());
}
var useCaseResponse = new GetAddressResponse
{
Address = response.ToResponse()
};
return(useCaseResponse);
}
/// <summary>
/// This function will load the actual data and then run the task which periodically refresh this data.
/// It doesnt have cancellation now!
/// </summary>
/// <param name="interval">Default interval is 3000 = 3 seconds</param>
/// <returns></returns>
public async Task <string> StartRefreshingData(int interval = 3000)
{
if (string.IsNullOrEmpty(Address) || !AccountKey.IsLoaded)
{
await InvokeErrorEvent("Please fill subaccount Address and Key first.", "Not loaded address and key.");
return(await Task.FromResult("Please fill subaccount Address and Key first."));
}
try
{
FirsLoadingStatus?.Invoke(this, "Loading of Sub Account data started.");
AddressInfo = new GetAddressResponse();
AddressInfo.Transactions = new List <string>();
await ReloadUtxos();
try
{
await TxCashPreload();
}
catch (Exception ex)
{
Console.WriteLine("Cannot finish the preload." + ex.Message);
}
var tasks = new Task[4];
tasks[0] = ReloadTokenSupply();
tasks[1] = ReloadMintingSupply();
FirsLoadingStatus?.Invoke(Address, $"Loading of Sub Account {Name} NFTs started.");
tasks[2] = ReLoadNFTs(withoutMessages: true);
tasks[3] = Task.Delay(100);
await Task.WhenAll(tasks);
tasks[0] = ReloadCoruzantNFTs();
tasks[1] = ReloadHardwarioNFTs();
tasks[2] = RefreshAddressReceivedPayments();
tasks[3] = RefreshAddressReceivedReceipts();
await Task.WhenAll(tasks);
FirsLoadingStatus?.Invoke(Address, $"Sub Account {Name} first load done.");
}
catch (Exception ex)
{
Console.WriteLine("Problem during first load of subaccount. " + ex.Message);
}
// todo cancelation token
_ = Task.Run(async() =>
{
var firstLoad = true;
var minorRefresh = 0;
var tasks = new Task[4];
while (true)
{
try
{
if (IsAutoRefreshActive && !firstLoad)
{
await ReloadUtxos();
tasks[0] = ReloadTokenSupply();
tasks[1] = ReloadMintingSupply();
tasks[2] = ReLoadNFTs(withoutMessages: true);
tasks[3] = Task.Delay(1);
await Task.WhenAll(tasks);
tasks[0] = ReloadCoruzantNFTs();
tasks[1] = ReloadHardwarioNFTs();
tasks[2] = RefreshAddressReceivedPayments();
tasks[3] = RefreshAddressReceivedReceipts();
await Task.WhenAll(tasks);
if (minorRefresh >= 0)
{
minorRefresh--;
}
else
{
await CheckPayments();
minorRefresh = 5;
}
}
if (firstLoad)
{
firstLoad = false;
}
}
catch (Exception ex)
{
Console.WriteLine("Cannot refresh data. " + ex.Message);
//await InvokeErrorEvent(ex.Message, "Unknown Error During Refreshing Data");
}
await Task.Delay(interval);
}
});
return(await Task.FromResult("RUNNING"));
}
public override async Task <string> StartRefreshingData(int interval = 1000)
{
AutoTxReload(); // start autoTxreload task, not awaited. It runs at background. It should be placed in main loop with recovery
// todo cancelation token
_ = Task.Run(async() =>
{
GetAddressResponse addrinfo = null;
while (true)
{
try
{
addrinfo = await NeblioTransactionHelpers.AddressInfoAsync(Address);
}
catch (Exception ex)
{
// todo
}
if (addrinfo != null)
{
TotalBalance = addrinfo.Balance;
TotalUnconfirmedBalance = addrinfo.UnconfirmedBalance;
if (addrinfo.Transactions != null)
{
SpendableTxId = addrinfo.Transactions.LastOrDefault();
// this will run just in first turn after init of account
// if there is some stored LastProcessedTxId it will load all tx until this one without invoke event
// if there is no last tx stored it will count until end and set all as already handled in some previous run of the app
if (NumberOfTransaction == 0)
{
var txs = addrinfo.Transactions.ToArray();
for (int t = 0; t < txs.Length; t++)
{
if (txs[t] == LastProcessedTxId)
{
initNumberOfTx = t;
}
}
if (initNumberOfTx == 0)
{
initNumberOfTx = addrinfo.Transactions.Count;
}
}
NumberOfTransaction = addrinfo.Transactions.Count;
try
{
await ReloadTransactions(addrinfo.Transactions);
}
catch (Exception ex)
{
// todo
}
}
DetailsLoaded?.Invoke(null, this);
// check if some new tx was processed or confirmed and save them for recovery as last processed
if (lastTxSaveDto.LastConfirmedTxId != LastConfirmedTxId || lastTxSaveDto.LastProcessedTxId != LastProcessedTxId)
{
try
{
lastTxSaveDto.LastConfirmedTxId = LastConfirmedTxId;
lastTxSaveDto.LastProcessedTxId = LastProcessedTxId;
var output = JsonConvert.SerializeObject(lastTxSaveDto);
FileHelpers.WriteTextToFile(Path.Join(EconomyMainContext.CurrentLocation, $"Accounts/{Address}.txt"), output);
}
catch (Exception ex)
{
log.Error("Cannot write file with last processed confirmed Tx!", ex);
}
}
}
await Task.Delay(interval);
}
});
return(await Task.FromResult("END"));
}
public NegotiatedContentResult <GetAddressResponse> PostGetAddress([FromBody] GetAddressRequest request)
{
GetAddressResponse resp = _userServices.GetAddress(request);
return(Content(HttpStatusCode.OK, resp));
}
