private void sendIntradayTickRequest()
{
if (!d_session.OpenService(REFDATA_SVC))
{
System.Console.WriteLine("Failed to open service: " + REFDATA_SVC);
return;
}
Service refDataService = d_session.GetService(REFDATA_SVC);
Request request = refDataService.CreateRequest("IntradayTickRequest");
request.Set("security", d_security);
// Add fields to request
Element eventTypes = request.GetElement("eventTypes");
for (int i = 0; i < d_events.Count; ++i)
{
eventTypes.AppendValue((string)d_events[i]);
}
// All times are in GMT
request.Set("startDateTime", d_startDateTime);
request.Set("endDateTime", d_endDateTime);
if (d_conditionCodes)
{
request.Set("includeConditionCodes", true);
}
System.Console.WriteLine("Sending Request: " + request);
d_session.SendRequest(request, d_identity, null);
}
public void processMessage(Message message)
{
Log.LogMessage(LogLevels.DETAILED, "Broker Strategy Parameters [" + brokerStrategyParameters.brokerStrategy.parent.broker.name + "." + brokerStrategyParameters.brokerStrategy.name + "]: processing message");
if (message.MessageType.Equals(ERROR_INFO))
{
Log.LogMessage(LogLevels.DETAILED, "Broker Strategy Parameters [" + brokerStrategyParameters.brokerStrategy.parent.broker.name + "." + brokerStrategyParameters.brokerStrategy.name + "]: processing RESPONSE error");
int errorCode = message.GetElementAsInt32("ERROR_CODE");
string errorMessage = message.GetElementAsString("ERROR_MESSAGE");
Log.LogMessage(LogLevels.DETAILED, "Broker Strategy Parameters [" + brokerStrategyParameters.brokerStrategy.parent.broker.name + "." + brokerStrategyParameters.brokerStrategy.name + "]: [" + errorCode + "] " + errorMessage);
}
else if (message.MessageType.Equals(GET_BROKER_STRATEGY_INFO))
{
Log.LogMessage(LogLevels.DETAILED, "Broker Strategy Parameters [" + brokerStrategyParameters.brokerStrategy.parent.broker.name + "." + brokerStrategyParameters.brokerStrategy.name + "]: processing succesful RESPONSE");
Element parameters = message.GetElement("EMSX_STRATEGY_INFO");
int numValues = parameters.NumValues;
for (int i = 0; i < numValues; i++)
{
Element parameter = parameters.GetValueAsElement(i);
string parameterName = parameter.GetElementAsString("FieldName");
int disable = parameter.GetElementAsInt32("Disable");
string stringValue = parameter.GetElementAsString("StringValue");
BrokerStrategyParameter newParameter = new BrokerStrategyParameter(brokerStrategyParameters, parameterName, stringValue, disable);
brokerStrategyParameters.add(newParameter);
Log.LogMessage(LogLevels.DETAILED, "Broker Strategy Parameters [" + brokerStrategyParameters.brokerStrategy.parent.broker.name + "." + brokerStrategyParameters.brokerStrategy.name + "] Added new parameter " + parameterName);
}
}
}
private void processAuthStatusEvent(Event eventObj)
{
foreach (Message msg in eventObj)
{
int userid = (int)msg.CorrelationID.Value;
if (msg.MessageType.Equals(AUTHORIZATION_REVOKED))
{
Element errorinfo = msg.GetElement("reason");
int code = errorinfo.GetElementAsInt32("code");
String reason = errorinfo.GetElementAsString("message");
System.Console.WriteLine("Authorization revoked for uuid " +
d_uuids[userid] +
" with code " + code + " and reason\n\t" + reason);
/* Reauthorize user here if required, and obtain a new identity.
* Existing identity is invalid.
*/
}
else if (msg.MessageType.Equals(ENTITLEMENT_CHANGED))
{
System.Console.WriteLine("Entitlements updated for uuid " +
d_uuids[userid]);
/* This is just informational.
* Continue to use existing identity.
*/
}
}
}
private TickData BBEventToTickData(Element bbElement, ITickDataQuery tickDateQuery)
{
var dataPoint = new TickData()
{
Security = tickDateQuery.Security,
SecurityObj = tickDateQuery.CorrelationIdObj
};
if (bbElement.HasElement("time") &&
bbElement.HasElement("type") &&
bbElement.HasElement("value") &&
bbElement.HasElement("size"))
{
// tick field data
dataPoint.TimeStamp = bbElement.GetElementAsTime("time").ToSystemDateTime();
//dataPoint.TimeStamp = Convert.ToDateTime(bbElement.GetElementAsString("time"));//.ToUniversalTime();
dataPoint.Price = bbElement.GetElementAsFloat64("value");
dataPoint.Size = (uint)bbElement.GetElementAsInt32("size");
string msgType = bbElement.GetElementAsString("type");
Enum.TryParse(msgType, true, out dataPoint.Type);
}
return(dataPoint);
}
private void processElement(Element element)
{
if (element.IsArray)
{
System.Console.WriteLine("\t\t" + element.Name);
// process array
int numOfValues = element.NumValues;
for (int i = 0; i < numOfValues; ++i)
{
// process array data
processElement(element.GetValueAsElement(i));
}
}
else if (element.NumElements > 0)
{
System.Console.WriteLine("\t\t" + element.Name);
int numOfElements = element.NumElements;
for (int i = 0; i < numOfElements; ++i)
{
// process child elements
processElement(element.GetElement(i));
}
}
else
{
// Assume all values are scalar.
System.Console.WriteLine("\t\t" + element.Name
+ " = " + element.GetValueAsString());
}
}
public void processMessage(Message message)
{
Log.LogMessage(LogLevels.BASIC, "Brokers: processing message");
if (message.MessageType.Equals(ERROR_INFO))
{
Log.LogMessage(LogLevels.BASIC, "Brokers: processing RESPONSE error");
int errorCode = message.GetElementAsInt32("ERROR_CODE");
string errorMessage = message.GetElementAsString("ERROR_MESSAGE");
Log.LogMessage(LogLevels.BASIC, "Error getting brokers: [" + errorCode + "] " + errorMessage);
}
else if (message.MessageType.Equals(GET_BROKERS))
{
Log.LogMessage(LogLevels.BASIC, "Brokers: processing successful RESPONSE");
Element brokerList = message.GetElement("EMSX_BROKERS");
int numValues = brokerList.NumValues;
for (int i = 0; i < numValues; i++)
{
string brokerName = brokerList.GetValueAsString(i);
Broker newBroker = new Broker(brokers, brokerName, assetClass);
brokers.add(newBroker);
Log.LogMessage(LogLevels.DETAILED, "Brokers: added new broker " + newBroker.name);
}
}
}
/// <summary>
/// Process subscription data
/// </summary>
/// <param name="eventObj"></param>
/// <param name="session"></param>
private void processRequestDataEvent(Event eventObj, Session session)
{
d_data.BeginLoadData();
// process message
foreach (Message msg in eventObj)
{
if (msg.MessageType.Equals(Bloomberglp.Blpapi.Name.GetName("IntradayBarResponse")))
{
if (msg.HasElement(RESPONSE_ERROR))
{
// process error
Element error = msg.GetElement(RESPONSE_ERROR);
if (msg.NumElements == 1)
{
d_data.Rows.Add(new object[] { d_requestSecurity, error.GetElementAsString(MESSAGE) });
return;
}
}
// process bar data
Element barDataArray = msg.GetElement("barData");
int numberOfBars = barDataArray.NumValues;
foreach (Element barData in barDataArray.Elements)
{
if (barData.Name.ToString() == "barTickData")
{
for (int pointIndex = 0; pointIndex < barData.NumValues; pointIndex++)
{
int fieldIndex = 0;
object[] dataValues = new object[d_data.Columns.Count];
Element fields = barData.GetValueAsElement(pointIndex);
foreach (DataColumn col in d_data.Columns)
{
if (fields.HasElement(col.ColumnName))
{
// process field data
Element item = fields.GetElement(col.ColumnName);
dataValues[fieldIndex] = item.GetValueAsString();
}
else
{
if (col.ColumnName == "security")
{
dataValues[fieldIndex] = d_requestSecurity;
}
else
{
dataValues[fieldIndex] = DBNull.Value;
}
}
fieldIndex++;
} // end foreach
// save bar data
d_data.Rows.Add(dataValues);
} // end for loop
} // end if
} // end foreach
} // end if
} // end foreach
d_data.EndLoadData();
}
/// <summary>
/// Request status event
/// </summary>
/// <param name="eventObj"></param>
/// <param name="session"></param>
private void processRequestStatusEvent(Event eventObj, Session session)
{
List <string> dataList = new List <string>();
// process status message
foreach (Message msg in eventObj)
{
DataGridViewRow dataRow = (DataGridViewRow)msg.CorrelationID.Object;
if (msg.MessageType.Equals(Bloomberglp.Blpapi.Name.GetName("SubscriptionStarted")))
{
// set subscribed color
foreach (DataGridViewCell cell in dataRow.Cells)
{
cell.Style.BackColor = Color.LightGreen;
}
try
{
// check for error
if (msg.HasElement("exceptions"))
{
// subscription has error
Element error = msg.GetElement("exceptions");
int searchIndex = 0;
for (int errorIndex = 0; errorIndex < error.NumValues; errorIndex++)
{
Element errorException = error.GetValueAsElement(errorIndex);
string field = errorException.GetElementAsString(FIELD_ID);
Element reason = errorException.GetElement(REASON);
string message = reason.GetElementAsString(DESCRIPTION);
for (; searchIndex < dataGridViewData.ColumnCount - 1; searchIndex++)
{
if (field == dataGridViewData.Columns[searchIndex].Name)
{
dataRow.Cells[searchIndex].Value = message;
break;
}
}
}
}
}
catch (Exception e)
{
toolStripStatusLabel1.Text = e.Message;
}
}
else
{
// check for subscription failure
if (msg.MessageType.Equals(Bloomberglp.Blpapi.Name.GetName("SubscriptionFailure")))
{
if (msg.HasElement(REASON))
{
Element reason = msg.GetElement(REASON);
string message = reason.GetElementAsString(DESCRIPTION);
dataRow.Cells[1].Value = message;
}
}
}
}
}
private void processMessage(Message msg)
{
Element data = msg.GetElement(BAR_DATA).GetElement(BAR_TICK_DATA);
int numBars = data.NumValues;
System.Console.WriteLine("Response contains " + numBars + " bars");
System.Console.WriteLine("Datetime\t\tOpen\t\tHigh\t\tLow\t\tClose" +
"\t\tNumEvents\tVolume");
for (int i = 0; i < numBars; ++i)
{
Element bar = data.GetValueAsElement(i);
Datetime time = bar.GetElementAsDate(TIME);
double open = bar.GetElementAsFloat64(OPEN);
double high = bar.GetElementAsFloat64(HIGH);
double low = bar.GetElementAsFloat64(LOW);
double close = bar.GetElementAsFloat64(CLOSE);
int numEvents = bar.GetElementAsInt32(NUM_EVENTS);
long volume = bar.GetElementAsInt64(VOLUME);
System.DateTime sysDatetime = time.ToSystemDateTime();
System.Console.WriteLine(
sysDatetime.ToString("s") + "\t" +
open.ToString("C") + "\t\t" +
high.ToString("C") + "\t\t" +
low.ToString("C") + "\t\t" +
close.ToString("C") + "\t\t" +
numEvents + "\t\t" +
volume);
}
}
public void processMessage(Message message)
{
Log.LogMessage(LogLevels.DETAILED, "Broker Strategies [" + brokerStrategies.broker.name + "]: processing message");
if (message.MessageType.Equals(ERROR_INFO))
{
Log.LogMessage(LogLevels.BASIC, "Broker Strategies [" + brokerStrategies.broker.name + "]: processing RESPONSE error");
int errorCode = message.GetElementAsInt32("ERROR_CODE");
string errorMessage = message.GetElementAsString("ERROR_MESSAGE");
Log.LogMessage(LogLevels.BASIC, "Broker Strategies [" + brokerStrategies.broker.name + "]: [" + errorCode + "] " + errorMessage);
}
else if (message.MessageType.Equals(GET_BROKER_STRATEGIES))
{
Log.LogMessage(LogLevels.DETAILED, "Broker Strategies [" + brokerStrategies.broker.name + "]: processing succesful RESPONSE");
Element strategies = message.GetElement("EMSX_STRATEGIES");
int numValues = strategies.NumValues;
for (int i = 0; i < numValues; i++)
{
string strategy = strategies.GetValueAsString(i);
if (strategy.Length > 0)
{
BrokerStrategy newBrokerStrategy = new BrokerStrategy(brokerStrategies, strategy);
brokerStrategies.add(newBrokerStrategy);
Log.LogMessage(LogLevels.DETAILED, "Broker Strategies [" + brokerStrategies.broker.name + "]: added new strategy " + newBrokerStrategy.name);
}
}
}
}
/// <summary>
/// Request status event
/// </summary>
/// <param name="eventObj"></param>
/// <param name="session"></param>
private void processRequestStatusEvent(Event eventObj, Session session)
{
List <string> dataList = new List <string>();
// process status message
foreach (Message msg in eventObj)
{
ListViewGroup group = (ListViewGroup)msg.CorrelationID.Object;
if (msg.MessageType.Equals(Bloomberglp.Blpapi.Name.GetName("SubscriptionStarted")))
{
// set waiting for subscription to start color
setGroupColor(group, Color.Yellow);
}
else
{
// check for subscription failure
if (msg.MessageType.Equals(Bloomberglp.Blpapi.Name.GetName("SubscriptionFailure")))
{
// set exception color
setGroupColor(group, Color.Red);
if (msg.HasElement(REASON))
{
Element reason = msg.GetElement(REASON);
string message = reason.GetElementAsString(DESCRIPTION);
group.Items[0].SubItems[1].Text = message;
}
}
}
}
}
private void processMessage(Message msg)
{
Element data = msg.GetElement(TICK_DATA).GetElement(TICK_DATA);;
int numItems = data.NumValues;
System.Console.WriteLine("TIME\t\t\tTYPE\tVALUE\t\tSIZE\tCC");
System.Console.WriteLine("----\t\t\t----\t-----\t\t----\t--");
for (int i = 0; i < numItems; ++i)
{
Element item = data.GetValueAsElement(i);
Datetime time = item.GetElementAsDate(TIME);
string type = item.GetElementAsString(TYPE);
double value = item.GetElementAsFloat64(VALUE);
int size = item.GetElementAsInt32(SIZE);
string cc = "";
if (item.HasElement(COND_CODE))
{
cc = item.GetElementAsString(COND_CODE);
}
System.DateTime sysDatetime =
new System.DateTime(time.Year, time.Month, time.DayOfMonth,
time.Hour, time.Minute, time.Second, time.MilliSecond);
System.Console.WriteLine(
sysDatetime.ToString("s") + "\t" +
type + "\t" +
value.ToString("C") + "\t\t" +
size + "\t" +
cc);
}
}
/// <summary>
/// Function to create and send ReferenceDataRequest
/// </summary>
/// <param name="session"></param>
private void sendRefDataRequest(Session session)
{
Service refDataService = session.GetService(REFDATA_SVC);
Request request = refDataService.CreateRequest("ReferenceDataRequest");
// Add securities to request
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue((string)d_securities[i]);
}
// Add fields to request
Element fields = request.GetElement("fields");
for (int i = 0; i < d_fields.Count; ++i)
{
fields.AppendValue((string)d_fields[i]);
}
System.Console.WriteLine("Sending Request: " + request);
if (d_authOption == "NONE")
{
session.SendRequest(request, null);
}
else
{
// request data with identity object
session.SendRequest(request, d_identity, null);
}
}
private void processSubscriptionStatus(Event eventObj, Session session)
{
System.Console.WriteLine("Processing SUBSCRIPTION_STATUS");
foreach (Message msg in eventObj)
{
string topic = (string)msg.CorrelationID.Object;
System.Console.WriteLine(System.DateTime.Now.ToString("s") +
": " + topic + " - " + msg.MessageType);
if (msg.HasElement(REASON))
{
// This can occur on SubscriptionFailure.
Element reason = msg.GetElement(REASON);
System.Console.WriteLine("\t" +
reason.GetElement(CATEGORY).GetValueAsString() +
": " + reason.GetElement(DESCRIPTION).GetValueAsString());
}
if (msg.HasElement(EXCEPTIONS))
{
// This can occur on SubscriptionStarted if at least
// one field is good while the rest are bad.
Element exceptions = msg.GetElement(EXCEPTIONS);
for (int i = 0; i < exceptions.NumValues; ++i)
{
Element exInfo = exceptions.GetValueAsElement(i);
Element fieldId = exInfo.GetElement(FIELD_ID);
Element reason = exInfo.GetElement(REASON);
System.Console.WriteLine("\t" + fieldId.GetValueAsString() +
": " + reason.GetElement(CATEGORY).GetValueAsString());
}
}
System.Console.WriteLine("");
}
}
public void processMessage(Message message)
{
Log.LogMessage(LogLevels.BASIC, "Teams: processing message");
if (message.MessageType.Equals(ERROR_INFO))
{
Log.LogMessage(LogLevels.BASIC, "Teams: processing RESPONSE error");
int errorCode = message.GetElementAsInt32("ERROR_CODE");
String errorMessage = message.GetElementAsString("ERROR_MESSAGE");
Log.LogMessage(LogLevels.BASIC, "Error getting teams: [" + errorCode + "] " + errorMessage);
}
else if (message.MessageType.Equals(GET_TEAMS))
{
Log.LogMessage(LogLevels.BASIC, "Teams: processing successful RESPONSE");
Element teamList = message.GetElement("TEAMS");
int numValues = teamList.NumValues;
for (int i = 0; i < numValues; i++)
{
String teamName = teamList.GetValueAsString(i);
Team newTeam = new Team(teams, teamName);
teams.add(newTeam);
Log.LogMessage(LogLevels.DETAILED, "Teams: Added new team " + newTeam.name);
}
}
}
private void sendRefDataRequest()
{
Request request = d_blpRefDataSvc.CreateRequest(
"ReferenceDataRequest");
// Add securities.
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue((String)d_securities[i]);
}
// Add fields
Element fields = request.GetElement("fields");
fields.AppendValue("PX_LAST");
fields.AppendValue("DS002");
request.Set("returnEids", true);
// Send the request using the server's credentials
System.Console.WriteLine("Sending RefDataRequest using server " +
"credentials..." + request.ToString());
d_session.SendRequest(request, d_appIdentity, null);
}
/// <summary>
/// Process miscellaneous events
/// </summary>
/// <param name="eventObj"></param>
/// <param name="session"></param>
private void processMiscEvents(Event eventObj, Session session)
{
foreach (Message msg in eventObj)
{
switch (msg.MessageType.ToString())
{
case "SessionStarted":
// "Session Started"
break;
case "SessionTerminated":
case "SessionStopped":
// "Session Terminated"
break;
case "ServiceOpened":
// "Reference Service Opened"
break;
case "RequestFailure":
Element reason = msg.GetElement(REASON);
string message = string.Concat("Error: Source-", reason.GetElementAsString(SOURCE),
", Code-", reason.GetElementAsString(ERROR_CODE), ", category-", reason.GetElementAsString(CATEGORY),
", desc-", reason.GetElementAsString(DESCRIPTION));
toolStripStatusLabel1.Text = message;
break;
default:
toolStripStatusLabel1.Text = msg.MessageType.ToString();
break;
}
}
}
private void ProcessCurveListResponse(Message msg)
{
Element results = msg.GetElement(RESULTS_ELEMENT);
int numResults = results.NumValues;
Console.WriteLine("Processing " + numResults + " results:");
for (int i = 0; i < numResults; ++i)
{
Element result = results.GetValueAsElement(i);
StringBuilder sb = new StringBuilder();
foreach (Name n in CURVE_RESPONSE_ELEMENTS)
{
if (sb.Length != 0)
{
sb.Append(" ");
}
sb.Append(n).Append("=").Append(result.GetElementAsString(n));
}
Console.WriteLine(
"\t{0} {1} - {2} '{3}'",
i + 1,
result.GetElementAsString(CURVE_ELEMENT),
result.GetElementAsString(DESCRIPTION_ELEMENT),
sb.ToString());
}
}
private void sendIntradayTickRequest(Session session)
{
Service refDataService = session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("IntradayTickRequest");
request.Set("security", d_security);
// Add fields to request
Element eventTypes = request.GetElement("eventTypes");
for (int i = 0; i < d_events.Count; ++i)
{
eventTypes.AppendValue((string)d_events[i]);
}
// All times are in GMT
request.Set("startDateTime", d_startDateTime);
request.Set("endDateTime", d_endDateTime);
if (d_conditionCodes)
{
request.Set("includeConditionCodes", true);
}
System.Console.WriteLine("Sending Request: " + request);
session.SendRequest(request, null);
}
private Request getBBRequest(ITickDataQuery query)
{
Service refDataService = Session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("IntradayTickRequest");
request.Set("security", query.Security);
Element eventTypes = request.GetElement("eventTypes");
foreach (string field in query.Fields)
{
eventTypes.AppendValue(field);
}
request.Set("includeConditionCodes", query.IncludeConditionCode);
request.Set("includeExchangeCodes", query.IncludeExchangeCode);
request.Set("startDateTime",
new BDateTime(query.StartDate));
request.Set("endDateTime",
new BDateTime(query.EndDate));
return(request);
}
/// <summary>
/// Function to create and send PortfolioDataRequest
/// </summary>
/// <param name="session"></param>
private void sendPortfolioDataRequest(Session session)
{
Service refDataService = session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("PortfolioDataRequest");
// Add securities to request
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue((string)d_securities[i]);
}
// Add fields to request
Element fields = request.GetElement("fields");
for (int i = 0; i < d_fields.Count; ++i)
{
fields.AppendValue((string)d_fields[i]);
}
// If specified, use REFERENCE_DATE override field
// to get portfolio information historically.
// The date must be in 'YYYYMMDD' format
if (d_override != null && d_override.Length != 0)
{
Element overrides = request["overrides"];
Element override1 = overrides.AppendElement();
override1.SetElement("fieldId", "REFERENCE_DATE");
override1.SetElement("value", d_override);
}
System.Console.WriteLine("Sending Request: " + request);
session.SendRequest(request, null);
}
private void run(string[] args)
{
// if only -h was entered for usage return without starting session
if (!parseCommandLine(args))
{
return;
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_host;
sessionOptions.ServerPort = d_port;
System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);
Session session = new Session(sessionOptions);
bool sessionStarted = session.Start();
if (!sessionStarted)
{
System.Console.WriteLine("Failed to start session.");
return;
}
if (!session.OpenService(REFDATA_SVC))
{
System.Console.WriteLine("Failed to open service: " + REFDATA_SVC);
return;
}
Service fieldInfoService = session.GetService(REFDATA_SVC);
Request request = fieldInfoService.CreateRequest("HistoricalDataRequest");
// Add securities to request
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue((string)d_securities[i]);
}
// Add fields to request
Element fields = request.GetElement("fields");
for (int i = 0; i < d_fields.Count; ++i)
{
fields.AppendValue((string)d_fields[i]);
}
request.Set("startDate", d_startDate);
request.Set("endDate", d_endDate);
System.Console.WriteLine("Sending Request: " + request);
session.SendRequest(request, null);
eventLoop(session);
session.Stop();
}//end run
// return true if processing is completed, false otherwise
private void processResponseEvent(Event eventObj)
{
foreach (Message msg in eventObj.GetMessages())
{
if (msg.HasElement(RESPONSE_ERROR))
{
printErrorInfo("REQUEST FAILED: ", msg.GetElement(RESPONSE_ERROR));
continue;
}
Element data = msg.GetElement(DATA);
Element securities = data.GetElement(SECURITY_DATA);
int numSecurities = securities.NumValues;
System.Console.WriteLine("Processing " + numSecurities + " securities:");
for (int i = 0; i < numSecurities; ++i)
{
Element security = securities.GetValueAsElement(i);
string ticker = security.GetElementAsString(SECURITY);
System.Console.WriteLine("\nTicker: " + ticker);
if (security.HasElement("securityError"))
{
printErrorInfo("\tSECURITY FAILED: ",
security.GetElement(SECURITY_ERROR));
continue;
}
Element fields = security.GetElement(FIELD_DATA);
if (fields.NumElements > 0)
{
System.Console.WriteLine("FIELD\t\tVALUE");
System.Console.WriteLine("-----\t\t-----");
int numElements = fields.NumElements;
for (int j = 0; j < numElements; ++j)
{
Element field = fields.GetElement(j);
System.Console.WriteLine(field.Name + "\t\t" +
field.GetValueAsString());
}
}
System.Console.WriteLine("");
Element fieldExceptions = security.GetElement(FIELD_EXCEPTIONS);
if (fieldExceptions.NumValues > 0)
{
System.Console.WriteLine("FIELD\t\tEXCEPTION");
System.Console.WriteLine("-----\t\t---------");
for (int k = 0; k < fieldExceptions.NumValues; ++k)
{
Element fieldException =
fieldExceptions.GetValueAsElement(k);
printErrorInfo(fieldException.GetElementAsString(FIELD_ID) +
"\t\t", fieldException.GetElement(ERROR_INFO));
}
}
}
}
}
/// <summary>
/// Process bulk data
/// </summary>
/// <param name="security"></param>
/// <param name="data"></param>
private void processBulkData(string security, Element data)
{
DataTable bulkTable = null;
// bulk data dataset
if (d_bulkData == null)
{
d_bulkData = new DataSet();
}
// get bulk data
Element bulk = data.GetValueAsElement(0);
if (d_bulkData.Tables.Contains(bulk.Name.ToString()))
{
// get existing bulk data table
bulkTable = d_bulkData.Tables[bulk.Name.ToString()];
}
else
{
// create new bulk data table
bulkTable = d_bulkData.Tables.Add(bulk.Name.ToString());
}
// create column if not already exist
if (!bulkTable.Columns.Contains("security"))
{
bulkTable.Columns.Add(new DataColumn("security", typeof(String)));
bulkTable.Columns.Add(new DataColumn("Id", typeof(int)));
}
// create columns in data table for bulk data
foreach (Element item in bulk.Elements)
{
if (!bulkTable.Columns.Contains(item.Name.ToString()))
{
bulkTable.Columns.Add(new DataColumn(item.Name.ToString(), typeof(String)));
}
}
// populate bulk
int count = 0;
for (int index = 0; index < data.NumValues; index++)
{
bulk = data.GetValueAsElement(index);
object[] dataArray = new object[bulk.NumElements + 2];
dataArray[0] = security;
dataArray[1] = count;
int dataIndex = 2;
foreach (Element item in bulk.Elements)
{
dataArray[dataIndex] = item.GetValueAsString();
dataIndex++;
}
bulkTable.Rows.Add(dataArray);
count++;
}
}
public void DownloadComponents(string Index, string bbgField, out List <string> members)
{
members = new List <string>();
Request request = refDataService.CreateRequest("ReferenceDataRequest");
Element securities = request.GetElement("securities");
securities.AppendValue(Index);
Element fields = request.GetElement("fields");
fields.AppendValue(bbgField);
Trace.WriteLine("Sending Index Components Request: " + Index);
session.SendRequest(request, null);
bool done = false;
while (!done)
{
Event eventObj = session.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE || eventObj.Type == Event.EventType.PARTIAL_RESPONSE)
{
foreach (var msg in eventObj)
{
if (msg.AsElement.HasElement("responseError"))
{
throw new Exception("Response error: " + msg.GetElement("responseError").GetElement("message"));
}
var security = msg.GetElement("securityData").GetValueAsElement();
var field = security.GetElement("fieldData").GetElement(bbgField);
for (int i = 0; i < field.NumValues; i++)
{
string data = "";
if (field.NumValues > 1)
{
data = field.GetValueAsElement(i).GetElement(0).GetValueAsString();
}
else
{
data = field.GetValueAsString();
}
members.Add(data + " Equity");
}
}
if (eventObj.Type == Event.EventType.RESPONSE)
{
done = true;
}
}
}
}
private void distributeMessage(Message msg)
{
Service service = msg.Service;
List <int> failedEntitlements = new List <int>();
Element securities = msg.GetElement(SECURITY_DATA);
int numSecurities = securities.NumValues;
System.Console.WriteLine("Processing " + numSecurities + " securities:");
for (int i = 0; i < numSecurities; ++i)
{
Element security = securities.GetValueAsElement(i);
String ticker = security.GetElementAsString(SECURITY);
Element entitlements = ((security.HasElement(EID_DATA) ?
security.GetElement(EID_DATA) : null));
int numUsers = d_identities.Count;
if (entitlements != null)
{
// Entitlements are required to access this data
for (int j = 0; j < numUsers; ++j)
{
failedEntitlements.Clear();
Identity identity = (Identity)d_identities[j];
if (identity.HasEntitlements(entitlements, service,
failedEntitlements))
{
System.Console.WriteLine("User: "******" is entitled to get data for: " + ticker);
// Now Distribute message to the user.
}
else
{
System.Console.WriteLine("User: "******" is NOT entitled to get data for: " + ticker +
" - Failed eids: ");
printFailedEntitlements(failedEntitlements);
}
}
}
else
{
// No Entitlements are required to access this data.
for (int j = 0; j < numUsers; ++j)
{
System.Console.WriteLine("User: "******" is entitled to get data for: " + ticker);
// Now Distribute message to the user.
}
}
}
}
bool ProcessErrors(Message msg)
{
Element securityData = msg.GetElement(SECURITY_DATA);
if (securityData.HasElement(SECURITY_ERROR))
{
Element security_error = securityData.GetElement(SECURITY_ERROR);
Element error_message = security_error.GetElement(MESSAGE);
System.Console.WriteLine(error_message);
return(true);
}
return(false);
}
private void ProcessInstrumentListResponse(Message msg)
{
Element results = msg.GetElement(RESULTS_ELEMENT);
int numResults = results.NumValues;
Console.WriteLine("Processing " + numResults + " results:");
for (int i = 0; i < numResults; ++i)
{
Element result = results.GetValueAsElement(i);
Console.WriteLine(
"\t{0} {1} - {2}",
i + 1,
result.GetElementAsString(SECURITY_ELEMENT),
result.GetElementAsString(DESCRIPTION_ELEMENT));
}
}
private void ProcessGovtListResponse(Message msg)
{
Element results = msg.GetElement(RESULTS_ELEMENT);
int numResults = results.NumValues;
Console.WriteLine("Processing " + numResults + " results:");
for (int i = 0; i < numResults; ++i)
{
Element result = results.GetValueAsElement(i);
Console.WriteLine(
"\t{0} {1}, {2} - {3}",
i + 1,
result.GetElementAsString(PARSEKY_ELEMENT),
result.GetElementAsString(NAME_ELEMENT),
result.GetElementAsString(TICKER_ELEMENT));
}
}
}//end printErrorInfo
bool ProcessExceptions(Message msg)
{
Element securityData = msg.GetElement(SECURITY_DATA);
Element field_exceptions = securityData.GetElement(FIELD_EXCEPTIONS);
if (field_exceptions.NumValues > 0)
{
Element element = field_exceptions.GetValueAsElement(0);
Element field_id = element.GetElement(FIELD_ID);
Element error_info = element.GetElement(ERROR_INFO);
Element error_message = error_info.GetElement(MESSAGE);
System.Console.WriteLine(field_id);
System.Console.WriteLine(error_message);
return(true);
}
return(false);
}
private Tuple<bool, dynamic> ConvertDataType(string dataType, Element field)
{
bool ok = false;
dynamic elementValue = null;
switch (dataType)
{
case "DATE":
{
DateTime _elementValue;
if (DateTime.TryParse(field.GetValue().ToString(), out _elementValue) ||
DateTime.TryParseExact(field.GetValue().ToString(), "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None, out _elementValue))
{
ok = true;
elementValue = _elementValue;
}
break;
}
case "FLOAT64":
case "FLOAT":
{
float _elementValue;
ok = float.TryParse(field.GetValue().ToString(), out _elementValue);
elementValue = _elementValue;
break;
}
default:
elementValue = field.GetValue().ToString();
elementValue = ((string)elementValue).Replace(',', ' ');
ok = true;
break;
}
return Tuple.Create<bool, dynamic>(ok, elementValue);
}
private IEnumerable<Tuple<string, SortedList<DateTime, dynamic>>> ParseUniversal(Element securityDataArray, List<IField> fields)
{
if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.P)
{
Console.WriteLine("\nDownload Paused, press c to continue");
while (!Console.KeyAvailable || Console.ReadKey(true).Key != ConsoleKey.C)
{
Thread.Sleep(1000 * 1);
}
}
var fieldNames = from f in fields
select f.FieldName.ToUpper();
SortedList<DateTime, dynamic> output;
if (securityDataArray.IsArray)
{
for (int i = 0; i < securityDataArray.NumValues; i++) //data for multiple securities
{
Element securityData = securityDataArray.GetValueAsElement(i); //single security
string securityName = securityData.GetElementAsString("security");
Element fieldData = securityData.GetElement("fieldData"); //data for multiple fields.
int j = -1;
foreach (var fieldName in fieldNames)
{
j++;
Element field = fieldData.GetElement(fieldName);
output = new SortedList<DateTime, dynamic>();
if (field.NumValues>0)
{
var data = field.GetValue(); //check field.NumValues - sometimes NumValues>1 - then output into single field - because it is single field but with multiple values
string dataType;
if (fields[j].Type != null && fields[j].Type.Length > 0)
dataType = fields[j].Type;
else
dataType = field.Datatype.ToString();
var result = ConvertDataType(dataType, field);
output.Add(ExtensionMethods.GetBusinessDay(DateTime.Today, -1), result.Item2);
}
yield return Tuple.Create(securityName,output);
}
}
}
else
{
var Outputs = new SortedList<DateTime, dynamic>[fieldNames.Count()];
for (int i = 0; i < Outputs.Length; i++)
Outputs[i] = new SortedList<DateTime, dynamic>();
Element fieldDataArray = securityDataArray.GetElement("fieldData"); // data for multiple fields, multiple dates
string securityName = securityDataArray.GetElementAsString("security");
for (int i = 0; i < fieldDataArray.NumValues; i++) //equals 0 if no fields or security wrong
{
Element fieldData = fieldDataArray.GetValueAsElement(i); // data for multiple fields, single date
int j = -1;
foreach (var fieldName in fieldNames)
{
j++;
Element date = fieldData.GetElement("date");
if (!fieldData.HasElement(fieldName))
continue;
Element field = fieldData.GetElement(fieldName);
dynamic elementValue = null;
bool ok = false;
string dataType;
if (fields[j].Type != null && fields[j].Type.Length > 0)
dataType = fields[j].Type;
else
dataType = field.Datatype.ToString();
var result = ConvertDataType(dataType, field);
ok = result.Item1;
elementValue = result.Item2;
if (!ok) { elementValue = null; }
Outputs[j].Add(date.GetValueAsDatetime().ToSystemDateTime(), elementValue);
}
}
for (int i = 0; i < Outputs.Length; i++)
yield return Tuple.Create(securityName, Outputs[i]);
}
}
