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));
}
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 <PhysicalTrade> CreatePhysicalTradeAsync(TradeDataObject tradeDataObject, string apiJwtToken)
{
var mappingHelper = new MappingHelper(await equiasMappingService.GetMappingsAsync(apiJwtToken));
var tradeSummary = (await tradeSummaryService.TradeSummaryAsync(tradeDataObject.TradeReference, tradeDataObject.TradeLeg, apiJwtToken))?.Data?.FirstOrDefault();
var cashflows = (await cashflowService.CashflowAsync(tradeDataObject.TradeReference, tradeDataObject.TradeLeg, apiJwtToken))?.Data;
var profileResponses = (await profileService.ProfileAsync(tradeDataObject.TradeReference, tradeDataObject.TradeLeg, apiJwtToken, ProfileTradeConstants.ProfileFormatSparse))?.Data;
logger.LogTrace("Trade Summary: {TradeSummary}\r\n", TradeCubeJsonSerializer.Serialize(tradeSummary));
logger.LogTrace("Trade Cashflows: {TradeCashflows}\r\n", TradeCubeJsonSerializer.Serialize(cashflows));
logger.LogTrace("Trade Profile: {TradeProfile}\r\n", TradeCubeJsonSerializer.Serialize(profileResponses));
return(await equiasMappingService.MapTrade(tradeDataObject, tradeSummary, cashflows, profileResponses, mappingHelper, apiJwtToken));
}
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 <ApiResponseWrapper <IEnumerable <TradeDataObject> > > SaveTradeAsync(TradeDataObject tradeDataObject, string apiJwtToken)
{
return(await tradeService.PutTradesViaJwtAsync(apiJwtToken, new List <TradeDataObject> {
tradeDataObject
}));
}
private static TradeDataObject SetTradePostSubmission(EboTradeResponse eboAddTradeResponse, TradeDataObject tradeDataObject)
{
if (eboAddTradeResponse is null)
{
throw new ArgumentNullException(nameof(eboAddTradeResponse));
}
if (tradeDataObject is null)
{
throw new ArgumentNullException(nameof(tradeDataObject));
}
// Mutation!
tradeDataObject.External ??= new ExternalFieldsType();
tradeDataObject.External.Equias ??= new EquiasType();
tradeDataObject.External.Equias.EboTradeId = eboAddTradeResponse.TradeId;
tradeDataObject.External.Equias.EboTradeVersion = eboAddTradeResponse.TradeVersion;
tradeDataObject.External.Equias.EboSubmissionStatus = eboAddTradeResponse.IsSuccessStatusCode
? ApiConstants.SuccessResult
: ApiConstants.FailedResult;
tradeDataObject.External.Equias.EboSubmissionMessage = eboAddTradeResponse.Message;
tradeDataObject.External.Equias.EboStatusLastCheckedTime = DateTime.UtcNow;
return(tradeDataObject);
}
private static TradeDataObject SetTradePreSubmission(EboGetTradeStatusResponse eboGetTradeStatusResponse, TradeDataObject tradeDataObject)
{
if (eboGetTradeStatusResponse is null)
{
throw new ArgumentNullException(nameof(eboGetTradeStatusResponse));
}
if (tradeDataObject is null)
{
throw new ArgumentNullException(nameof(tradeDataObject));
}
var getTradeStatus = eboGetTradeStatusResponse.States.SingleOrDefault();
// Mutation!
tradeDataObject.External ??= new ExternalFieldsType();
tradeDataObject.External.Equias ??= new EquiasType();
tradeDataObject.External.Equias.EboTradeId = eboGetTradeStatusResponse.States.SingleOrDefault()?.TradeId;
tradeDataObject.External.Equias.EboSubmissionTime = DateTime.UtcNow;
tradeDataObject.External.Equias.EboSubmissionStatus = getTradeStatus?.TradeVersion is null
? EquiasConstants.StatusSubmitted
: EquiasConstants.StatusResubmitted;
return(tradeDataObject);
}
public async Task <PhysicalTrade> MapTrade(TradeDataObject tradeDataObject, TradeSummaryResponse tradeSummaryResponse, IEnumerable <CashflowResponse> cashflowResponses,
IEnumerable <ProfileResponse> profileResponses, MappingHelper mappingHelper, string apiJwtToken)
{
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 (cashflowResponses is null)
{
throw new DataException("No cashflow data");
}
if (profileResponses is null)
{
throw new DataException("No profile data");
}
var timezone = DateTimeHelper.GetTimeZone(tradeDataObject.Product?.Commodity?.Timezone);
var cashflows = cashflowResponses.ToList();
var commodity = MapCommodityToCommodity(tradeDataObject.Product?.Commodity?.Commodity, mappingHelper);
var buyerEic = await MapEic(tradeDataObject.Buyer, "Buyer party", apiJwtToken);
var sellerEic = await MapEic(tradeDataObject.Seller, "Seller party", apiJwtToken);
var beneficiaryId = await MapEic(tradeDataObject.Beneficiary, "Beneficiary party", apiJwtToken, buyerEic);
return(new PhysicalTrade
{
ActionType = tradeDataObject.EboActionType(),
TradeId = TestMapTradeReferenceToTradeId(tradeDataObject.TradeReference, tradeDataObject.TradeLeg),
Uti = tradeDataObject.Uti,
ProcessInformation = new ProcessInformation
{
ReportingOnBehalfOf = false,
EmirReportMode = CmsReportType,
RemitReportMode = CmsReportType
},
Market = MapCommodityToMarket(tradeDataObject.Product?.Commodity),
Commodity = commodity,
TransactionType = MapContractTypeToTransactionType(tradeDataObject.Product?.ContractType, mappingHelper),
DeliveryPointArea = tradeDataObject.Product?.Commodity?.DeliveryArea?.Eic,
BuyerParty = buyerEic,
SellerParty = sellerEic,
BeneficiaryId = beneficiaryId,
Intragroup = MapInternalToIntragroup(tradeDataObject.Buyer?.Internal, tradeDataObject.Seller?.Internal),
LoadType = MapShapeDescriptionToLoadType(tradeDataObject.Product?.ShapeDescription, "Custom", mappingHelper),
Agreement = MapContractAgreementToAgreement(tradeDataObject.Contract?.AgreementType?.AgreementType, tradeDataObject.Product?.Commodity?.Commodity, mappingHelper),
TotalVolume = AbsoluteValue(tradeSummaryResponse?.TotalVolume),
TotalVolumeUnit = MapEnergyUnitToVolumeUnit(tradeDataObject.Quantity?.QuantityUnit?.EnergyUnit?.EnergyUnit, mappingHelper),
TradeExecutionTimestamp = EquiasDateTimeHelper.FormatDateTimeWithOffset(tradeDataObject.TradeDateTime, timezone),
CapacityUnit = MapQuantityUnitToCapacityUnit(tradeDataObject.Quantity?.QuantityUnit?.QuantityUnit, mappingHelper),
PriceUnit = MapPriceUnit(tradeDataObject.Price?.PriceUnit, mappingHelper),
TotalContractValue = AbsoluteValue(tradeSummaryResponse?.TotalValue),
SettlementCurrency = tradeSummaryResponse?.TotalValueCurrency,
SettlementDates = cashflows.Any()
? cashflows.SelectMany(d => d.Cashflows.Select(c => c.SettlementDate.ToIso8601DateTime()))
: null,
TimeIntervalQuantities = MapProfileResponsesToDeliveryStartTimes(tradeDataObject.Quantity?.Quantity, profileResponses, timezone, tradeDataObject.Price?.PriceUnit?.CurrencyExponent),
TraderName = tradeDataObject.InternalTrader?.ContactLongName,
HubCodificationInformation = commodity == EquiasConstants.CommodityGas
? await MapHubCodificationInformation(tradeDataObject.Buyer, tradeDataObject.Seller, apiJwtToken)
: null,
Agents = commodity == EquiasConstants.CommodityPower
? new List <Agent>
{
new()
{
AgentName = tradeDataObject.Extension?.BuyerEnergyAccount,
AgentType = EquiasConstants.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),
NotificationAgent = await MapNotificationAgent(tradeDataObject.Extension?.EcvnAgentParty, apiJwtToken),
TransmissionChargeIdentification = MapSchedule5(tradeDataObject.Extension?.Schedule5, mappingHelper)
}
}
}
public async Task <TradeDataObject> ConvertTradeAsync(OwnTrade m7Trade, string apiKey)
{
try
{
var tradeDateTime = m7Trade.execTimeUTC;
var tradeId = m7Trade.tradeId;
var accountId = m7Trade.acctId;
var userCode = m7Trade.usrCode;
var quantity = m7Trade.qty;
var price = m7Trade.px;
var side = m7Trade.side;
var deliveryAreaId = m7Trade.dlvryAreaId;
var deliveryStart = m7Trade.Contract.dlvryStartUTC;
var deliveryEnd = m7Trade.Contract.dlvryEndUTC;
var exchangeId = m7Trade.Product.exchangeId;
var aggressorIndicator = m7Trade.aggressorIndicator?.ToUpper();
var allMappings = (await mappingService.GetMappingsViaApiKeyAsync(apiKey)).Data.ToDictionary(k => k.MappingKey, v => v);
var allSettings = (await settingService.GetSettingsViaApiKeyAsync(apiKey)).Data.ToDictionary(k => k.SettingName, v => v);
var tradeStatus = "Live";
var quantityType = "Fixed";
var priceType = "Fixed";
var buySell = MapSideToBuySell(side);
var commodityMapping = MapDeliveryAreaToCommodityAsync(deliveryAreaId, allMappings);
var fingerprintTask = MapCommodityToProductAsync(commodityMapping?.MappingTo, deliveryStart, deliveryEnd, apiKey);
var internalPartyTask = im7PartyService.MapInternalPartyAsync(accountId, allMappings, allSettings, apiKey);
var counterpartyTask = im7PartyService.MapCounterpartyAsync(exchangeId, allMappings, allSettings, apiKey);
var fingerprint = await fingerprintTask;
var internalParty = await internalPartyTask;
var counterparty = await counterpartyTask;
var tradingBook = await tradingBookService.MapTradingBookAsync(deliveryAreaId, allMappings, allSettings, apiKey);
var internalTrader = await contactService.MapInternalTraderAsync(userCode, allMappings, allSettings, apiKey);
var venue = await venueService.MapVenueAsync(exchangeId, allMappings, allSettings, apiKey);
if (internalParty is null)
{
throw new DataException("Could not map InternalParty");
}
if (counterparty is null)
{
throw new DataException("Could not map Counterparty");
}
if (tradingBook is null)
{
throw new DataException("Could not map TradingBook");
}
if (internalTrader is null)
{
throw new DataException("Could not map InternalTrader");
}
if (venue is null)
{
throw new DataException("Could not map Venue");
}
var trade = new TradeDataObject
{
TradeDateTime = tradeDateTime,
TradeStatus = tradeStatus,
BuySell = buySell,
Product = fingerprint?.ProductDataObject,
TradingBook = tradingBook,
InternalParty = internalParty,
InternalTrader = internalTrader,
Counterparty = counterparty,
CounterpartyReference = tradeId.ToString(),
Buyer = buySell == "Buy"
? internalParty
: counterparty,
Seller = buySell == "Sell"
? internalParty
: counterparty,
Exchange = counterparty,
ExchangeReference = tradeId.ToString(),
Initiator = aggressorIndicator == "Y"
? counterparty
: internalParty,
Aggressor = aggressorIndicator == "Y"
? internalParty
: counterparty,
Venue = venue,
Quantity = new QuantityDataObject
{
Quantity = quantity,
QuantityType = quantityType,
QuantityUnit = fingerprint?.ProductDataObject?.QuantityUnit
},
Price = new PriceDataObject
{
Price = price,
PriceType = priceType,
PriceUnit = fingerprint?.ProductDataObject?.PriceUnit
}
};
return(trade);
}
catch (Exception ex)
{
logger.LogError(ex, "Error creating trade from M7 ({Message})", ex.Message);
throw;
}
}
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 static bool WithholdEquiasSubmission(this TradeDataObject tradeDataObject)
{
return(tradeDataObject?.External?.Equias?.EboWhithhold is not null && tradeDataObject.External.Equias.EboWhithhold.Value);
}
public static string ConfirmationDocumentId(this TradeDataObject tradeDataObject)
{
return(tradeDataObject.External?.Confirmation?.DocumentId);
}
public static bool IsConfirmationWithheld(this TradeDataObject tradeDataObject)
{
return(tradeDataObject?.External?.Confirmation?.Withhold is not null && tradeDataObject.External.Confirmation.Withhold.Value);
}
public static string EboStatus(this TradeDataObject tradeDataObject)
{
return(tradeDataObject.External?.Equias?.CmStatus);
}
public static string EboActionType(this TradeDataObject tradeDataObject)
{
return(string.IsNullOrWhiteSpace(tradeDataObject.External?.Equias?.EboTradeId)
? null
: "R");
}
