protected List <BasicAssetValuation> ConvertProviderResultsToStandardValuations(
Dictionary <string, BasicQuotation> providerResults,
RequestContext requestContext)
{
var results = new List <BasicAssetValuation>();
// build standard results (and convert quote units)
Logger.LogDebug(" Results :");
for (int i = 0; i < requestContext.RequestItems.Count; i++)
{
RequestItem requestItem = requestContext.RequestItems[i];
Asset standardAsset = requestItem.StandardAsset;
BasicQuotation standardQuote = requestItem.StandardQuote;
string standardInstrId = standardAsset.id;
string standardFieldId = standardQuote.GetStandardFieldName();
PriceQuoteUnitsEnum standardQuoteUnit = requestItem.StandardUnits;
PriceQuoteUnitsEnum providerQuoteUnit = requestItem.ProviderUnits;
string providerInstrId = requestContext.InstrConversionMap[standardInstrId.ToLower()];
string providerFieldId = requestContext.FieldConversionMap[standardFieldId.ToLower()];
string providerQuoteKey = FormatProviderQuoteKey(providerInstrId, providerFieldId);
if (providerResults.TryGetValue(providerQuoteKey, out var providerQuote))
{
BasicQuotation convertedQuote;
if (providerQuote.valueSpecified)
{
// valid value returned
decimal convertedValue = PriceQuoteUnitsHelper.ConvertPriceQuoteUnitsValue(providerQuoteUnit, standardQuoteUnit, providerQuote.value);
convertedQuote = BasicQuotationHelper.Create(standardQuote, convertedValue);
// debug
Logger.LogDebug(" [{0}] '{1}/{2}' ({3}/{4}) [{5}] --> '{6}/{7}' ({8}/{9}) [{10}]", i,
providerInstrId, providerFieldId, AssetMeasureEnum.MarketQuote, providerQuoteUnit, providerQuote.value,
standardInstrId, standardFieldId, AssetMeasureEnum.MarketQuote, standardQuoteUnit, convertedQuote.value);
// end debug
}
else
{
// no value - copy error details
convertedQuote = providerQuote;
// debug
Logger.LogDebug(" [{0}] '{1}/{2}' ({3}/{4}) [{5}] --> '{6}/{7}' ({8}/{9}) [{10}]", i,
providerInstrId, providerFieldId, providerQuote.measureType.Value, providerQuote.quoteUnits.Value, providerQuote.value,
standardInstrId, standardFieldId, convertedQuote.measureType.Value, convertedQuote.quoteUnits.Value, convertedQuote.value);
// end debug
}
// add other provider info
convertedQuote.timeSpecified = providerQuote.timeSpecified;
convertedQuote.time = providerQuote.time;
convertedQuote.valuationDateSpecified = providerQuote.valuationDateSpecified;
convertedQuote.valuationDate = providerQuote.valuationDate;
convertedQuote.informationSource = providerQuote.informationSource;
results.Add(new BasicAssetValuation {
objectReference = new AnyAssetReference {
href = standardAsset.id
},
quote = new[] { convertedQuote }
});
}
}
return(results);
}
/// <summary>
///
/// </summary>
/// <param name="commodityType"></param>
/// <param name="commodityDetails"></param>
/// <param name="currency"></param>
/// <param name="multiplier"></param>
/// <param name="specifiedPrice"></param>
/// <param name="deliveryDateRollConvention"></param>
/// <param name="priceQuoteUnits"></param>
/// <param name="deliveryDates"></param>
/// <param name="exchangeId"></param>
/// <param name="informationSource"></param>
/// <returns></returns>
public static Commodity Create(string commodityType, string commodityDetails, string currency, int multiplier, SpecifiedPriceEnum specifiedPrice,
Offset deliveryDateRollConvention, PriceQuoteUnitsEnum priceQuoteUnits, DeliveryDatesEnum deliveryDates, string exchangeId, string informationSource)
{
var commodity = new Commodity
{
currency = new Currency {
Value = currency
},
commodityBase = new CommodityBase {
Value = commodityType
},
commodityDetails = new CommodityDetails {
Value = commodityDetails
},
deliveryDateRollConvention = deliveryDateRollConvention,
Item1 = deliveryDates,
multiplier = multiplier,
multiplierSpecified = true,
specifiedPriceSpecified = true,
unit = new QuantityUnit(),
specifiedPrice = specifiedPrice
};
commodity.unit.Value = priceQuoteUnits.ToString();
if (exchangeId != null)
{
commodity.Item = ExchangeIdHelper.Parse(exchangeId);
}
else
{
commodity.Item = InformationSourceHelper.Create(informationSource);
}
return(commodity);
}
public static PriceQuoteUnits Create(PriceQuoteUnitsEnum quoteUnits)
{
return(new PriceQuoteUnits
{
Value = quoteUnits.ToString()
});
}
public static BasicQuotation Create(AssetMeasureEnum measureType, PriceQuoteUnitsEnum priceUnits, string sideAsString)
{
ParseQuotationSideEnum(sideAsString, out var sideSpecified, out var side);
return(new BasicQuotation
{
valueSpecified = false,
measureType = AssetMeasureTypeHelper.Create(measureType),
quoteUnits = PriceQuoteUnitsHelper.Create(priceUnits),
sideSpecified = sideSpecified,
side = side
});
}
public static PriceQuoteUnits Parse(string quoteUnitsAsString)
{
PriceQuoteUnitsEnum quoteUnitsEnum = PriceQuoteUnitsEnum.Undefined;
if (quoteUnitsAsString != null)
{
quoteUnitsEnum = PriceQuoteUnitsScheme.ParseEnumString(quoteUnitsAsString);
}
return(new PriceQuoteUnits {
Value = quoteUnitsEnum.ToString()
});
}
private void AddUnitsMap(int priority, MDSRequestType requestType, string sourcePattern, PriceQuoteUnitsEnum targetUnits)
{
_rules.Locked(rules => rules.Add(new MapRule(
MDSDictionaryType.QuoteUnits,
MDSProviderId.GlobalIB, _provider,
requestType,
priority,
sourcePattern, targetUnits.ToString())));
}
/// <summary>
/// Converts the price quote value between source/target units.
/// </summary>
/// <param name="sourceUnits">The source units.</param>
/// <param name="targetUnits">The target units.</param>
/// <param name="sourceValue">The source value.</param>
/// <returns></returns>
public static decimal ConvertPriceQuoteUnitsValue(PriceQuoteUnitsEnum sourceUnits, PriceQuoteUnitsEnum targetUnits, decimal sourceValue)
{
if (targetUnits == sourceUnits)
{
// no conversion required
return(sourceValue);
}
// convert source value to normalised value
decimal normalValue = sourceValue;
switch (sourceUnits)
{
// normalised units that do not need conversion
case PriceQuoteUnitsEnum.DecimalRate:
case PriceQuoteUnitsEnum.DecimalSpread:
break;
// other units that require conversion
case PriceQuoteUnitsEnum.InverseDecimalRate: // to DecimalRate
normalValue = (1.0M / sourceValue);
break;
case PriceQuoteUnitsEnum.RateSpread: // to DecimalSpread
normalValue = (sourceValue / 10000.0M);
break;
case PriceQuoteUnitsEnum.Rate: // to DecimalRate
normalValue = (sourceValue / 100.0M);
break;
case PriceQuoteUnitsEnum.IRFuturesPrice: // to DecimalRate
normalValue = ((100.0M - sourceValue) / 100.0M);
break;
default: // conversion not supported/implemented
throw new NotSupportedException($"Cannot convert value ({sourceValue}) from units ({sourceUnits})");
}
// convert normalised value to target value
decimal targetValue = normalValue;
switch (targetUnits)
{
// normalised units that do not need conversion
case PriceQuoteUnitsEnum.DecimalRate:
case PriceQuoteUnitsEnum.DecimalSpread:
break;
// other units that require conversion
case PriceQuoteUnitsEnum.InverseDecimalRate: // from DecimalRate
targetValue = (1.0M / normalValue);
break;
case PriceQuoteUnitsEnum.RateSpread: // from DecimalSpread
normalValue = (normalValue * 10000.0M);
break;
case PriceQuoteUnitsEnum.Rate: // from DecimalRate
targetValue = (normalValue * 100.0M);
break;
case PriceQuoteUnitsEnum.IRFuturesPrice: // from DecimalRate
targetValue = (100.0M - (normalValue * 100.0M));
break;
default: // conversion not supported/implemented
throw new NotSupportedException($"Cannot convert value ({normalValue}) to units ({targetUnits})");
}
return(targetValue);
}
public static BasicQuotation Create(decimal value, AssetMeasureEnum assetMeasureEnum, PriceQuoteUnitsEnum priceQuoteUnitsEnum)
{
return(new BasicQuotation
{
valueSpecified = true,
value = value,
measureType = new AssetMeasureType {
Value = AssetMeasureScheme.GetEnumString(assetMeasureEnum)
},
quoteUnits = new PriceQuoteUnits {
Value = PriceQuoteUnitsScheme.GetEnumString(priceQuoteUnitsEnum)
}
});
}
