public async Task <ConfirmationResponse> CancelAsync(TradeKey tradeKey, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
var tradeDataObject = await GetTradeAsync(tradeKey.TradeReference, tradeKey.TradeLeg, apiJwtToken);
if (tradeDataObject is null || tradeDataObject.IsConfirmationWithheld())
{
return(new ConfirmationResponse());
}
if (string.IsNullOrEmpty(tradeDataObject.ConfirmationDocumentId()))
{
return(new ConfirmationResponse
{
IsSuccessStatusCode = false,
Message = "Cannot cancel confirmation, confirmation has yet to be submitted"
});
}
return(await DeleteConfirmationAsync(tradeDataObject, await CreateTradeConfirmationAsync(tradeDataObject, apiJwtToken, fidectusConfiguration), apiJwtToken, fidectusConfiguration));
}
public async Task <ConfirmationResponse> SendConfirmation(string method, string companyId, ConfirmationRequest confirmationRequest,
RequestTokenResponse requestTokenResponse, IFidectusConfiguration fidectusConfiguration)
{
async Task <ConfirmationResponse> PostConfirmationAsync(HttpClient httpClient)
{
return(await PostAsync <ConfirmationRequest, ConfirmationResponse>(httpClient, fidectusConfiguration.FidectusConfirmationUrl, confirmationRequest, false));
}
async Task <ConfirmationResponse> PutConfirmationAsync(HttpClient httpClient)
{
return(await PutAsync <ConfirmationRequest, ConfirmationResponse>(httpClient, $"{fidectusConfiguration.FidectusConfirmationUrl}/{confirmationRequest.TradeConfirmation?.DocumentId}", confirmationRequest, false));
}
async Task <ConfirmationResponse> HttpMethod(string httpMethod, HttpClient httpClient)
{
return(httpMethod switch
{
"POST" => await PostConfirmationAsync(httpClient),
"PUT" => await PutConfirmationAsync(httpClient),
_ => throw new Exception($"Unknown HTTP method ({method})")
});
}
private async Task <RequestTokenResponse> CreateAuthenticationTokenAsync(string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
return(await fidectusAuthenticationService.FidectusGetAuthenticationToken(await CreateAuthenticationTokenRequestAsync(apiJwtToken), fidectusConfiguration));
}
public async Task <ConfirmationResponse> ConfirmAsync(TradeKey tradeKey, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
var tradeDataObject = await GetTradeAsync(tradeKey.TradeReference, tradeKey.TradeLeg, apiJwtToken);
if (tradeDataObject is null || tradeDataObject.IsConfirmationWithheld())
{
return(new ConfirmationResponse {
IsSuccessStatusCode = true
});
}
var tradeConfirmation = await CreateTradeConfirmationAsync(tradeDataObject, apiJwtToken, fidectusConfiguration);
var method = string.IsNullOrWhiteSpace(tradeDataObject.ConfirmationDocumentId())
? "POST"
: "PUT";
var confirmationResponse = await SendConfirmationAsync(method, tradeConfirmation, apiJwtToken, fidectusConfiguration);
if (confirmationResponse.IsSuccessStatusCode)
{
return(confirmationResponse);
}
if (confirmationResponse.StatusCode == 409)
{
logger.LogInformation("Already sent ({StatusCode}), trying a PUT...", confirmationResponse.StatusCode);
return(await SendConfirmationAsync("PUT", tradeConfirmation, apiJwtToken, fidectusConfiguration));
}
throw new DataException(string.IsNullOrWhiteSpace(confirmationResponse.Message)
? "Failed to send confirmation"
: $"Failed to send confirmation ({confirmationResponse.Message})");
}
private async Task <ConfirmationResponse> DeleteConfirmationAsync(TradeDataObject tradeDataObject, TradeConfirmation tradeConfirmation, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
try
{
return(await fidectusService.DeleteConfirmation(fidectusConfiguration.CompanyId(tradeConfirmation.SenderId),
tradeDataObject.ConfirmationDocumentId(), await CreateAuthenticationTokenAsync(apiJwtToken, fidectusConfiguration), fidectusConfiguration));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
throw;
}
}
private async Task <TradeConfirmation> MapTradeConfirmationAsync(TradeDataObject tradeDataObject, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
var tradeSummary = (await tradeSummaryService.TradeSummaryAsync(tradeDataObject.TradeReference, tradeDataObject.TradeLeg, apiJwtToken))?.Data?.FirstOrDefault();
var profileResponses = (await profileService.ProfileAsync(tradeDataObject.TradeReference, tradeDataObject.TradeLeg, apiJwtToken, ProfileTradeConstants.ProfileFormatSparse))?.Data;
return(await fidectusMappingService.MapConfirmation(tradeDataObject, tradeSummary, profileResponses, apiJwtToken, fidectusConfiguration));
}
private async Task <ConfirmationResponse> SendConfirmationAsync(string method, TradeConfirmation tradeConfirmation, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
try
{
return(await fidectusService.SendConfirmation(method, fidectusConfiguration.CompanyId(tradeConfirmation.SenderId),
new ConfirmationRequest { TradeConfirmation = tradeConfirmation },
await CreateAuthenticationTokenAsync(apiJwtToken, fidectusConfiguration), fidectusConfiguration));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
throw;
}
}
public async Task <TradeConfirmation> CreateTradeConfirmationAsync(TradeDataObject tradeDataObject, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
try
{
return(await MapTradeConfirmationAsync(tradeDataObject, apiJwtToken, fidectusConfiguration));
}
catch (Exception ex)
{
logger.LogError(ex, "{Message}", ex.Message);
throw;
}
}
public async Task <ConfirmationResultResponse> BoxResult(TradeKey tradeKey, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
var tradeDataObject = await GetTradeAsync(tradeKey.TradeReference, tradeKey.TradeLeg, apiJwtToken);
if (tradeDataObject is null)
{
return(new ConfirmationResultResponse());
}
var requestTokenResponse = await CreateAuthenticationTokenAsync(apiJwtToken, fidectusConfiguration);
var companyId = fidectusConfiguration.CompanyId();
var boxResultResponse = await fidectusService.GetBoxResult(companyId, tradeDataObject.ConfirmationDocumentId(), requestTokenResponse, fidectusConfiguration);
return(new ConfirmationResultResponse
{
Id = boxResultResponse.Id,
DocumentId = boxResultResponse.BoxResult?.DocumentId,
DocumentVersion = boxResultResponse.BoxResult?.DocumentVersion,
DocumentType = boxResultResponse.BoxResult?.DocumentType,
State = boxResultResponse.BoxResult?.State,
Timestamp = boxResultResponse.BoxResult?.Timestamp,
CounterpartyDocumentId = boxResultResponse.BoxResult?.Counterparty?.DocumentId,
CounterpartyDocumentVersion = boxResultResponse.BoxResult?.Counterparty?.DocumentVersion
});
}
public async Task <TradeConfirmation> MapConfirmation(TradeDataObject tradeDataObject, TradeSummaryResponse tradeSummaryResponse,
IEnumerable <ProfileResponse> profileResponses, string apiJwtToken, IFidectusConfiguration fidectusConfiguration)
{
if (tradeDataObject is null)
{
throw new DataException("Trade is null");
}
if (tradeDataObject.Product?.Commodity?.Timezone is null)
{
throw new DataException("Trade's timezone is null");
}
if (profileResponses is null)
{
throw new DataException("No profile data");
}
var timezone = DateTimeHelper.GetTimeZone(tradeDataObject.Product?.Commodity?.Timezone);
var senderId = await MapSenderId(tradeDataObject, apiJwtToken);
var receiverId = await MapReceiverId(tradeDataObject, apiJwtToken);
var buyerEic = await MapEic(tradeDataObject.Buyer, "Buyer party", apiJwtToken);
var sellerEic = await MapEic(tradeDataObject.Seller, "Seller party", apiJwtToken);
var commodity = MapCommodityToCommodity(tradeDataObject.Product?.Commodity?.Commodity, fidectusConfiguration);
return(new TradeConfirmation
{
DocumentId = MapDocumentId(tradeDataObject, senderId),
DocumentUsage = fidectusConfiguration.GetSetting("FidectusConfirmationUsage", "Live"),
SenderId = senderId,
ReceiverId = receiverId,
ReceiverRole = "Trader",
DocumentVersion = 1,
Market = tradeDataObject.Product?.Commodity?.Country,
Commodity = commodity,
TransactionType = MapContractTypeToTransactionType(tradeDataObject.Product?.ContractType, fidectusConfiguration),
DeliveryPointArea = tradeDataObject.Product?.Commodity?.DeliveryArea?.Eic,
BuyerParty = buyerEic,
SellerParty = sellerEic,
LoadType = MapShapeDescriptionToLoadType(tradeDataObject.Product?.ShapeDescription, "Custom", fidectusConfiguration),
Agreement = MapContractAgreementToAgreement(tradeDataObject.Contract?.AgreementType?.AgreementType, tradeDataObject.Product?.Commodity?.Commodity, fidectusConfiguration),
Currency = MapPriceUnitToCurrency(tradeDataObject.Price?.PriceUnit),
TotalVolume = AbsoluteValue(tradeSummaryResponse?.TotalVolume),
TotalVolumeUnit = MapEnergyUnitToVolumeUnit(tradeDataObject.Quantity?.QuantityUnit?.EnergyUnit?.EnergyUnit, fidectusConfiguration),
TradeDate = tradeDataObject.TradeDateTime.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture),
CapacityUnit = MapQuantityUnitToCapacityUnit(tradeDataObject.Quantity?.QuantityUnit?.QuantityUnit, fidectusConfiguration),
PriceUnit = MapPriceUnitToPriceUnit(tradeDataObject.Price?.PriceUnit, fidectusConfiguration),
TotalContractValue = AbsoluteValue(tradeSummaryResponse?.TotalValue),
TimeIntervalQuantities = MapProfileResponsesToDeliveryStartTimes(tradeDataObject.Quantity?.Quantity, profileResponses, timezone, tradeDataObject.Price?.PriceUnit?.CurrencyExponent),
TraderName = tradeDataObject.InternalTrader?.ContactLongName,
HubCodificationInformation = commodity == FidectusConstants.CommodityGas
? await MapHubCodificationInformation(tradeDataObject.Buyer, tradeDataObject.Seller, apiJwtToken)
: null,
AccountAndChargeInformation = commodity == FidectusConstants.CommodityPower
? MapAccountAndChargeInformation(tradeDataObject)
: null,
Agents = commodity == FidectusConstants.CommodityPower
? new List <Agent>
{
new()
{
AgentName = tradeDataObject.Extension?.EcvnAgentParty?.Extension?.BscParty?.BscPartyLongName,
AgentType = FidectusConstants.AgentTypeEcvna,
Ecvna = new Ecvna
{
BscPartyId = await MapBscParty(tradeDataObject.Extension?.EcvnAgentParty?.Extension?.BscParty, apiJwtToken),
BuyerEnergyAccount = tradeDataObject.Extension?.BuyerEnergyAccount,
SellerEnergyAccount = tradeDataObject.Extension?.SellerEnergyAccount,
BuyerId = await MapBuyerSellerId(tradeDataObject.Buyer, apiJwtToken),
SellerId = await MapBuyerSellerId(tradeDataObject.Seller, apiJwtToken),
}
}
}
public async Task <RequestTokenResponse> FidectusGetAuthenticationToken(RequestTokenRequest requestTokenRequest, IFidectusConfiguration fidectusConfiguration)
{
var requestTokenResponse = await redisService.Get <FidectusAuthenticationToken>(RedisConstants.FidectusAuthenticationTokenKey, requestTokenRequest.ClientId);
if (!string.IsNullOrWhiteSpace(requestTokenResponse?.AccessToken))
{
logger.LogInformation("Reusing cached Fidectus access token...");
return(new RequestTokenResponse
{
AccessToken = requestTokenResponse.AccessToken,
IsSuccessStatusCode = true
});
}
logger.LogInformation("Getting new Fidectus access token...");
var httpClient = httpClientFactory.CreateClient();
httpClient.BaseAddress = new Uri(fidectusConfiguration.FidectusAuthUrl);
var getAuthenticationToken = await PostAsync <RequestTokenRequest, RequestTokenResponse>(httpClient, fidectusConfiguration.FidectusAuthUrl, requestTokenRequest);
var fidectusAuthenticationToken = new FidectusAuthenticationToken {
AccessToken = getAuthenticationToken.AccessToken
};
await redisService.Set(fidectusAuthenticationToken, 24, RedisConstants.FidectusAuthenticationTokenKey, requestTokenRequest.ClientId);
logger.LogInformation("New Fidectus access token cached");
return(getAuthenticationToken);
}
