public async Task Process(HashEvent ev)
{
var tx = await _bitcoinTransactionRepository.FindByTransactionIdAsync(ev.Id);
if (tx == null)
{
return;
}
string hash = ev.Hash;
switch (tx.CommandType)
{
case BitCoinCommands.CashOut:
var cashOutContext = await _transactionService.GetTransactionContext <CashOutContextData>(tx.TransactionId);
var clientAcc = await _сlientAccountClient.GetByIdAsync(cashOutContext.ClientId);
var clientEmail = await _personalDataService.GetEmailAsync(cashOutContext.ClientId);
await _cashOperationsRepositoryClient.UpdateBlockchainHashAsync(cashOutContext.ClientId, cashOutContext.CashOperationId, hash);
await _srvEmailsFacade.SendNoRefundOCashOutMail(clientAcc.PartnerId, clientEmail, cashOutContext.Amount, cashOutContext.AssetId, hash);
break;
}
}
public async Task <CommandHandlingResult> Handle(Commands.SaveTransferOperationStateCommand command, IEventPublisher eventPublisher)
{
var message = command.QueueMessage;
var transactionId = message.Id;
var transaction = await _transactionsRepository.FindByTransactionIdAsync(transactionId);
if (transaction == null)
{
_log.Error(nameof(Commands.SaveManualOperationStateCommand), new Exception($"unknown transaction {transactionId}"), context: command);
return(CommandHandlingResult.Ok());
}
var amountNoFee = await _feeCalculationService.GetAmountNoFeeAsync(message);
var context = await _transactionService.GetTransactionContext <TransferContextData>(transactionId) ??
TransferContextData.Create(
message.FromClientId,
new TransferContextData.TransferModel
{
ClientId = message.ToClientid
},
new TransferContextData.TransferModel
{
ClientId = message.FromClientId
});
context.Transfers[0].OperationId = Guid.NewGuid().ToString();
context.Transfers[1].OperationId = Guid.NewGuid().ToString();
var destWallet = await _walletCredentialsRepository.GetAsync(message.ToClientid);
var sourceWallet = await _walletCredentialsRepository.GetAsync(message.FromClientId);
var contextJson = context.ToJson();
var cmd = new TransferCommand
{
Amount = amountNoFee,
AssetId = message.AssetId,
Context = contextJson,
SourceAddress = sourceWallet?.MultiSig,
DestinationAddress = destWallet?.MultiSig,
TransactionId = Guid.Parse(transactionId)
};
await SaveState(cmd, context);
eventPublisher.PublishEvent(new TransferOperationStateSavedEvent {
TransactionId = transactionId, QueueMessage = message, AmountNoFee = (double)amountNoFee
});
return(CommandHandlingResult.Ok());
}
public async Task <T> GetTransactionContext <T>(string transactionId) where T : BaseContextData
{
var fromBlob = await _contextBlobStorage.Get(transactionId);
if (string.IsNullOrWhiteSpace(fromBlob))
{
var transaction = await _transactionsRepository.FindByTransactionIdAsync(transactionId);
fromBlob = transaction?.ContextData;
}
if (fromBlob == null)
{
return(default(T));
}
return(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(fromBlob));
}
public async Task ProcessMessage(CashInOutQueueMessage message)
{
_log.Info(message: "Processing message", message.ToJson());
ChaosKitty.Meow();
var transaction = await _transactionsRepository.FindByTransactionIdAsync(message.Id);
if (transaction == null)
{
if (_cashOperationsRepositoryClient.GetAsync(message.ClientId, message.Id) == null)
{
_log.Warning($"{nameof(CashInOutQueue)}:{nameof(CashInOutQueueMessage)}", "unknown transaction", context: message.ToJson());
return;
}
await ProcessExternalCashin(message);
}
else
{
switch (transaction.CommandType)
{
case BitCoinCommands.CashIn:
case BitCoinCommands.Issue:
await ProcessIssue(message);
break;
case BitCoinCommands.CashOut:
await ProcessCashOut(message);
break;
case BitCoinCommands.ManualUpdate:
ProcessManualUpdate(message);
break;
default:
_log.Warning($"{nameof(CashInOutQueue)}:{nameof(CashInOutQueueMessage)}", $"Unknown command type (value = [{transaction.CommandType}])", context: message.ToJson());
break;
}
}
}
