public async Task PublishAsync(PaymentRequestDetailsMessage message)
{
await _log.WriteInfoAsync(nameof(PaymentRequestPublisher), nameof(PublishAsync), $"message = {message.ToJson()}",
"Publishing payment request status update message");
await _publisher.ProduceAsync(message);
}
private Task ReportRefundRequiredAsync(PaymentRequestDetailsMessage message, bool isKycRequired)
{
string text = _formatter.FormatRefundRequired(message, isKycRequired);
_log.Info(text, GetLogContext(message));
return(_telegramSender.SendTextMessageAsync(_settings.ChatId, text, ParseMode.Markdown));
}
private Task ReportConfirmedAsync(PaymentRequestDetailsMessage message, bool isPaidWithError)
{
bool isKycRequired = _settings.MerchantIds.Contains(message.MerchantId, StringComparer.OrdinalIgnoreCase);
if (isKycRequired)
{
if (!isPaidWithError &&
message.Transactions?.Any(t =>
t.SourceWalletAddresses?.Any(a =>
_settings.LykkeXHotWallets.Contains(a, StringComparer.OrdinalIgnoreCase)) ==
true) == true)
{
return(ReportPaymentCompletedAsync(message, isKycRequired));
}
return(ReportRefundRequiredAsync(message, isKycRequired));
}
if (!isPaidWithError)
{
return(ReportPaymentCompletedAsync(message, isKycRequired));
}
return(ReportRefundRequiredAsync(message, isKycRequired));
}
private object GetLogContext(PaymentRequestDetailsMessage message)
{
return(new
{
PaymentRequestId = message.Id,
message.MerchantId
});
}
public async Task PublishAsync(IPaymentRequest paymentRequest, Core.Domain.PaymentRequests.PaymentRequestRefund refundInfo)
{
PaymentRequestDetailsMessage message = await _paymentRequestDetailsBuilder.Build <
PaymentRequestDetailsMessage,
PaymentRequestOrder,
PaymentRequestTransaction,
PaymentRequestRefund>(paymentRequest, refundInfo);
await PublishAsync(message);
}
private async Task ProcessMessageAsync(PaymentRequestDetailsMessage message)
{
try
{
await _invoiceService.UpdateAsync(message);
}
catch (Exception ex)
{
_log.ErrorWithDetails(ex, message);
}
}
private async Task ProcessMessageAsync(PaymentRequestDetailsMessage message)
{
try
{
await _notificationsService.NotifyStatusUpdateAsync(
Mapper.Map <InvoiceStatusUpdateNotification>(message));
}
catch (Exception ex)
{
_log.ErrorWithDetails(ex, message);
}
}
public string FormatPaymentCompleted(PaymentRequestDetailsMessage message, bool isKycRequired)
{
return(string.Format(
MessageTemplates.PaymentCompleted,
message.MerchantId,
isKycRequired ? MessageTemplates.KycRequiredText : string.Empty,
message.WalletAddress,
GetSourceWalletAddressesText(message.Transactions),
message.PaidAmount,
message.PaymentAssetId,
message.Id
));
}
public async Task ProcessPaymentRequestUpdate(PaymentRequestDetailsMessage model)
{
var callback = await _paymentCallbackRepository.GetAsync(model.MerchantId, model.Id);
if (callback == null)
{
throw new CallbackNotFoundException(model.Id);
}
string content = JsonConvert.SerializeObject(model.ToStatusApiModel(), new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
NullValueHandling = NullValueHandling.Include
});
await HttpClient.PostAsync(callback.Url, new StringContent(content, Encoding.UTF8, "application/json"));
}
private async Task ProcessMessageAsync(PaymentRequestDetailsMessage message)
{
try
{
await _callbackService.ProcessPaymentRequestUpdate(message);
_log.Info("Payment request update processed", message.ToJson());
}
catch (CallbackNotFoundException ex)
{
_log.Info($"Callback url not found for payment request id {ex.PaymentRequestId}");
}
catch (Exception ex)
{
_log.Error(ex, null, message.ToJson());
throw;
}
}
public Task ReportAsync(PaymentRequestDetailsMessage message)
{
switch (message.Status)
{
case PaymentRequestStatus.Confirmed:
return(ReportConfirmedAsync(message, false));
case PaymentRequestStatus.Error:
switch (message.ProcessingError)
{
case PaymentRequestProcessingError.LatePaid:
case PaymentRequestProcessingError.PaymentAmountBelow:
case PaymentRequestProcessingError.PaymentAmountAbove:
return(ReportConfirmedAsync(message, true));
}
break;
}
return(Task.CompletedTask);
}
public static PaymentStatusModel ToStatusApiModel(this PaymentRequestDetailsMessage src)
{
PaymentStatusModel response = new PaymentStatusModel
{
Id = src.Id,
PaymentAsset = src.PaymentAssetId,
SettlementAsset = src.SettlementAssetId,
OrderId = src.OrderId,
PaymentRequest = new PaymentRequestModel
{
Amount = src.Order?.PaymentAmount,
Address = src.WalletAddress,
CreatedAt = src.Timestamp.ToIsoDateTime(),
ExchangeRate = src.Order?.ExchangeRate,
ExpirationDt = src.DueDate.ToIsoDateTime(),
Transactions = src.Transactions.Any() ? src.Transactions.Select(Mapper.Map <PaymentTransactionModel>).ToList() : null
}
};
switch (src.Status)
{
case PaymentRequestStatus.New:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentRequestCreated;
break;
case PaymentRequestStatus.Confirmed:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentConfirmed;
break;
case PaymentRequestStatus.InProcess:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentInProgress;
break;
case PaymentRequestStatus.Cancelled:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentCancelled;
break;
case PaymentRequestStatus.Error:
switch (src.ProcessingError)
{
case PaymentRequestProcessingError.PaymentAmountAbove:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentAmountAbove
};
break;
case PaymentRequestProcessingError.PaymentAmountBelow:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentAmountBelow
};
break;
case PaymentRequestProcessingError.PaymentExpired:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentExpired
};
break;
case PaymentRequestProcessingError.LatePaid:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.LatePaid
};
break;
case PaymentRequestProcessingError.RefundNotConfirmed:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundError;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
response.Error = new ErrorModel
{
Code = PaymentRequestErrorPublicCodes.TransactionNotConfirmed
};
break;
case PaymentRequestProcessingError.UnknownPayment:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
break;
case PaymentRequestProcessingError.UnknownRefund:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundError;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
response.Error = new ErrorModel
{
Code = PaymentRequestErrorPublicCodes.RefundIsNotAvailable
};
break;
default:
throw new Exception("Unknown payment request error type");
}
break;
case PaymentRequestStatus.RefundInProgress:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundInProgress;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
break;
case PaymentRequestStatus.Refunded:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundConfirmed;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
break;
default:
throw new Exception("Unknown payment request status");
}
return(response);
}
public async Task PublishAsync(PaymentRequestDetailsMessage message)
{
_log.Info("Publishing payment request status update message", message);
await _publisher.ProduceAsync(message);
}
private Task ProcessMessageAsync(PaymentRequestDetailsMessage message)
{
return(_paymentRequestStatusReporter.ReportAsync(message));
}
