private async void GetTransactionListInitial()
{
Transactions.Clear();
var transactions = await WalletService.GetWalletTransactions();
Transactions.AddRange(transactions);
}
private async Task TryRewriteTableAsync()
{
try
{
var historyBuilder = new TransactionHistoryBuilder(Global.Wallet);
var txRecordList = await Task.Run(historyBuilder.BuildHistorySummary);
var tis = txRecordList.Select(txr => new TransactionInfo
{
DateTime = txr.DateTime.ToLocalTime(),
Confirmed = txr.Height.Type == HeightType.Chain,
Confirmations = txr.Height.Type == HeightType.Chain ? (int)Global.BitcoinStore.SmartHeaderChain.TipHeight - txr.Height.Value + 1 : 0,
AmountBtc = $"{txr.Amount.ToString(fplus: true, trimExcessZero: true)}",
Label = txr.Label,
BlockHeight = txr.Height.Type == HeightType.Chain ? txr.Height.Value : 0,
TransactionId = txr.TransactionId.ToString()
});
Transactions?.Clear();
var trs = tis.Select(ti => new TransactionViewModel(ti));
Transactions = new ObservableCollection <TransactionViewModel>(trs.OrderByDescending(t => t.DateTime));
Global.UiConfig.Transactions = tis.ToArray();
Global.UiConfig.ToFile(); // write to file once height is the highest
}
catch (Exception ex)
{
Logger.LogError(ex);
}
}
private async Task LoadFirstPageAsync()
{
Transactions.Clear();
Offset = 0;
await LoadNextPageAsync();
}
private void GetTransactions()
{
Transactions.Clear();
var rowNodes = HtmlDocument.DocumentNode.SelectNodes("//tbody/tr");
foreach (var raow in rowNodes)
{
var cellNodes = raow.SelectNodes("./td[position()<last()-1]").Select(td => WebUtility.HtmlDecode(td.InnerHtml.ToString())).ToList();
Transactions.Add(new Transaction
{
Befattning = cellNodes[3],
Handelsplats = cellNodes[1],
ISIN = cellNodes[7],
Instrumentnamn = cellNodes[6],
Karaktar = cellNodes[5],
Narstaende = cellNodes[4],
PersonILedandeStallning = cellNodes[2],
Pris = cellNodes[11],
PubliceringsDatum = cellNodes[0],
TransaktionsDatum = cellNodes[8],
Utgivare = cellNodes[1],
Valuta = cellNodes[12],
Volym = cellNodes[9],
Volymsenhet = cellNodes[10]
});
}
foreach (var row in Transactions)
{
{
//Console.Write(row.ISIN);
}
}
}
/// <summary>
/// Commits the transaction in MongoDb.
/// </summary>
public override void Commit()
{
_log.Debug($"Committing transaction for URI: {Uri}");
var parent = Parent as MongoTransaction;
if (parent != null)
{
// Transfer transactions to parent transaction
Adapter.UpdateEntities(Id, parent.Id);
parent.Transactions.AddRange(Transactions);
// Prevent deletion of transactions
Transactions.Clear();
}
else
{
var pending = Transactions.Where(t => t.Status == TransactionStatus.Pending && t.Action == MongoDbAction.Delete);
foreach (var transaction in pending)
{
Delete(transaction);
}
}
ClearTransactions();
Committed = true;
}
public async override void RefreshView()
{
RestApi.Portfolios.TransactionsResponse response;
if (_Parameter.Stock.Id == Guid.Empty)
{
response = await _Parameter.RestClient.Portfolio.GetTransactions(_Parameter.DateRange);
}
else
{
response = await _Parameter.RestClient.Holdings.GetTransactions(_Parameter.Stock.Id, _Parameter.DateRange);
}
if (response == null)
{
return;
}
Transactions.Clear();
for (var i = response.Transactions.Count - 1; i >= 0; i--)
{
Transactions.Add(new TransactionViewItem(response.Transactions[i]));
}
OnPropertyChanged("");
}
/// <summary>
/// The handler handles the event when the <see cref="TransactionFilterViewModel.FilterApplied"/> event is raised
/// by the <see cref="FilterViewModel"/>.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FilterViewModelFilterApplied(object sender, EventArgs e)
{
SelectedTransaction = null;
Transactions.Clear();
_messagingService.ShowProgressMessage(UIText.WAIT_SCREEN_HEADER, UIText.GETTING_TRANS_WAIT_MSG);
GetFilteredTransactions();
}
async Task ExecuteLoadTransactionsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Transactions.Clear();
var items = _mapper.Map <IEnumerable <TransactionModel> >(await DataStore.GetAsync(true));
foreach (var item in items)
{
Transactions.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
private async Task Load()
{
Transactions.Clear();
var service = new EnvelopeManager();
Envelope = await service.GetEnvelopeDetailsWithTransactionAsync(envelopeID);
Income = 0;
Expense = 0;
foreach (var item in Envelope.Transactions)
{
if (item.Type == false)
{
Expense += item.Value;
}
else if (item.Type == true)
{
Income += item.Value;
}
Transactions.Add(item);
}
EnvelopeName = Envelope.Name;
EnvelopeDetails = Envelope.Details;
Income += Envelope.Value;
remaining = Income - Expense;
RemainingMoney = remaining.ToString();
accID = Envelope.AccountId;
}
public async Task ExecuteLoadTransactionsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Transactions.Clear();
var transactions = (await DataStore.GetTransactionsAsync())
.ToList()
.OrderBy(p => p.IsComplete);
Transactions.ReplaceRange(transactions);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
MessagingCenter.Send(new MessagingCenterAlert
{
Title = "Error",
Message = "Unable to load items.",
Cancel = "OK"
}, "message");
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Submits signed transactions and queue response utxos
/// </summary>
/// <returns></returns>
public async Task ProcessTransactions()
{
if (CanMerge)
{
foreach (var transaction in Transactions)
{
string encodedTx = txEncoder.EncodeSigned(transaction).ToHex(true);
TransactionReceipt receipt = await plasmaAPIService.SubmitTransaction(encodedTx);
if (receipt != null)
{
UTXOData utxo = new UTXOData();
utxo.BlkNum = receipt.BlkNum;
utxo.TxIndex = receipt.TxIndex;
utxo.OIndex = 0;
utxo.Data = transaction.Outputs[0].Value.ToBigIntegerFromRLPDecoded();
utxo.Owner = transaction.Outputs[0].Owner;
utxo.Currency = transaction.Outputs[0].Currency;
utxo.Position = UTXOData.CalculatePosition(utxo.BlkNum, utxo.TxIndex, utxo.OIndex);
utxoList.Add(utxo);
}
}
Transactions.Clear();
PrepareTransactions();
}
}
private async Task RewriteTableAsync()
{
var txRecordList = await Task.Run(() =>
{
return(BuildTxRecordList());
});
var rememberSelectedTransactionId = SelectedTransaction?.TransactionId;
Transactions?.Clear();
var trs = txRecordList.Select(txr => new TransactionInfo
{
DateTime = txr.dateTime.ToLocalTime(),
Confirmed = txr.height != WalletWasabi.Models.Height.MemPool && txr.height != WalletWasabi.Models.Height.Unknown,
AmountBtc = $"{txr.amount.ToString(fplus: true, trimExcessZero: true)}",
Label = txr.label,
TransactionId = txr.transactionId.ToString()
}).Select(ti => new TransactionViewModel(ti));
Transactions = new ObservableCollection <TransactionViewModel>(trs);
if (Transactions.Count > 0 && !(rememberSelectedTransactionId is null))
{
var txToSelect = Transactions.FirstOrDefault(x => x.TransactionId == rememberSelectedTransactionId);
if (txToSelect != default)
{
Interlocked.Exchange(ref _disableClipboard, 1);
SelectedTransaction = txToSelect;
}
}
RefreshOrdering();
}
/// <summary>
/// Este metodo consulta a la base de datos las transacciones segun el arbol de ruta especificado
/// </summary>
private void ReloadTransactions()
{
Transactions.Clear();
Deposits = 0m;
Egress = 0m;
Balance = 0m;
UpdateParameters(); //Con el objetivo de utilizar datos actualizados
//Este es el primer filtro, con esto evito estar repitiendo codigo por todas partes
if (categoriesSelected.Count == 0)
{
Deposits = generalDeposit;
Egress = generalEgress;
Balance = generalBalance;
}
else if (firtsTransactionDate.HasValue)
{
List <CashboxTransaction> temporalList = new List <CashboxTransaction>();
DateTime since = firtsTransactionDate.Value;
DateTime until = lastTransactionDate.Value;
if (DefinedPeriod)
{
if (SinceDateSelected.HasValue && UntilDateSelected.HasValue)
{
since = SinceDateSelected.Value;
until = UntilDateSelected.Value;
}
else if (SinceDateSelected.HasValue && !UntilDateSelected.HasValue)
{
since = SinceDateSelected.Value;
}
else if (!SinceDateSelected.HasValue && UntilDateSelected.HasValue)
{
until = UntilDateSelected.Value;
}
}
temporalList = BDComun.RecoverTransaction(categoriesSelected, since, until);
foreach (CashboxTransaction t in temporalList)
{
if (t.Amount > 0)
{
Deposits += t.Amount;
}
else
{
Egress += Math.Abs(t.Amount);
}
Balance += t.Amount;
Transactions.Add(t);
}
}
UpdateReports();
}
private async void RefreshTxs()
{
var txs = await MempoolMgr.GetTxsJsonFromMempool();
this.TxCount = txs.Count;
Transactions.Clear();
Transactions.AddRange(txs);
}
private Block CreateBlock(string previousHash, int proof)
{
var newBlock = new Block(Blocks.Count + 1, previousHash, proof);
newBlock.Transactions.AddRange(Transactions);
Transactions.Clear();
return(newBlock);
}
public async Task RefreshTransactions()
{
RefreshingTransactions = true;
var context = await _agentContextProvider.GetContextAsync();
var message = _discoveryService.CreateQuery(context, "*");
DiscoveryDiscloseMessage protocols = null;
try
{
var response = await SendMessage(context.Wallet, message);
protocols = response.GetMessage <DiscoveryDiscloseMessage>();
}
catch (Exception)
{
//Swallow exception
//TODO more granular error protection
}
IList <TransactionItem> transactions = new List <TransactionItem>();
Transactions.Clear();
if (protocols == null)
{
HasTransactions = false;
RefreshingTransactions = false;
return;
}
foreach (var protocol in protocols.Protocols)
{
switch (protocol.ProtocolId)
{
case MessageTypes.TrustPingMessageType:
transactions.Add(new TransactionItem()
{
Title = "Trust Ping",
Subtitle = "Version 1.0",
PrimaryActionTitle = "Ping",
PrimaryActionCommand = new Command(async() =>
{
await PingConnectionAsync();
}, () => true),
Type = TransactionItemType.Action.ToString("G")
});
break;
}
}
Transactions.InsertRange(transactions);
HasTransactions = transactions.Any();
RefreshingTransactions = false;
}
private async Task GetTransactionList()
{
IsBusy = true;
Transactions.Clear();
var transactions = await WalletService.GetWalletTransactions();
Transactions.AddRange(transactions);
IsBusy = false;
}
public void LoadTransactions()
{
Transactions.Clear();
var transactions = _transactionDataProvider.LoadTransactionHistory();
foreach (var transaction in transactions)
{
Transactions.Add(transaction);
}
}
private void ClearTransactions()
{
if (Transactions.Any())
{
Adapter.DeleteTransactions(Id);
Transactions.Clear();
}
_databaseProvider = null;
Database = null;
}
public async Task LoadTransactions()
{
Transactions.Clear();
foreach (PortfolioTransaction p in PortfolioTransactions)
{
var transaction = await _http.GetFromJsonAsync <Transaction>($"api/transaction/{p.Id}");
Transactions.Add(transaction);
}
CalcsChanged();
}
protected override void HandleDateStateChange(DateStateViewModel dateState)
{
base.HandleDateStateChange(dateState);
dateState.WhenDateStateChanged.Subscribe((state) =>
{
Transactions.Clear();
foreach (var category in Categories)
{
category.Spent = 0;
}
});
}
public void LoadTransactions()
{
Transactions.Clear();
_allTransaction = _transactionService.GetTransactions();
foreach (var transaction in _allTransaction.Where(e => e.CreatedTime.ToString("yyyy") == Year && e.CreatedTime.ToString("MMMM") == Month))
{
if (transaction.Type == BaseModel.TypeEnum.Income && GetIncomes ||
transaction.Type == BaseModel.TypeEnum.Expense && GetExpenses)
{
Transactions.Add(transaction);
}
}
}
internal void ApplyInternal(OptionDeleted deleted)
{
NumberOfContracts = 0;
Transactions.Clear();
Buys.Clear();
Sells.Clear();
FirstFill = null;
SoldToOpen = null;
Closed = null;
Notes.Clear();
Expirations.Clear();
Deleted = true;
}
public void UpdateTransactionsCollection()
{
Transactions.Clear();
foreach (Transaction transaction in _tranService.GetTransactions())
{
if (transaction.WalletGuid == _wallet.Guid)
{
if (_walService.GetWallet(FromWallet).Transactions.ToList().Exists(x => x.Guid == transaction.Guid))
{
Transactions.Add(transaction);
}
}
}
RaisePropertyChanged(nameof(Transactions));
}
/// <summary>
/// Procesa el programa
/// </summary>
internal void Process(ProgramModel program)
{
// Inicializa el generador base
Initialize();
// Inicializa las transacciones
Transactions.Clear();
// Añade las variables iniciales
foreach ((string key, object value) in Manager.Parameters.Enumerate())
{
Context.Actual.VariablesTable.Add(key, value);
}
Context.Actual.VariablesTable.Add("Today", DateTime.Now);
// Ejecuta el programa
Execute(program.Sentences);
}
public void ResetToValueOf(AppXmlCommon.XmlAccount xAccount)
{
AccountMoney = xAccount.accountMoney;
AccountPercent = xAccount.accountPercent;
Transactions.Clear();
List <Transaction> tmpTransactions = new List <Transaction>();
foreach (AppXmlCommon.XmlTransaction xTransaction in xAccount.transactions)
{
tmpTransactions.Add(TransactionFromXmlTransaction(xTransaction));
}
Transactions = tmpTransactions;
}
private async Task ReloadTransactions()
{
Loading = true;
try
{
await _semaphoreSlim.WaitAsync().ConfigureAwait(false);
Transactions.Clear();
BlockNumber = _blockNumber;
}
finally
{
Loading = false;
_semaphoreSlim.Release();
}
}
public void AddTransactions(IEnumerable <Transaction> transactions)
{
Transactions.Clear();
foreach (var transaction in transactions)
{
var transactionViewModel = _TransactionViewModelFactory.CreateTransactionViewModel(transaction);
transactionViewModel.BeginEdit();
Transactions.Add(transactionViewModel);
}
SelectedTransaction = Transactions.First();
Show();
}
protected override void HandleDateStateChange(DateStateViewModel dateState)
{
base.HandleDateStateChange(dateState);
dateState.WhenDateStateChanged.Subscribe((state) =>
{
Transactions.Clear();
foreach (var accountVm in Accounts)
{
accountVm.RemoveAllTransactions();
if (accountVm.Account != null)
{
accountVm.IsLoading = true;
}
}
});
}
private async Task ExecuteGetTransactionsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
GetTransactionsCommand.ChangeCanExecute();
var showAlert = false;
try
{
UpdateBalance();
Transactions.Clear();
var trans = await data.GetTransactionsAsync();
foreach (var transaction in trans)
{
Transactions.Add(new TransactionViewModel(page, transaction));
}
TransactionsFiltered = new ObservableRangeCollection <TransactionViewModel>(SortTransactionsByDate());
}
catch (WebException err)
{
await page.DisplayAlert("Ошибка", "У вас отсутствует подключение к интернету", "OK");
}
catch (Exception ex)
{
showAlert = true;
}
finally
{
IsBusy = false;
GetTransactionsCommand.ChangeCanExecute();
}
if (showAlert)
{
await page.DisplayAlert("Упс ... :(", "Не получается получить мероприятия.", "OK");
}
}
