public async Task <Asset> GetBaseAssetOrDefault(string merchantId)
{
var baseAssetId = await GetBaseAssetId(merchantId) ?? GetDefaultBaseAssetId();
Asset baseAsset = await _lykkeAssetsResolver.TryGetAssetAsync(baseAssetId);
return(baseAsset);
}
public async Task <Payment> GetByInvoiceIdAsync(string invoiceId)
{
InvoiceModel invoice = await _payInvoiceClient.GetInvoiceAsync(invoiceId);
var payment = Mapper.Map <Payment>(invoice);
payment.SettlementAsset = await _lykkeAssetsResolver.TryGetAssetAsync(payment.SettlementAssetId);
return(payment);
}
public async Task <Invoice> GetByIdAsync(string invoiceId)
{
InvoiceModel invoice = await _payInvoiceClient.GetInvoiceAsync(invoiceId);
Asset settlementAsset = await _lykkeAssetsResolver.TryGetAssetAsync(invoice.SettlementAssetId);
PaymentRequestModel paymentRequest = null;
if (!string.IsNullOrEmpty(invoice.PaymentRequestId))
{
paymentRequest =
await _payInternalClient.GetPaymentRequestAsync(invoice.MerchantId, invoice.PaymentRequestId);
}
return(new Invoice
{
Id = invoice.Id,
Number = invoice.Number,
ClientEmail = invoice.ClientEmail,
ClientName = invoice.ClientName,
Amount = invoice.Amount,
DueDate = invoice.DueDate,
Status = invoice.Status,
SettlementAssetId = invoice.SettlementAssetId,
SettlementAsset = settlementAsset,
PaymentAssetId = invoice.PaymentAssetId,
PaymentRequestId = invoice.PaymentRequestId,
WalletAddress = paymentRequest?.WalletAddress,
CreatedDate = invoice.CreatedDate,
Note = invoice.Note
});
}
public async Task <bool> SendAsync(string invoiceId, string checkoutUrl, IReadOnlyList <string> addresses)
{
InvoiceModel invoice;
MerchantModel merchant;
try
{
invoice = await _payInvoiceClient.GetInvoiceAsync(invoiceId);
merchant = await _payMerchantClient.Api.GetByIdAsync(invoice.MerchantId);
}
catch (Exception ex)
{
_log.ErrorWithDetails(ex, new { invoiceId });
return(false);
}
Asset settlementAsset = await _lykkeAssetsResolver.TryGetAssetAsync(invoice.SettlementAssetId);
var payload = new Dictionary <string, string>
{
{ "UserName", invoice.ClientName },
{ "InvoiceNumber", invoice.Number },
{ "AmountToPay", invoice.Amount.ToStringNoZeros(settlementAsset.Accuracy) },
{ "AmountToPayAsset", settlementAsset.DisplayId },
{ "InvoiceDueDate", invoice.DueDate.ToString("d") },
{ "InvoiceUrl", checkoutUrl },
{ "Note", invoice.Note },
{ "Year", DateTime.Today.Year.ToString() },
{ "MerchantName", merchant.DisplayName ?? merchant.Name }
};
string template = string.IsNullOrEmpty(invoice.Note) ? EmailTemplateWithoutNote : EmailTemplate;
try
{
await _emailPartnerRouterClient.Send(new SendEmailCommand
{
ApplicationId = Constants.EmailApplicationId,
EmailAddresses = addresses.ToArray(),
Template = template,
Payload = payload
});
}
catch (Exception ex)
{
_log.ErrorWithDetails(ex, new { invoiceId, template });
return(false);
}
return(true);
}
public async Task <IActionResult> GetRefundData([Guid] string paymentRequestId)
{
try
{
PaymentRequestDetailsModel paymentRequestDetails = await _payInternalClient.GetPaymentRequestDetailsAsync(User.GetMerchantId(), paymentRequestId);
if (!IsStatusValidForRefund(paymentRequestDetails.Status, paymentRequestDetails.ProcessingError))
{
_log.Warning("Attempt to refund in incorrect status, details: " + paymentRequestDetails.ToJson());
return(BadRequest(ErrorResponse.Create(RefundErrorType.NotAllowedInStatus.ToString())));
}
var paymentAsset = await _lykkeAssetsResolver.TryGetAssetAsync(paymentRequestDetails.PaymentAssetId);
var refundData = new RefundDataResponse
{
PaymentAsset = Mapper.Map <AssetModel>(paymentAsset),
SourceWalletAddresses = paymentRequestDetails.Transactions.SelectMany(x => x.SourceWalletAddresses).ToList(),
Amount = paymentRequestDetails.Transactions.Sum(x => x.Amount)
};
return(Ok(refundData));
}
catch (Exception ex)
{
_log.ErrorWithDetails(ex, details: new { paymentRequestId });
return(BadRequest(ErrorResponse.Create(PayInvoicePortalApiErrorCodes.UnexpectedError)));
}
bool IsStatusValidForRefund(PaymentRequestStatus status, PaymentRequestProcessingError processingError)
{
var invoiceStatus = status.ToInvoiceStatus(processingError);
switch (invoiceStatus)
{
case InvoiceStatus.Underpaid:
case InvoiceStatus.Overpaid:
case InvoiceStatus.LatePaid:
return(true);
default:
return(false);
}
}
}
public async Task <IActionResult> GetSettings()
{
var employeeId = User.GetEmployeeId();
var merchantId = User.GetMerchantId();
try
{
var merchant = await _payMerchantClient.Api.GetByIdAsync(merchantId);
var publicKeyInfo = await _payAuthClient.GetPayAuthInformationAsync(merchantId);
var baseAssetId = await _assetService.GetBaseAssetId(merchantId);
var availableBaseAssets = (await _assetService.GetSettlementAssetsAsync(merchantId)).ToDictionary(_ => _.Key, _ => _.Value);
// need to add base asset if not empty to the list of available assets
if (!string.IsNullOrEmpty(baseAssetId) && !availableBaseAssets.ContainsKey(baseAssetId))
{
Asset asset = await _lykkeAssetsResolver.TryGetAssetAsync(baseAssetId);
availableBaseAssets.TryAdd(baseAssetId, asset?.DisplayId ?? baseAssetId);
}
var settings = new SettingsResponse
{
MerchantDisplayName = merchant.DisplayName,
EmployeeFullname = User.GetName(),
EmployeeEmail = User.GetEmail(),
AvailableBaseAssets = availableBaseAssets.Select(o => new AssetItemViewModel(o.Key, o.Value)).ToList().OrderBy(_ => _.Title),
BaseAssetId = baseAssetId,
MerchantId = merchantId,
MerchantApiKey = merchant.ApiKey,
HasPublicKey = !string.IsNullOrEmpty(publicKeyInfo.RsaPublicKey)
};
return(Ok(settings));
}
catch (Exception e)
{
_log.Error(e, new { employeeId, merchantId }.ToJson());
return(BadRequest(ErrorResponse.Create(PayInvoicePortalApiErrorCodes.UnexpectedError)));
}
}
