private Task ProcessMessageAsync(CashTransferEvent message)
{
var fees = message.CashTransfer.Fees;
var fee = fees?.FirstOrDefault()?.Transfer;
var @event = new CashTransferProcessedEvent
{
OperationId = Guid.Parse(message.Header.RequestId),
RequestId = Guid.Parse(message.Header.MessageId),
FromWalletId = Guid.Parse(message.CashTransfer.FromWalletId),
ToWalletId = Guid.Parse(message.CashTransfer.ToWalletId),
Volume = decimal.Parse(message.CashTransfer.Volume),
AssetId = message.CashTransfer.AssetId,
Timestamp = message.Header.Timestamp,
FeeSourceWalletId = fee != null?Guid.Parse(fee.SourceWalletId) : (Guid?)null,
FeeSize = ParseNullabe(fee?.Volume)
};
_cqrsEngine.PublishEvent(@event, BoundedContext.Name);
if (fees != null)
{
var feeEvent = new FeeChargedEvent
{
OperationId = message.Header.MessageId,
OperationType = FeeOperationType.Transfer,
Fee = fees.Where(x => x.Transfer != null).Select(x => x.Transfer).ToJson()
};
_cqrsEngine.PublishEvent(feeEvent, BoundedContext.Name);
}
return(Task.CompletedTask);
}
private TransferQueueMessage ToOldModel(CashTransferEvent transferEvent)
{
return(new TransferQueueMessage
{
Id = transferEvent.Header.MessageId,
AssetId = transferEvent.CashTransfer.AssetId,
Date = transferEvent.Header.Timestamp,
FromClientId = transferEvent.CashTransfer.FromWalletId,
ToClientid = transferEvent.CashTransfer.ToWalletId,
Amount = transferEvent.CashTransfer.Volume,
Fees = transferEvent.CashTransfer.Fees?.ToOldFees(transferEvent.Header.Timestamp),
});
}
private Task ProcessMessage(CashTransferEvent transfer)
{
var cashTransfer = ToOldModel(transfer);
_cqrsEngine.SendCommand(
new Commands.SaveTransferOperationStateCommand {
QueueMessage = cashTransfer
},
BoundedContexts.TxHandler,
BoundedContexts.Operations);
return(Task.CompletedTask);
}
private async Task ProcessMessageAsync(CashTransferEvent message)
{
var fees = message.CashTransfer.Fees;
var fee = fees?.FirstOrDefault()?.Transfer;
var operationId = Guid.Parse(message.Header.RequestId);
var fromWallet = Guid.Parse(message.CashTransfer.FromWalletId);
var toWallet = Guid.Parse(message.CashTransfer.ToWalletId);
var volume = decimal.Parse(message.CashTransfer.Volume);
var timestamp = message.Header.Timestamp;
var assetId = message.CashTransfer.AssetId;
var feeSourceWalletId = fee != null?Guid.Parse(fee.SourceWalletId) : (Guid?)null;
var feeSize = ParseNullabe(fee?.Volume);
var cashInOuts = new BaseHistoryRecord[] {
new Cashout()
{
Id = operationId,
WalletId = fromWallet,
Volume = -Math.Abs(volume),
Timestamp = timestamp,
AssetId = assetId,
FeeSize = fromWallet == feeSourceWalletId ? feeSize : null,
State = Antares.Service.History.Core.Domain.Enums.HistoryState.Finished
},
new Cashin()
{
Id = operationId,
WalletId = toWallet,
Volume = Math.Abs(volume),
Timestamp = timestamp,
AssetId = assetId,
FeeSize = toWallet == feeSourceWalletId ? feeSize : null,
State = Antares.Service.History.Core.Domain.Enums.HistoryState.Finished
}
};
foreach (var cashInOut in cashInOuts)
{
if (!await _historyRecordsRepository.TryInsertAsync(cashInOut))
{
_log.Warning($"Skipped duplicated transfer record", context: new
{
id = operationId
});
}
}
}
private async Task ProcessMessageAsync(CashTransferEvent item)
{
if (!_depositCurrencies.Contains(item.CashTransfer.AssetId, StringComparer.InvariantCultureIgnoreCase))
{
return;
}
var transfer = item.CashTransfer;
if (await IsTransferBetweenClientWalletsAsync(transfer.FromWalletId, transfer.ToWalletId))
{
_log.Info("Skip transfer between client wallets", context: item.ToJson());
return;
}
double volume = Convert.ToDouble(transfer.Volume);
(double convertedVolume, string assetId) = await _currencyConverter.ConvertAsync(transfer.AssetId, volume);
if (convertedVolume == 0)
{
return;
}
string operationType = GetOperationType(item.CashTransfer);
_cqrsEngine.PublishEvent(new ClientDepositedEvent
{
ClientId = transfer.ToWalletId,
FromClientId = transfer.FromWalletId,
OperationId = item.Header.MessageId ?? item.Header.RequestId,
Asset = transfer.AssetId,
Amount = volume,
BaseAsset = assetId,
BaseVolume = convertedVolume,
OperationType = operationType,
Timestamp = item.Header.Timestamp
}, TierBoundedContext.Name);
}
private Task ProcessMessageAsync(CashTransferEvent message)
{
UpdateBalances(message.Header, message.BalanceUpdates);
return(Task.CompletedTask);
}
private async Task ProcessMessageAsync(CashTransferEvent item)
{
var id = item.Header.MessageId ?? item.Header.RequestId;
try
{
IPaymentTransaction paymentTransaction = null;
for (int i = 0; i < 3; i++)
{
paymentTransaction = await _paymentTransactionsRepository.GetByIdForClientAsync(id, item.CashTransfer.ToWalletId);
if (paymentTransaction != null)
{
break;
}
await Task.Delay(2000 *(i + 1));
}
double volume = double.Parse(item.CashTransfer.Volume);
if (item.CashTransfer.Fees != null)
{
foreach (var fee in item.CashTransfer.Fees)
{
if (string.IsNullOrWhiteSpace(fee.Transfer?.Volume))
{
continue;
}
volume -= double.Parse(fee.Transfer.Volume);
}
}
if (paymentTransaction == null || paymentTransaction.PaymentSystem != CashInPaymentSystem.Swift)
{
var cashOp = new CashOperation
{
Id = id,
ClientId = item.CashTransfer.ToWalletId,
Asset = item.CashTransfer.AssetId,
Volume = volume,
DateTime = item.Header.Timestamp,
};
await _cashOperationsCollector.AddDataItemAsync(cashOp);
}
else
{
var transfer = new CashTransferOperation
{
Id = id,
FromClientId = item.CashTransfer.FromWalletId,
ToClientId = item.CashTransfer.ToWalletId,
Asset = item.CashTransfer.AssetId,
Volume = volume,
DateTime = item.Header.Timestamp,
};
await _cashTransfersCollector.AddDataItemAsync(transfer);
}
}
catch (Exception exc)
{
_log.Error(exc, context: item);
}
}
