private async Task HandleTransferReceived(string[] topics, string data)
        {
            var transferModel = _eventDecoder.DecodeTransferReceivedEvent(topics, data);

            var paymentTransfer = await _paymentTransfersRepository.GetByTransferIdAsync(transferModel.TransferId);

            if (paymentTransfer == null)
            {
                _log.Error(
                    message:
                    $"Payment transfer with id: {transferModel.TransferId} which was just received was not found in DB",
                    context: transferModel);
                return;
            }

            if (paymentTransfer.Status == PaymentTransferStatus.Pending)
            {
                await _transferTokensReservedPublisher.PublishAsync(new PaymentTransferTokensReservedEvent
                {
                    TransferId     = paymentTransfer.TransferId,
                    InvoiceId      = paymentTransfer.InvoiceId,
                    Amount         = paymentTransfer.AmountInTokens,
                    CustomerId     = paymentTransfer.CustomerId,
                    CampaignId     = paymentTransfer.SpendRuleId,
                    Timestamp      = DateTime.UtcNow,
                    InstalmentName = paymentTransfer.InstalmentName,
                    LocationCode   = paymentTransfer.LocationCode,
                });
            }

            var resultError = await _paymentsService.ProcessPaymentTransferAsync(paymentTransfer.TransferId);

            if (resultError != PaymentTransfersErrorCodes.None)
            {
                _log.Error(
                    message:
                    $"Payment transfer with id: {transferModel.TransferId} could not be processed because of error",
                    context: new { transferModel, resultError });
            }
        }
Beispiel #2
0
        private async Task HandlePaymentReceived(string[] topics, string data, DateTime timestamp)
        {
            var receivedPaymentModel = _eventDecoder.DecodeTransferReceivedEvent(topics, data);

            var statusUpdateResult =
                await _paymentsStatusUpdater.TokensTransferSucceedAsync(receivedPaymentModel.PaymentRequestId, timestamp);

            if (statusUpdateResult != PaymentStatusUpdateErrorCodes.None)
            {
                _log.Error(message: "Could not mark payment as TransferSucceeded because of error",
                           context: new { Error = statusUpdateResult, Payment = receivedPaymentModel });
                return;
            }

            await _paymentTokensReservedPublisher.PublishAsync(new PartnersPaymentTokensReservedEvent
            {
                PaymentRequestId = receivedPaymentModel.PaymentRequestId,
                PartnerId        = receivedPaymentModel.PartnerId,
                CustomerId       = receivedPaymentModel.CustomerId,
                LocationId       = receivedPaymentModel.LocationId,
                Amount           = receivedPaymentModel.Amount,
                Timestamp        = DateTime.UtcNow
            });
        }