public async Task <InvoiceIataSpecificData> GetIataSpecificDataAsync(string invoiceId)
{
var invoiceIataSpecificData = await _invoiceIataSpecificDataCache.GetOrAddAsync
(
$"InvoiceIataSpecificData-{invoiceId}",
async x => {
try
{
var response = await _iataApiClient.GetInvoiceByIdAsync(invoiceId);
return(new InvoiceIataSpecificData
{
IsIataInvoice = true,
IataInvoiceDate = response.Date.ToString("yyyy-MM-dd"),
SettlementMonthPeriod = response.SettlementMonthPeriod
});
}
catch (ErrorResponseException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
return(new InvoiceIataSpecificData {
IsIataInvoice = false
});
}
},
DateTime.UtcNow.AddYears(1)
);
return(invoiceIataSpecificData.IsIataInvoice ? invoiceIataSpecificData : null);
}
private async Task <IReadOnlyDictionary <string, BlockchainType> > GetAssetsNetworkAsync()
{
var result = await _assetsNetworkCache.GetOrAddAsync
(
"AssetsNetworkCache",
async _ => {
try
{
IEnumerable <AssetGeneralSettingsResponse> response =
await _payInternalClient.GetAssetGeneralSettingsAsync();
return(response.ToDictionary(x => x.AssetDisplayId, x => x.Network));
}
catch (Exception ex)
{
_log.Error(ex);
return(null);
}
},
// cache for a small period in order to foreach in memory on assets if any asset has not yet cached
TimeSpan.FromSeconds(1)
);
return(result ?? new Dictionary <string, BlockchainType>());
}
private Task <string> GetCachedCustomerWalletAddressAsync(string customerId)
{
return(_customerWalletsCache.GetOrAddAsync(
customerId,
GetCustomerWalletAddressAsync,
_customerWalletsCacheExpirationPeriod));
}
private Task <IEnumerable <VolatilityModel> > GetCachedValueAsync(string key, Func <Task <IEnumerable <VolatilityModel> > > factory)
{
if (_settings.ExpirationTimeUTC.HasValue)
{
DateTimeOffset expiration = DateTime.UtcNow.Date.Add(_settings.ExpirationTimeUTC.Value.TimeOfDay);
if (expiration <= DateTime.UtcNow)
{
expiration = expiration.AddDays(1);
}
return(_memoryCache.GetOrAddAsync(key, k => factory(), expiration));
}
if (_settings.CachePeriod.HasValue)
{
return(_memoryCache.GetOrAddAsync(key, k => factory(), _settings.CachePeriod.Value));
}
return(_memoryCache.GetOrAddAsync(key, k => factory(), TimeSpan.FromHours(CacheHours)));
}
public async Task <string> GetMerchantNameAsync(string merchantId)
{
var merchantName = await _merchantNamesCache.GetOrAddAsync
(
$"MerchantName-{merchantId}",
async x => {
var merchant = await _payMerchantClient.Api.GetByIdAsync(merchantId);
return(merchant.DisplayName);
},
_cacheExpirationPeriods.MerchantName
);
return(merchantName);
}
public async Task <string> GetMerchantLogoUrlAsync(string merchantId)
{
var merchantLogoUrl = await _merchantLogoUrlsCache.GetOrAddAsync
(
$"MerchantLogoUrl-{merchantId}",
async x => {
try
{
return(await _payInternalClient.GetMerchantLogoUrl(merchantId));
}
catch (DefaultErrorResponseException ex) when(ex.StatusCode == HttpStatusCode.NotFound)
{
return(_merchantSettings.MerchantDefaultLogoUrl);
}
},
_cacheExpirationPeriods.MerchantLogoUrl
);
return(merchantLogoUrl);
}
public async Task <IReadOnlyDictionary <string, string> > GetIataBillingCategoriesAsync()
{
var iataBillingCategories = await _iataBillingCategories.GetOrAddAsync
(
"IataBillingCategories",
async x => {
try
{
IReadOnlyList <string> response = await _iataApiClient.GetBillingCategoriesAsync();
return(response);
}
catch (ErrorResponseException)
{
return(new List <string>());
}
},
_cacheExpirationPeriodsSettings.IataBillingCategories
);
return(iataBillingCategories?.ToDictionary(x => x, x => x));
}
public async Task <BlockchainType> GetAssetNetworkAsync(string assetId)
{
var result = await _assetBlockchainTypeCache.GetOrAddAsync
(
$"AssetBlockchainTypeCache-{assetId}",
async _ =>
{
try
{
var assetsNetwork = await GetAssetsNetworkAsync();
return(assetsNetwork.TryGetValue(assetId, out var network) ? new Tuple <BlockchainType>(network) : new Tuple <BlockchainType>(BlockchainType.None));
}
catch (Exception ex)
{
_log.Error(ex);
return(null);
}
}
);
return(result?.Item1 ?? BlockchainType.None);
}
public async Task <IReadOnlyList <HistoryItem> > GetHistoryAsync(string merchantId, string invoiceId)
{
IReadOnlyList <HistoryItemModel> history = await _payInvoiceClient.GetInvoiceHistoryAsync(invoiceId);
history = history
.GroupBy(o => o.Status)
.Where(o => !_excludeStatusesFromHistory.Contains(o.Key))
.SelectMany(o => _getOnlyFirstStatusesFromHistory.Contains(o.Key)
? new List <HistoryItemModel> {
o.OrderBy(s => s.Date).First()
}
: o.ToList())
.OrderBy(o => o.Date)
.ToList();
var items = new List <HistoryItem>();
foreach (HistoryItemModel item in history)
{
var authorFullName = string.Empty;
if (!string.IsNullOrEmpty(item.ModifiedById))
{
authorFullName = await _employeeFullNameCache.GetOrAddAsync
(
$"EmployeeFullNameCache-{item.ModifiedById}",
async _ => {
try
{
var employee = await _payInvoiceClient.GetEmployeeAsync(item.ModifiedById);
return(employee != null ? $"{employee.FirstName} {employee.LastName}" : string.Empty);
}
catch (Exception ex)
{
_log.Error(ex);
return(null);
}
}
);
}
Asset historySettlementAsset = await _lykkeAssetsResolver.TryGetAssetAsync(item.SettlementAssetId);
Asset historyPeymentAsset = await _lykkeAssetsResolver.TryGetAssetAsync(item.PaymentAssetId);
items.Add(new HistoryItem
{
AuthorFullName = authorFullName,
Status = item.Status,
PaymentAmount = item.PaymentAmount,
SettlementAmount = item.SettlementAmount,
PaidAmount = item.PaidAmount,
PaymentAsset = historyPeymentAsset,
SettlementAsset = historySettlementAsset,
ExchangeRate = item.ExchangeRate,
SourceWalletAddresses = item.SourceWalletAddresses,
RefundWalletAddress = item.RefundWalletAddress,
RefundAmount = item.RefundAmount,
DueDate = item.DueDate,
PaidDate = item.PaidDate,
Date = item.Date
});
}
return(items);
}
