/// <summary>
/// Initializes a new instance of the <see cref="PriceableEquitySpot"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="position">The underlysing prosiiotn.</param>
/// <param name="equity">The equity</param>
/// <param name="settlementCalendar">The settlement Calendar.</param>
/// <param name="marketQuote">The market quote.</param>
public PriceableEquitySpot(DateTime baseDate, int position, EquityNodeStruct equity,
IBusinessCalendar settlementCalendar, BasicQuotation marketQuote)
: base(baseDate, position, equity.SettlementDate, settlementCalendar, marketQuote)
{
//Issuer = equity.Equity.id;
IsXD = IsExDiv();
//EquityCurveName = CurveNameHelpers.GetEquityCurveName(Currency.Value, Issuer);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="tradeDate"></param>
/// <param name="effectiveDate"></param>
/// <param name="referenceEquity"></param>
/// <param name="settlementCalendar"></param>
/// <param name="equityFpML"></param>
/// <param name="basePartyReference"></param>
/// <param name="forecastRateInterpolation"></param>
public EquityTransactionPricer(ILogger logger, ICoreCache cache, string nameSpace, DateTime tradeDate, DateTime effectiveDate,
String referenceEquity, IBusinessCalendar settlementCalendar, EquityTransaction equityFpML, string basePartyReference, Boolean forecastRateInterpolation)
{
logger.LogInfo("EquityType set. Commence to build a equity transaction.");
if (equityFpML == null)
{
return;
}
SettlementDate = effectiveDate;
TradeDate = tradeDate;
Multiplier = 1.0m;
BuyerReference = equityFpML.buyerPartyReference.href;
PaymentCurrencies = new List <string> {
equityFpML.unitPrice.currency.Value
};
SellerReference = equityFpML.sellerPartyReference.href;
BasePartyBuyer = basePartyReference == equityFpML.buyerPartyReference.href;
ForecastRateInterpolation = forecastRateInterpolation;
SettlementCalendar = settlementCalendar;
ReferenceEquity = referenceEquity;
NumberOfShares = Convert.ToInt16(equityFpML.numberOfUnits);
PurchasePrice = MoneyHelper.GetAmount(equityFpML.unitPrice.amount, equityFpML.unitPrice.currency.Value);
PaymentCurrencies = new List <string> {
equityFpML.unitPrice.currency.Value
};
var exchangeMIC = equityFpML.equity.exchangeId;
var exchangeMICData = InstrumentDataHelper.CreateEquityExchangeKey(nameSpace, exchangeMIC.Value);
var exchangeData = cache.LoadItem <ExchangeConfigData>(exchangeMICData);
if (exchangeData?.Data is ExchangeConfigData)
{
var exchange = (ExchangeConfigData)exchangeData.Data;
var equityTypeInfo = new EquityNodeStruct {
SettlementDate = exchange.SettlementDate
};
if (equityFpML.equity != null)
{
if (SettlementCalendar == null)
{
SettlementCalendar = BusinessCenterHelper.ToBusinessCalendar(cache,
equityTypeInfo.SettlementDate
.businessCenters,
nameSpace);
}
if (PaymentCalendar == null)
{
PaymentCalendar = SettlementCalendar;
}
var equity = XmlSerializerHelper.Clone(equityFpML.equity);
EquityTypeInfo = XmlSerializerHelper.Clone(equityTypeInfo);
EquityTypeInfo.Equity = equity;;
RiskMaturityDate = SettlementDate;
MaturityDate = SettlementDate;
if (!PaymentCurrencies.Contains(equityFpML.equity.currency.Value))
{
PaymentCurrencies.Add(equityFpML.equity.currency.Value);
}
logger.LogInfo("Equity transaction has been successfully created.");
}
}
else
{
logger.LogInfo("Equity type data not available.");
}
//Add payments like the settlement price
if (PurchasePrice == null || !PurchasePrice.amountSpecified)
{
return;
}
var amount = PurchasePrice.amount * NumberOfShares;
var settlementPayment = PaymentHelper.Create("EquitySettlemetAmount", BuyerReference, SellerReference, amount, SettlementDate);
AdditionalPayments = PriceableInstrumentsFactory.CreatePriceablePayments(basePartyReference, new[] { settlementPayment }, PaymentCalendar);
if (!PaymentCurrencies.Contains(settlementPayment.paymentAmount.currency.Value))
{
PaymentCurrencies.Add(settlementPayment.paymentAmount.currency.Value);
}
}
/// <summary>
/// Gets the instrument config data.
/// </summary>
/// <param name="cache">The cache.</param>
/// <param name="nameSpace">The client namespace</param>
/// <param name="parts">The AssetId or the parts of the AssetId.</param>
/// <returns></returns>
public static Instrument GetInstrumentConfigurationData(ICoreCache cache, string nameSpace, params string[] parts)
{
bool simplifiable = true;
if (parts.Length == 1)
{
parts = parts[0].Split('-');
}
string uniqueName;
var assetType = (AssetTypesEnum)Enum.Parse(typeof(AssetTypesEnum), parts[1], true);
var swapTypes = new[] { AssetTypesEnum.IRSwap, AssetTypesEnum.BasisSwap, AssetTypesEnum.XccyBasisSwap, AssetTypesEnum.XccySwap };
var fxTypes = new[] { AssetTypesEnum.FxSpot, AssetTypesEnum.FxForward };
var bondTypes = new[] { AssetTypesEnum.Bond };
var commodityTypes = new[] { AssetTypesEnum.CommoditySpread, AssetTypesEnum.CommodityForward };
var equityTypes = new[] { AssetTypesEnum.Equity, AssetTypesEnum.EquityForward, AssetTypesEnum.EquitySpread };
var irfuturesOptionTypes = new[] { AssetTypesEnum.IRFutureOption, AssetTypesEnum.IRCallFutureOption, AssetTypesEnum.IRPutFutureOption };
var otherTypes = new[] { AssetTypesEnum.BondForward, AssetTypesEnum.BondSpot };
ICoreItem loadedItem;
Instrument instrument;
string exchangeMIC = null;
if (swapTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
else if (irfuturesOptionTypes.Contains(assetType) && parts.Length > 2)
{
uniqueName = CreateKey(nameSpace, AssetTypesEnum.IRFutureOption.ToString(), parts[0], parts[2]);
}
else if (commodityTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
else if (fxTypes.Contains(assetType))
{
return(GetFxInstrumentConfigurationData(cache, nameSpace, parts));
}
else if (bondTypes.Contains(assetType) && parts[2].Split('.').Length > 4)
{
uniqueName = CreateBondKey(nameSpace, parts[2]);
var extraData = cache.LoadItem <Bond>(uniqueName);
var bondType = extraData.AppProps.GetValue <string>(BondProp.BondType, true);
uniqueName = CreateKey(nameSpace, parts[1], parts[0], bondType);
loadedItem = cache.LoadItem <Instrument>(uniqueName);
instrument = loadedItem.Data as Instrument;
if (instrument != null)
{
var newInstrument = XmlSerializerHelper.Clone(instrument);
((BondNodeStruct)newInstrument.InstrumentNodeItem).Bond = extraData.Data as Bond;
return(newInstrument);
}
}
else if (equityTypes.Contains(assetType))
{
var assetCode = parts[2].Split('.');
EquityAsset equityAsset = null;
if (assetCode.Length == 2)
{
uniqueName = CreateEquityAssetKey(nameSpace, parts[2]);
var equity = cache.LoadItem <EquityAsset>(uniqueName);
exchangeMIC = equity.AppProps.GetValue <string>(EquityProp.ExchangeMIC, true);
equityAsset = equity.Data as EquityAsset;
}
if (assetCode.Length == 1)
{
exchangeMIC = assetCode[0];
}
uniqueName = CreateEquityExchangeKey(nameSpace, exchangeMIC);
loadedItem = cache.LoadItem <ExchangeConfigData>(uniqueName);
if (assetType == AssetTypesEnum.Equity && loadedItem.Data is ExchangeConfigData exchange)
{
instrument = new Instrument();
var equityNode = new EquityNodeStruct
{
Equity = equityAsset,
Exchange = exchange.ExchangeData,
SettlementDate = exchange.SettlementDate
};
instrument.AssetType = parts[1];
instrument.InstrumentNodeItem = equityNode;
instrument.Currency = CurrencyHelper.Parse(parts[0]);
instrument.ExtraItem = equityNode.Exchange.MIC;
return(instrument);
}
if (parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC, parts[3]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC);
simplifiable = false;
}
}
else if (otherTypes.Contains(assetType) && parts.Length > 3)
{
//This is to simplify the configuration data and no bond forward is required
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2], parts[3]);
}
//Default Area that sweeps all the standard keys structures.
else if (parts.Length > 2)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0]);
simplifiable = false;
}
loadedItem = cache.LoadItem <Instrument>(uniqueName);
if (loadedItem == null && simplifiable)
{
if (swapTypes.Contains(assetType) && parts.Length > 3)
{
//This handles the special case of IRSwaps, where the underlying maturity should use the default.
uniqueName = CreateKey(nameSpace, parts[1], parts[0], "Default", parts[3]);
}
else if (commodityTypes.Contains(assetType) && parts.Length > 3)
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0], parts[2]);
}
else if (equityTypes.Contains(assetType) && parts.Length > 3)
{
//Orion.V5r3.Configuration.Instrument.EquityForward.AUD-EquityForward.AU.0D
uniqueName = CreateKey(nameSpace, parts[1], parts[0], exchangeMIC);
}
else if (otherTypes.Contains(assetType))
{
//This is to simplify the configuration data and no bond forward is required
uniqueName = CreateKey(nameSpace, AssetTypesEnum.Bond.ToString(), parts[0], parts[2]);
}
else
{
uniqueName = CreateKey(nameSpace, parts[1], parts[0]);
}
loadedItem = cache.LoadItem <Instrument>(uniqueName);
}
instrument = loadedItem?.Data as Instrument;
return(instrument);
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableEquityForward"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="position">The underlysing prosiiotn.</param>
/// <param name="equity">The equity</param>
/// <param name="settlementCalendar">The settlement Calendar.</param>
/// <param name="marketQuote">The market quote.</param>
public PriceableEquityForward(DateTime baseDate, int position, EquityNodeStruct equity,
IBusinessCalendar settlementCalendar, BasicQuotation marketQuote)
: base(baseDate, position, equity.SettlementDate, settlementCalendar, marketQuote)
{
IsXD = IsExDiv();
}
