public async Task StoreDecryptedTransactionData <T>(TransactionDownloadData <T> transactionData) where T : Operation
{
if ((Flags & TransactionDownloadManagerFlags.DecrytpedTransactionStorage) != 0)
{
var decryptedData = transactionData.GetDecryptedData();
if (decryptedData != null)
{
await Task.Run((Action)(() =>
{
var transactionId = transactionData.Transaction.OperationId;
var decrytedStorage = _decryptedAttachementsStorage.Value;
var data = decryptedData.ToByteArray();
if (decrytedStorage.ContainsIndex(transactionId))
{
decrytedStorage.UpdateEntry(transactionId, (byte[])data);
}
else
{
decrytedStorage.AddEntry(transactionId, (byte[])data);
}
decrytedStorage.Commit();
}));
}
}
}
void RetrieveDecrytpedTransactionStorage <T>(TransactionDownloadData <T> transactionData) where T : Operation
{
if ((Flags & TransactionDownloadManagerFlags.DecrytpedTransactionStorage) != 0)
{
var transaction = transactionData.Transaction;
var transactionId = transaction.OperationId;
if (transactionData.GetDecryptedData() == null)
{
var decrytedStorage = _decryptedAttachementsStorage.Value;
if (decrytedStorage.ContainsIndex(transactionId))
{
var data = decrytedStorage.GetBlockData(transactionId);
if (data != null)
{
try
{
var attachements = new TransactionAttachements(new Unpacker(data));
transactionData.UpdateDecryptedData(attachements);
}
catch { }
}
}
}
}
}
async Task <TransactionDownloadData <T> > DownloadTransactionAttachement <T>(TransactionDownloadData <T> transactionData, bool commit) where T : Operation
{
var transaction = transactionData.Transaction;
var transactionId = transaction.OperationId;
if (transactionData.HasAttachements)
{
if (transactionData.AttachementsState != TransactionAttachementsState.Ok)
{
var attachementStorage = _attachementsStorage.Value;
if (!attachementStorage.ContainsIndex(transactionId))
{
var attachementData = new TransactionAttachements(transactionId);
var attachementTransaction = transaction as AttachementDataTransaction;
var count = attachementTransaction.Items.Count;
for (var i = 0; i < attachementTransaction.Items.Count; i++)
{
var item = attachementTransaction.Items[i];
var data = (await Client.DownloadAttachement(attachementTransaction, i)).Data;
if (data != null)
{
attachementData.AddData(item.Name, data);
}
}
if (count == attachementData.Count)
{
attachementStorage.AddEntry(transactionId, attachementData.ToByteArray());
if (commit)
{
attachementStorage.Commit();
}
transactionData.UpdateAttachement(TransactionAttachementsState.Ok, attachementData);
}
else
{
transactionData.UpdateAttachement(TransactionAttachementsState.DownloadFailed, null);
}
}
else
{
var data = attachementStorage.GetBlockData(transactionId);
if (data != null)
{
try
{
transactionData.UpdateAttachement(TransactionAttachementsState.Ok, new TransactionAttachements(new Unpacker(data)));
}
catch { }
}
}
}
}
return(transactionData);
}
protected async Task <TransactionDownloadResult <T> > QueryStoredTransactions <T>(long startTransactionId, int count, TransactionDownloadHandler <T> handler) where T : Operation
{
var nextId = startTransactionId;
if (startTransactionId <= Operation.InvalidTransactionId)
{
nextId = await handler.QueryLastStoredTransactionId(this);
}
if (nextId != Operation.InvalidTransactionId)
{
try
{
var transactions = new List <TransactionDownloadData <T> >();
for (var i = 0; i < count; i++)
{
if (nextId <= Operation.InvalidTransactionId)
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, false, transactions, nextId));
}
T operation = await GetStoredOperation <T>(nextId, handler);
if (operation == null)
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.InternalError, true, transactions, Operation.InvalidTransactionId));
}
var data = new TransactionDownloadData <T>(operation, this);
await DownloadTransactionAttachement(data);
RetrieveDecrytpedTransactionStorage(data);
transactions.Add(data);
nextId = handler.GetPreviousTransactionId(operation);
}
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, nextId != Operation.InvalidTransactionId, transactions, nextId));
}
catch (Exception ex)
{
Log.IgnoreException(ex);
}
}
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, false, new List <TransactionDownloadData <T> >(), Operation.InvalidTransactionId));
}
public Task <TransactionDownloadData <T> > DownloadTransactionAttachement <T>(TransactionDownloadData <T> transactionData) where T : Operation
{
return(DownloadTransactionAttachement(transactionData, true));
}
protected async Task <TransactionDownloadResult <T> > DownloadTransactions <T>(long startTransactionId, long endTransactionId, int count, bool downloadAttachements, bool cache, TransactionDownloadHandler <T> handler) where T : Operation
{
var nextId = Operation.InvalidTransactionId;
if (startTransactionId <= Operation.InvalidTransactionId)
{
var info = await handler.GetLastTransactionId();
var error = TransactionDownloadResultCode.Ok;
if (info == null)
{
error = TransactionDownloadResultCode.NetworkError;
}
else
{
if (info.ResultType != ResultTypes.Ok)
{
if (info.ResultType == ResultTypes.ChainNotFound)
{
error = TransactionDownloadResultCode.ChainNotFound;
}
else if (info.ResultType == ResultTypes.DataNotFound)
{
error = TransactionDownloadResultCode.DataNotFound;
}
else if (info.ResultType == ResultTypes.AccountNotFound)
{
error = TransactionDownloadResultCode.AccountNotFound;
}
else if (info.ResultType == ResultTypes.FeatureNotFound)
{
error = TransactionDownloadResultCode.FeatureNotFound;
}
else
{
throw new Exception("Unknown result type");
}
}
}
if (error != TransactionDownloadResultCode.Ok)
{
return(new TransactionDownloadResult <T>(error, false, new List <TransactionDownloadData <T> >(), Operation.InvalidTransactionId));
}
if (info is Result <LastTransactionInfo> lastTransactionInfo)
{
nextId = lastTransactionInfo.Item.TransactionId;
}
else if (info is Result <LastTransactionCountInfo> lastDataTransactionInfo)
{
nextId = lastDataTransactionInfo.Item.TransactionId;
}
else
{
throw new Exception("Unknown last transactin info");
}
}
else
{
nextId = startTransactionId;
}
var transactions = new List <TransactionDownloadData <T> >();
if (nextId != Operation.InvalidTransactionId)
{
var discStorage = _transactionStorage.Value;
try
{
// useful?
var end = endTransactionId != Operation.InvalidTransactionId || count <= 0;
if (end)
{
count = int.MaxValue;
}
for (var i = 0; i < count; i++)
{
if (nextId <= Operation.InvalidTransactionId)
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, false, transactions, nextId));
}
T operation = await GetStoredOperation <T>(nextId, handler);
if (operation == null)
{
operation = await handler.DownloadTransaction(nextId);
if (operation != null)
{
var transaction = operation as Transaction;
if (transaction != null)
{
var accountId = transaction.AccountId;
var transactionid = transaction.TransactionId;
var timestamp = transaction.Timestamp;
{
var accountIndex = transaction.GetFeature <AccountIndex>(AccountIndex.FeatureId);
if (accountIndex != null)
{
var index = accountIndex?.Index;
var hasIndex = index != null;
var accountEntry = await _accountEntryStorage.GetEntry(accountId);
if (accountEntry == null)
{
accountEntry = new DataAccountStorageEntry(accountId);
accountEntry.Update(transactionid, timestamp, 0);
if (hasIndex)
{
accountEntry.UpdateIndex(index, transactionid, timestamp, accountIndex.TransactionCount);
}
await _accountEntryStorage.UpdateEntry(accountEntry);
}
else
{
var update = accountEntry.Update(transactionid, timestamp, 0);
if (hasIndex)
{
update |= accountEntry.UpdateIndex(index, transactionid, timestamp, accountIndex.TransactionCount);
}
if (update)
{
await _accountEntryStorage.UpdateEntry(accountEntry);
}
}
}
}
{
var sharedIndex = transaction.GetFeature <SharedAccountIndex>(SharedAccountIndex.FeatureId);
if (sharedIndex != null)
{
var accountEntry = await _accountEntryStorage.GetEntry(0);
if (accountEntry == null)
{
accountEntry = new DataAccountStorageEntry(0);
accountEntry.Update(transactionid, timestamp, 0);
accountEntry.UpdateIndex(sharedIndex.Index, transactionid, timestamp, sharedIndex.TransactionCount);
await _accountEntryStorage.UpdateEntry(accountEntry);
}
else
{
var update = accountEntry.Update(transactionid, timestamp, 0);
update |= accountEntry.UpdateIndex(sharedIndex.Index, transactionid, timestamp, sharedIndex.TransactionCount);
if (update)
{
await _accountEntryStorage.UpdateEntry(accountEntry);
}
}
}
}
{
var receiver = transaction.GetFeature <Receiver>(Receiver.FeatureId);
if (receiver != null)
{
for (var a = 0; a < receiver.Receivers.Count; a++)
{
var receiverId = receiver.Receivers[a];
var accountEntry = await _accountEntryStorage.GetEntry(receiverId);
if (accountEntry == null)
{
accountEntry = new DataAccountStorageEntry(receiverId);
accountEntry.UpdateTargeted(transactionid, timestamp);
await _accountEntryStorage.UpdateEntry(accountEntry);
}
else
{
if (accountEntry.UpdateTargeted(transactionid, timestamp))
{
await _accountEntryStorage.UpdateEntry(accountEntry);
}
}
}
}
}
{
var transactionTarget = transaction.GetFeature <TransactionTarget>(TransactionTarget.FeatureId);
if (transactionTarget != null)
{
for (var t = 0; t < transactionTarget.Targets.Count; t++)
{
var id = transactionTarget.Targets[t];
var targetedEntry = await _targetedTransactionStorage.GetEntry(id);
if (targetedEntry == null)
{
targetedEntry = new TargetedChainTransactionStorageEntry(id);
targetedEntry.Update(transactionid, timestamp, 0);
await _targetedTransactionStorage.UpdateEntry(targetedEntry);
}
else
{
if (targetedEntry.Update(transactionid, timestamp, 0))
{
await _targetedTransactionStorage.UpdateEntry(targetedEntry);
}
}
}
}
}
{
var group = transaction.GetFeature <Group>(Group.FeatureId);
if (group != null)
{
var groupId = group.GroupId;
var groupIndex = group.GroupIndex;
var hasGroupIndex = groupIndex != null;
var groupEntry = await _groupEntryStorage.GetEntry(groupId);
if (groupEntry == null)
{
groupEntry = new GroupStorageEntry(groupId);
groupEntry.Update(transactionid, timestamp, 0);
if (hasGroupIndex)
{
groupEntry.UpdateIndex(groupIndex, transactionid, timestamp, group.GroupIndexTransactionCount);
}
await _groupEntryStorage.UpdateEntry(groupEntry);
}
else
{
var update = groupEntry.Update(transactionid, timestamp, 0);
if (hasGroupIndex)
{
update |= groupEntry.UpdateIndex(groupIndex, transactionid, timestamp, group.GroupIndexTransactionCount);
}
if (update)
{
await _groupEntryStorage.UpdateEntry(groupEntry);
}
}
}
}
}
if (cache)
{
if (discStorage.ContainsIndex(nextId))
{
discStorage.UpdateEntry(operation.OperationId, operation.ToArray());
}
else
{
discStorage.AddEntry(operation.OperationId, operation.ToArray());
}
discStorage.Commit();
}
}
else
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.NetworkError, true, transactions, Operation.InvalidTransactionId));
}
}
if (operation == null)
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.InternalError, true, transactions, Operation.InvalidTransactionId));
}
var data = new TransactionDownloadData <T>(operation, this);
if (downloadAttachements && cache)
{
await DownloadTransactionAttachement(data);
}
RetrieveDecrytpedTransactionStorage(data);
transactions.Add(data);
nextId = handler.GetPreviousTransactionId(operation);
if (end && nextId <= endTransactionId)
{
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, nextId != Operation.InvalidTransactionId, transactions, nextId));
}
}
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, nextId != Operation.InvalidTransactionId, transactions, nextId));
}
catch (Exception ex)
{
Log.IgnoreException(ex);
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.InternalError, true, transactions, Operation.InvalidTransactionId));
}
finally
{
if (downloadAttachements)
{
_attachementsStorage.Value.Commit();
}
}
}
return(new TransactionDownloadResult <T>(TransactionDownloadResultCode.Ok, false, transactions, Operation.InvalidTransactionId));
}
