protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_)
{
var allEDs = dc_.FIs.Where(x =>
x.InstrumentType == InstrumentType.IRFuture
&& x.Maturity >= DateTime.Today
&& x.SymmetryCode.StartsWith("ED"))
.Where(x => x.Maturity.Value.Month % 3 == 0)
.OrderBy(x => x.Maturity)
.Take(12);
var listOfInstruments = new List<InstrumentIdentifier>();
// find the market snap to which
var marketSnap = QuoteHelpers.GetMarketSnap("CLOSE", m_markDate, dc_, ThrowBehavior.DontThrow);
if (marketSnap == null) return null;
var source = QuoteHelpers.GetQuoteSource("SYM", dc_, ThrowBehavior.DontThrow);
if (source == null) return null;
foreach (var ed in allEDs)
{
EDItem item = new EDItem(ed, dc_, marketSnap, source);
if (item.CanRequestPrice)
{
m_items.Add(item);
m_ricToOptionItem[item.OptionAbovePrice.ReutersTicker] = item.OptionAbovePrice;
m_ricToOptionItem[item.OptionBelowPrice.ReutersTicker] = item.OptionBelowPrice;
listOfInstruments.Add(new InstrumentIdentifier()
{
IdentifierValue = item.OptionBelowPrice.ReutersTicker,
IdentifierType="RIC"
});
listOfInstruments.Add(new InstrumentIdentifier()
{
IdentifierValue = item.OptionAbovePrice.ReutersTicker,
IdentifierType="RIC"
});
}
}
if (listOfInstruments.Count() > 0)
{
var v = ServiceHelpers.ValidateInstruments_FindUnValidated(listOfInstruments.ToArray(), dsClient_, ref credentials_);
m_notValidatedIdentifiers = v.Item2;
return v.Item1;
}
else
return null;
}
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_)
{
var allFixings = getAllSwaps(dc_);
m_ric_to_FIs = new Dictionary<string, FI>();
var listOfInstruments = new List<InstrumentIdentifier>();
foreach (var fi in allFixings)
{
string[] rics = FIHelpers.GetFIIdentifiers(fi.SymmetryCode, IdentifierType.RIC, dc_, ThrowBehavior.DontThrow);
if (rics == null || rics.Length==0)
{
SLog.log.WarnFormat("Cannot locate RIC for SymmetryCode:{0}", fi.SymmetryCode);
continue;
}
Array.ForEach(rics, x => {
m_ric_to_FIs.Add(x, fi);
listOfInstruments.Add(new InstrumentIdentifier()
{
IdentifierType="RIC",
IdentifierValue=x
});
}
);
}
var t = ServiceHelpers.ValidateInstruments_FindUnValidated(listOfInstruments.ToArray(), dsClient_, ref credentials_);
m_notValidatedIdentifiers = t.Item2;
return t.Item1;
}
public static void Go()
{
var dict_fiidToAuctionID = new Dictionary<int, int>();
{
string sql = "select * from FIBondAuction";
DataSet ds = Singleton<ConnMngr>.Instance.Execute(DBNames.SQLSERVER_SYMMETRYTS, sql);
foreach (DataRow row in ds.Tables[0].Rows)
if(!dict_fiidToAuctionID.ContainsKey(Convert.ToInt32(row["FIID"])))
dict_fiidToAuctionID.Add(Convert.ToInt32(row["FIID"]), Convert.ToInt32(row["FIBondAuctionID"]));
}
var dict_isinToMissingBond = new Dictionary<string, Bond>();
var rss_identifiers = new List<InstrumentIdentifier>();
foreach (var bond in Singleton<Bonds>.Instance.Where(x => x.SymmetryCode.StartsWith("US912828")))
{
if (!dict_fiidToAuctionID.ContainsKey(bond.FIID))
{
dict_isinToMissingBond.Add(bond.SymmetryCode, bond);
rss_identifiers.Add(new InstrumentIdentifier { IdentifierType = "ISN", IdentifierValue = bond.SymmetryCode, Source="TWB"});
Logger.Debug(string.Format("{0}/{1} is missing auction information", bond.SymmetryCode, bond.DisplayName), typeof(UpdateBondAuctionData));
}
}
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Ssl3;
if (rss_identifiers.Count() == 0)
return; // nothing to do
try
{
var cred = ServiceHelpers.GetCredentials();
{
using (var dsClient = new ExtractionServiceClient())
{
var validatedInstruments = ServiceHelpers.ValidateInstruments(rss_identifiers.ToArray(), dsClient, ref cred);
{
var request = new ExtractRequest
{
CredentialsHeader = cred,
request = new InstrumentExtractionRequestTermsAndConditions
{
Instruments = validatedInstruments,
OutputFields = Enum.GetNames(typeof(FieldsToReturn))
.Select(x => typeof(FieldsToReturn).GetField(x.ToString()))
.Select(x => x.GetCustomAttribute<RSSFieldAttribute>().FieldName).ToArray()
}
};
var response = dsClient.Extract(request);
var pivoted = ExtractionUtility.PivotExtractionResult(response.ExtractResult.Columns, response.ExtractResult.RowCount, response.ExtractResult.Messages);
StringBuilder b = new StringBuilder();
b.AppendLine(ServiceHelpers.ToCsvLine(pivoted.ColumnNames.Concat(new [] {"FIID"})));
foreach (var row in pivoted.Rows)
{
string isin = row[(int)FieldsToReturn.InstrumentID] as string;
b.AppendLine(ServiceHelpers.ToCsvLine(row.Concat(new string[] { dict_isinToMissingBond[isin].FIID.ToString() })));
}
var path = @"e:\temp\missingAuctions.csv";
FileInfo i = new FileInfo(path);
StreamWriter writer = i.CreateText();
writer.Write(b.ToString());
writer.Close();
}
}
}
}
catch (Exception ex_)
{
Logger.Error("blast", typeof(UpdateCTBondData), ex_);
}
}
public override ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_)
{
return new ReutersDSS.FTP.InputList()
{
InputListAction="Replace",
Name=ftpInstrumentList.ToString(),
Instrument=getAllSwaps(dc_)
.Select(x=>FIHelpers.GetFIIdentifiers(x.SymmetryCode,IdentifierType.RIC,dc_,ThrowBehavior.DontThrow))
.Where(x=>x!=null && x.Length>0)
.SelectMany(x=>x)
.Select(x=>new ReutersDSS.FTP.Instrument()
{
IdentifierType="RIC",
Identifier=x,
}).ToList()
};
}
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_)
{
m_ric_to_FIs = new Dictionary<string, FI>();
var listOfInstruments = new List<InstrumentIdentifier>();
foreach (var fi in getAllFixings(dc_))
{
string ric = FIHelpers.GetFIIdentifier(fi.SymmetryCode, IdentifierType.RIC, dc_, ThrowBehavior.DontThrow);
if (ric == null)
{
SLog.log.WarnFormat("Cannot locate RIC for SymmetryCode:{0}", fi.SymmetryCode);
continue;
}
m_ric_to_FIs.Add(ric, fi);
listOfInstruments.Add(new InstrumentIdentifier()
{
IdentifierValue = ric,
IdentifierType = "RIC"
});
}
ValidatedInstrument[] ret = ServiceHelpers.ValidateInstruments(listOfInstruments.ToArray(), dsClient_, ref credentials_);
return ret;
}
public abstract ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_);
public abstract void MakeRequestsToDataScope(ExtractionServiceClient dsClient_, CredentialsHeader dsHeader_);
public abstract void PrepareInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader dsHeader_);
public static void Go()
{
var ctList = SI.Strategy.CTDs.Generator.Go();
var listOfMissing = new List<MonthYear>();
foreach (var v in ctList)
{
if (v.CT2 == null || v.CT3 == null || v.CT5 == null || v.CT7 == null || v.CT10 == null || v.CT30 == null)
if (!listOfMissing.Contains(v.RefundingMonth))
{
Logger.Debug(string.Format("Missing bonds for {0}", v.RefundingMonth), typeof(UpdateCTBondData));
listOfMissing.Add(v.RefundingMonth);
}
}
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Ssl3;
try
{
var cred = ServiceHelpers.GetCredentials();
using (var dc = SymmetryDataSource.ReadOnly())
{
using (var dsClient = new ExtractionServiceClient())
{
var isins = new Dictionary<string, ValidatedInstrument>();
foreach (var v in listOfMissing)
{
var request = new SearchInstrumentsRequest
{
CredentialsHeader = cred,
request = new InstrumentSearchRequestGovCorp
{
IdentifierType = "ISN",
IdentifierSearchValue = "US9128*",
PreferredIdentifierType = "ISN",
IsGovernmentGroup = true,
IssueDatePrimaryValue = new DateTime(v.Year, v.Month, 3),
IssueDateSecondaryValue = new DateTime(v.Year, v.Month, 25),
IssueDateComparisonOperator = "FROM",
}
};
var response = dsClient.SearchInstruments(request);
Array.ForEach(response.SearchInstrumentsResult.Instruments.Select(x => x.IdentifierValue).Distinct().ToArray(), (x) => Logger.Debug(x, typeof(UpdateCTBondData)));
foreach (var validatedInstrument in response.SearchInstrumentsResult.Instruments)
{
var isin = validatedInstrument.IdentifierValue;
if (isins.ContainsKey(isin))
{
if (validatedInstrument.Source.Equals("TWB"))
isins[isin] = validatedInstrument;
continue;
}
var fi = FIHelpers.GetFIBySymmetryCode(isin, dc, Symmetry.Core.ThrowBehavior.DontThrow);
if (fi == null)
isins.Add(isin, validatedInstrument);
}
}
if (isins.Count == 0)
return;
{
var request = new ExtractRequest
{
CredentialsHeader = cred,
request = new InstrumentExtractionRequestTermsAndConditions
{
Instruments = isins.ToList().Select(x => x.Value).ToArray(),
OutputFields = Enum.GetNames(typeof(FieldsToReturn))
.Select(x => typeof(FieldsToReturn).GetField(x.ToString()))
.Select(x => x.GetCustomAttribute<RSSFieldAttribute>().FieldName).ToArray()
}
};
var response = dsClient.Extract(request);
var pivoted = ExtractionUtility.PivotExtractionResult(response.ExtractResult.Columns, response.ExtractResult.RowCount, response.ExtractResult.Messages);
StringBuilder b = new StringBuilder();
b.AppendLine(ServiceHelpers.ToCsvLine(pivoted.ColumnNames));
foreach (var row in pivoted.Rows)
{
b.AppendLine(ServiceHelpers.ToCsvLine(row));
}
var path = @"e:\temp\missingBonds.csv";
FileInfo i = new FileInfo(path);
StreamWriter writer = i.CreateText();
writer.Write(b.ToString());
writer.Close();
}
}
}
}
catch (Exception ex_)
{
Logger.Error("blast", typeof(UpdateCTBondData), ex_);
}
}
public override ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_)
{
throw new NotImplementedException();
}
public override ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_)
{
var futs = getValidFuturesChains();
return
new ReutersDSS.FTP.InputList()
{
InputListAction = "Replace",
Name = ftpInstrumentList.ToString(),
Instrument =
futs.Select(
fut =>
new ReutersDSS.FTP.Instrument
{
IdentifierType = "CHR",
Identifier = string.Format("0#{0}:", fut.RICStart)
}).ToList()
};
}
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_)
{
var ints =
getValidFuturesChains()
.Select(
x =>
new InstrumentIdentifier {IdentifierValue = string.Format("0#{0}:}", x.RICStart), IdentifierType = "CHR"});
if (!ints.Any())
return null;
// keep mapping for return from datascope
m_ric_to_FIs = new Dictionary<string, FI>();
var listOfInstruments = new List<InstrumentIdentifier>();
var tp = ServiceHelpers.ValidateInstruments(ints.ToArray(), dsClient_, ref credentials_);
return tp;
}
private void validateUsingMethod(
Func<FI,string,SymmetryEntities,InstrumentIdentifier> identifierformer_,
int configIndex_,
ICollection<FI> fromThese_,
ICollection<ValidatedInstrument> validated_,
ExtractionServiceClient dsClient_,
CredentialsHeader credentials_,
SymmetryEntities dc_
)
{
var identifiers = new List<InstrumentIdentifier>();
var dict = new Dictionary<string, FI>();
foreach (var f in fromThese_)
{
var config = RICHelper.GetMappingForBond(f.SymmetryCode);
string exch = null;
switch (configIndex_)
{
case 0:
{
exch = config == null || config.ExchangeList == null || !config.ExchangeList.Any()
? PRIMARY_BOND_SOURCE
: config.ExchangeList[0];
}
break;
case 1:
{
exch = config == null || config.ExchangeList == null || config.ExchangeList.Count() < 2
? SECONDARY_BOND_SOURCE
: config.ExchangeList[1];
}
break;
}
var identifer = identifierformer_(f, exch, dc_);
if (identifer == null) continue;
dict[identifer.IdentifierValue] = f;
identifiers.Add(identifer);
}
if (!identifiers.Any()) return;
var validated_unvalidated = ServiceHelpers.ValidateInstruments_FindUnValidated(identifiers.ToArray(), dsClient_, ref credentials_);
foreach(var valid in validated_unvalidated.Item1)
{
validated_.Add(valid);
fromThese_.Remove(dict[valid.IdentifierValue]);
}
}
public override ReutersDSS.FTP.InputList BuildFTPInputList(SymmetryEntities dc_, ExtractionServiceClient dsClient_)
{
var valInstruments = getValidatedInstruments(dc_, dsClient_, ServiceHelpers.GetCredentials());
return new ReutersDSS.FTP.InputList()
{
InputListAction = "Replace",
Name = ftpInstrumentList.ToString(),
Instrument = valInstruments.Select(x => new ReutersDSS.FTP.Instrument()
{
Identifier = x.IdentifierValue,
IdentifierType = x.IdentifierType,
Exchange = new[] {x.Source}.ToList()
}).ToList()
};
}
protected override ValidatedInstrument[] getValidatedInstruments(SymmetryEntities dc_, ExtractionServiceClient dsClient_, CredentialsHeader credentials_)
{
var allBondsToValidate = getAllBondsToPrice(dc_);
var validated = new List<ValidatedInstrument>();
// first try cusip=TWEB
validateUsingMethod(
configIndex_: 0,
fromThese_: allBondsToValidate,
validated_: validated,
dsClient_: dsClient_,
credentials_: credentials_,
dc_: dc_,
identifierformer_: (bond, exch, dc) =>
{
if (String.Compare(exch, "TWB", StringComparison.OrdinalIgnoreCase) != 0)
return null;
bool canUseCusipEqTWEB = false;
/*
* We know that actually tweb starts using cusip=tweb after auction date, but we don't always have the auction data for the bond
*
* If we can get the auction date, and it's before that date, then we can use cusip=tweb
*
*/
if (bond.FIBond == null) return null;
{
DateTime? auctionDate = bond.FIBond.AuctionDate;
if (bond.FIBond.FIBondAuctions != null && bond.FIBond.FIBondAuctions.Count>0)
auctionDate = bond.FIBond.FIBondAuctions.ToArray().Select(x => x.AuctionDate).Min();
if (auctionDate.HasValue && auctionDate.Value < DateTime.Today)
canUseCusipEqTWEB = true;
}
// if we haven't already been able to validate using auction date, then, as a second best,
// see if 'today' is past or equal to issuedate
if (!canUseCusipEqTWEB && bond.FIBond.IssueDate.HasValue)
canUseCusipEqTWEB = bond.FIBond.IssueDate.Value <= DateTime.Today;
if (!canUseCusipEqTWEB)
return null;
var cusip = FIHelpers.GetFIIdentifier(bond.SymmetryCode, IdentifierType.CUSIP, dc, ThrowBehavior.DontThrow);
if (string.IsNullOrEmpty(cusip))
return null;
return new InstrumentIdentifier
{
IdentifierType = "RIC",
IdentifierValue = string.Format("{0}=TWEB", cusip)
};
});
// then try ISIN with source=TWEB (or first config item)
validateUsingMethod(
configIndex_: 0,
fromThese_: allBondsToValidate,
validated_: validated,
dsClient_: dsClient_,
credentials_: credentials_,
dc_: dc_,
identifierformer_: (bond, exch, dc) => new InstrumentIdentifier
{
IdentifierType = "ISN",
Source=exch,
IdentifierValue = bond.SymmetryCode
});
// then try ISIN with source=TWEB (or first config item)
validateUsingMethod(
configIndex_: 1,
fromThese_: allBondsToValidate,
validated_: validated,
dsClient_: dsClient_,
credentials_: credentials_,
dc_: dc_,
identifierformer_: (bond, exch, dc) => new InstrumentIdentifier
{
IdentifierType = "ISN",
Source = exch,
IdentifierValue = bond.SymmetryCode
});
// log anything we couldn't get a validated intstrument for
foreach (var remainingBond in allBondsToValidate)
{
SLog.log.DebugFormat("Could not discover validated instrument for [{0}]", remainingBond.SymmetryCode);
}
SLog.log.InfoFormat("Validated {0} bonds.", validated.Count);
return validated.ToArray();
}
