internal IntradayTickMessage(CorrelationID corr, Service service) :
base(new Name("IntradayTickResponse"), corr, service)
{
this._parent = null;
this._responseError = new IntradayTickElementResponseError();
this._isResponseError = true;
}
internal MessageMarketSubscriptionFailure(Subscription sub)
: base(new Name("SubscriptionFailure"), sub.CorrelationID, null)
{
this._correlationId = sub.CorrelationID;
this._topicName = sub.Security;
this._reason = new ElementMarketReason(ElementMarketReason.ReasonTypeEnum.badSecurity);
}
/// <summary>
/// Use this for security errors
/// </summary>
/// <param name="corr"></param>
/// <param name="service"></param>
internal IntradayBarMessage(CorrelationID corr, Service service, string security) :
base(new Name("IntradayBarResponse"), corr, service)
{
this._responseError = new IntradayBarElementResponseError(security);
this._parent = null;
this._isResponseError = true;
}
public ReferenceDataRequestInfo(IEnumerable<string> tickers, IEnumerable<string> fields)
{
Id = new CorrelationID();
Tickers = new List<string>(tickers);
Fields = new List<string>(fields);
Response = new ReferenceDataResponse(this);
}
/// <summary>
/// Use this for regular securities (no security error)
/// </summary>
/// <param name="corr"></param>
/// <param name="bars"></param>
/// <param name="service"></param>
internal IntradayBarMessage(CorrelationID corr, Service service, IEnumerable <IntradayBarTickDataType> bars) :
base(new Name("IntradayBarResponse"), corr, service)
{
this._parent = new IntradayBarElementData(bars);
this._responseError = null;
this._isResponseError = false;
}
public ReferenceDataRequestInfo(IEnumerable <string> tickers, IEnumerable <string> fields)
{
Id = new CorrelationID();
Tickers = new List <string>(tickers);
Fields = new List <string>(fields);
Response = new ReferenceDataResponse(this);
}
internal IntradayTickMessage(CorrelationID corr, Service service, SortedDictionary <DateTime, Types.Tuple3 <string, double, int> > ticks, bool includeConditionCodes) :
base(new Name("IntradayTickResponse"), corr, service)
{
this._parent = new IntradayTickElementDataParent(ticks, includeConditionCodes);
this._responseError = null;
this._isResponseError = false;
}
/// <summary>
/// Use this for security errors
/// </summary>
/// <param name="corr"></param>
/// <param name="service"></param>
internal MessageIntradayBar(CorrelationID corr, Service service, string security)
: base(new Name("IntradayBarResponse"), corr, service)
{
this._responseError = new ElementIntradayBarResponseError(security);
this._parent = null;
this._isResponseError = true;
}
private async Task DoKeyPressCommon(string sPrefix, object sender, View.KeyEventArgs eventArgs, AdjustTextDelegate adjustText, AfterOnEnterDelegate afterOnEnter)
{
eventArgs.Handled = false;
if (eventArgs.KeyCode == Keycode.Enter)
{
if (eventArgs.Event.Action == KeyEventActions.Up)
{
EditText eb = (EditText)sender;
string sResultText = eb.Text;
if (adjustText != null)
{
sResultText = adjustText(sResultText);
}
CorrelationID crid = new CorrelationID();
m_lp.LogEvent(crid, EventType.Information, "Dispatching ScanCode: {0}", sResultText);
await RunOnUiThreadAsync(() => eb.Text = $"{sPrefix}{sResultText}");
await DispatchScanCode(eb.Text, m_cbCheckOnly.Checked, crid);
afterOnEnter?.Invoke();
}
// handle both down and up so we don't get the default behavior...
eventArgs.Handled = true;
}
}
public void SendRequestForInstradayBar(ApiTaskBar argvTask)
{
//Generate correlation ID
long tUniqueId = this.GenerateCorrelationId();
CorrelationID tCorrelationId = new CorrelationID(tUniqueId);
mIntradayBarRequestByCorrelationId.Add(tUniqueId, argvTask);
//mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, "Sending Intraday Bar request..."));
// Create the Request object to represent the data request
Request tRequest = mReferenceService.CreateRequest("IntradayBarRequest");
// Specify the security we are interested in
tRequest.Set("security", argvTask.mBbgTicker);
// Add fields to request
tRequest.Set("eventType", argvTask.mFields);
tRequest.Set("gapFillInitialBar", false);
tRequest.Set("adjustmentNormal", false);
tRequest.Set("adjustmentAbnormal", false);
tRequest.Set("adjustmentSplit", false);
tRequest.Set("adjustmentFollowDPDF", false);
tRequest.Set("interval", argvTask.mBarLengthInMinute);
// Set the start and ending dates and the max number of data points
tRequest.Set("startDateTime", argvTask.mStartTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss"));
tRequest.Set("endDateTime", argvTask.mEndTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss"));
int tMaxDataPoints = (int)Math.Round((argvTask.mEndTime - argvTask.mStartTime).TotalMinutes / argvTask.mBarLengthInMinute + 10);
tRequest.Set("maxDataPoints", tMaxDataPoints);
mLastIntradayTickTicker = argvTask.mBbgTicker;
// Submit the request
mSession.SendRequest(tRequest, tCorrelationId);
mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, "IntradayBarRequest: " + argvTask.mTicker + " for fields " + argvTask.mFields
+ " from " + argvTask.mStartTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss") + " to " + argvTask.mEndTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss")));
}
/*----------------------------------------------------------------------------
* %%Function: ReaderLastScanDateDelegate
* %%Qualified: UpcSvc.UpcSvc.ReaderLastScanDateDelegate
* %%Contact: rlittle
*
* ----------------------------------------------------------------------------*/
public static void ReaderLastScanDateDelegate(SqlReader sqlr, CorrelationID crid, ref USR_String usrs)
{
DateTime dttm = sqlr.Reader.GetDateTime(1);
usrs = USR_String.FromTCSR(USR.SuccessCorrelate(crid));
usrs.TheValue = dttm.ToString();
}
public void SendRequestForReferenceData(List <ApiTask> argvTasks)
{
//mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, "Sending request for reference data..."));
foreach (ApiTask tTask in argvTasks)
{
//Generate correlation ID
long tUniqueId = this.GenerateCorrelationId();
CorrelationID tCorrelationId = new CorrelationID(tUniqueId);
mOtherRequestByCorrelationId.Add(tUniqueId, tTask);
// Create the Request object to represent the data request
Request tRequest = mReferenceService.CreateRequest("ReferenceDataRequest");
// Specify the security we are interested in
tRequest.Append("securities", tTask.mTicker);
// Specify the fields we are interested in
string[] tFields = tTask.GetFieldList();
foreach (string tField in tFields)
{
tRequest.Append("fields", tField);
}
tRequest.Set("returnEids", false);
tRequest.Set("returnFormattedValue", false);
tRequest.Set("useUTCTime", false);
tRequest.Set("forcedDelay", false);
tRequest.Set("returnNullValue", false);
// Submit the request
mSession.SendRequest(tRequest, tCorrelationId);
//mBbgMsgEvent(this, new InterfaceEventArgs(InterfaceEventArgs.xBbgMsgType.Print, "ReferenceDataRequest: " + tTask.mTicker + " for fields " + tTask.mFields));
}
}
private void authorizeUsers()
{
// Authorize each of the users
for (int i = 0; i < d_uuids.Count; ++i)
{
Identity identity = d_session.CreateIdentity();
d_identities.Add(identity);
Request authRequest = d_apiAuthSvc.CreateAuthorizationRequest();
authRequest.Set("uuid", d_uuids[i]);
authRequest.Set("ipAddress", d_programAddresses[i]);
CorrelationID correlator = new CorrelationID(i);
EventQueue eventQueue = new EventQueue();
d_session.SendAuthorizationRequest(authRequest, identity,
eventQueue, correlator);
Event eventObj = eventQueue.NextEvent();
while (true)
{
printEvent(eventObj);
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
break;
}
eventObj = eventQueue.NextEvent();
}
}
}
internal MessageIntradayTick(CorrelationID corr, Service service, Dictionary<DateTime, Tuple<string, double, int>> ticks, bool includeConditionCodes)
: base(new Name("IntradayTickResponse"), corr, service)
{
this._parent = new ElementIntradayTickDataParent(ticks, includeConditionCodes);
this._responseError = null;
this._isResponseError = false;
}
public void MakeRequest(string securityName, string fieldName)
{
if (refDataService == null) return;
Request request = refDataService.CreateRequest("ReferenceDataRequest");
Element securities = request.GetElement("securities");
securities.AppendValue(securityName);
Element fieldNames = request.GetElement("fields");
fieldNames.AppendValue(fieldName);
CorrelationID cID = new CorrelationID(1);
session.Cancel(cID);
session.SendRequest(request, cID);
//while (true)
//{
// Event eventObj = session.NextEvent();
// Debug.WriteLine("Processing data... {0}", eventObj.Type);
// // process data
// ProcessEvent(eventObj, session);
// if (eventObj.Type == Event.EventType.RESPONSE)
// {
// break;
// }
//}
Debug.WriteLine("Processed Request...");
}
internal MarketMessageSubscriptionStarted(Subscription sub) : base(new Name("SubscriptionStarted"), sub.CorrelationID, null)
{
this._correlationId = sub.CorrelationID;
this._topicName = sub.Security;
{ //deal with bad fields
List <string> badFields = new List <string>(sub.Fields.Count);
for (int i = sub.Fields.Count - 1; i >= 0; i--)
{
if (Types.Rules.IsBadField(sub.Fields[i]))
{
badFields.Add(sub.Fields[i]);
sub.Fields.RemoveAt(i);
}
}
if (badFields.Count == 0)
{
this._exceptionsNull = new MarketElementNull("exceptions");
}
else
{
this._exceptionsBadFields = new MarketElementExceptionsArray(badFields);
}
}
}
protected bool Authenticate(Session session, Identity identity, Request request)
{
var correlationId = new CorrelationID();
var eventQueue = new EventQueue();
session.SendAuthorizationRequest(request, identity, eventQueue, correlationId);
while (true)
{
var eventArgs = eventQueue.NextEvent();
foreach (var message in eventArgs.GetMessages())
{
if (MessageTypeNames.AuthorizationFailure.Equals(message.MessageType))
{
return(false);
}
if (MessageTypeNames.AuthorizationSuccess.Equals(message.MessageType))
{
return(true);
}
throw new Exception("Unknown message type: " + message);
}
}
}
internal MessageIntradayTick(CorrelationID corr, Service service)
: base(new Name("IntradayTickResponse"), corr, service)
{
this._parent = null;
this._responseError = new ElementIntradayTickResponseError();
this._isResponseError = true;
}
private IEnumerable <PriceResponse> LoadPrices(IEnumerable <SymbolRequest> symbols, DateTime startDate, DateTime endDate)
{
var prices = new List <PriceResponse>();
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = "127.0.0.1";
sessionOptions.ServerPort = 8194;
Session session = new Session(sessionOptions);
if (session.Start() && session.OpenService("//blp/refdata"))
{
Service service = session.GetService("//blp/refdata");
if (service == null)
{
Debug.WriteLine("Service is null");
}
else
{
foreach (var selectedSymbol in symbols)
{
var symbol = selectedSymbol.Symbol.Split(':');
Request request = service.CreateRequest("HistoricalDataRequest");
request.Append("securities", symbol[0] + " " + symbol[1] + " " + selectedSymbol.Industry);
request.Append("fields", "BID"); //Note that the API will not allow you to use the HistoricalDataRequest._nBid name as a value here. It expects a string.
request.Append("fields", "ASK"); //ditto
request.Set("startDate", startDate.ToString("yyyyMMdd")); //Request that the information start three months ago from today. This override is required.
request.Set("endDate", endDate.ToString("yyyyMMdd")); //Request that the information end three days before today. This is an optional override. The default is today.
CorrelationID requestID = new CorrelationID(1);
session.SendRequest(request, requestID);
bool continueToLoop = true;
while (continueToLoop)
{
Event eventObj = session.NextEvent();
switch (eventObj.Type)
{
case Event.EventType.RESPONSE: // final event
continueToLoop = false;
handleResponseEvent(eventObj, prices);
break;
case Event.EventType.PARTIAL_RESPONSE:
handleResponseEvent(eventObj, prices);
break;
default:
break;
}
}
}
}
}
return(prices);
}
/// <summary>
/// Get override field informations
/// </summary>
/// <param name="ids"></param>
private void getFieldInformation(List <string> ids)
{
// get auth service
if (d_service == null)
{
if (d_session.OpenService(@"//blp/apiflds"))
{
d_service = d_session.GetService(@"//blp/apiflds");
}
}
Request request = d_service.CreateRequest("FieldInfoRequest");
request.Set("returnFieldDocumentation", true);
foreach (string id in ids)
{
request.Append("id", id);
}
// set field info request correlationID to 3000
CorrelationID cId = new CorrelationID(3000);
// cancel previous pending request
d_session.Cancel(cId);
d_session.SendRequest(request, cId);
}
/// <summary>
/// generic remove the given code from the reentrancy protection. This code MUST match the code that
/// that was added to the queue
/// </summary>
/// <param name="crids"></param>
/// <param name="sTitle"></param>
/// <param name="fResult"></param>
async Task ReportAndRemoveReentrancyEntry(int workId, string scanCode, Guid crids, string sTitle, bool fResult)
{
string sDescription = sTitle;
if (sTitle == null)
{
// SetTextBoxText(ebScanCode, "");
await SetTextBoxText(ebTitle, "!!TITLE NOT FOUND");
sDescription = "";
// SetFocus(ebTitle, true);
}
else
{
await SetTextBoxText(ebTitle, sTitle);
//SetFocus(ebScanCode, false);
}
m_lp.LogEvent(
crids,
fResult ? EventType.Information : EventType.Error,
"FinalScanCodeCleanup: {0}: {1}",
fResult,
sTitle);
m_board.UpdateWork(workId, fResult, sDescription);
FinishCode(scanCode, CorrelationID.FromCrids(crids));
}
public Dictionary <long, MarketData> SubscribeMktData(List <ApiTaskRealtime> argvTasks)
{
Dictionary <long, MarketData> tReturnValue = new Dictionary <long, MarketData>();
List <Subscription> tNewTask = new List <Subscription>();
foreach (ApiTaskRealtime tTask in argvTasks)
{
if (!mSubscriptions.ContainsKey(tTask.mBbgTicker))
{
//Generate correlation ID
long tUniqueId = this.GenerateCorrelationId();
CorrelationID tCorrelationId = new CorrelationID(tUniqueId);
mSubscriptionByCorrelationId.Add(tUniqueId, tTask);
List <string> tFields = tTask.GetFieldList().ToList();
List <string> tOptions = new List <string>();
tOptions.Add("interval=" + tTask.mDataDeliverInterval.ToString());
Bloomberglp.Blpapi.Subscription tSubscription = new Subscription(tTask.mBbgTicker, tFields, tOptions, tCorrelationId);
mSubscriptions.Add(tTask.mBbgTicker, tSubscription);
tNewTask.Add(tSubscription);
mTradingDates.Add(tTask.mBbgTicker, DateTime.Today.ToString("yyyy-MM-dd"));
MarketData tNewMarketData = new MarketData(tTask.mTicker, tTask.mBbgTicker);
mMarketData.Add(tUniqueId, tNewMarketData);
tReturnValue.Add(tUniqueId, tNewMarketData);
}
}
mSession.Subscribe(tNewTask);
return(tReturnValue);
}
/// <summary>
/// Use this for regular securities (no security error)
/// </summary>
/// <param name="corr"></param>
/// <param name="bars"></param>
/// <param name="service"></param>
internal MessageIntradayBar(CorrelationID corr, Service service, IEnumerable<BarTickDataType> bars)
: base(new Name("IntradayBarResponse"), corr, service)
{
this._parent = new ElementBarData(bars);
this._responseError = null;
this._isResponseError = false;
}
private void _ProcessSubscriptionStatus(Event e, Session s)
{
List <Subscription> subscriptionList = null;
foreach (Message msg in e)
{
CorrelationID cid = msg.CorrelationID;
string topic = (string)cid.Object;
if (msg.MessageType == SUBSCRIPTION_TERMINATED && m_PendingUnsubscribe.Remove(cid))
{
// If this message was due to a previous unsubscribe
Subscription subscription = _GetSubscription(cid);
if (m_isSlow)
{
m_PendingSubscriptions.Add(subscription);
}
else
{
if (subscriptionList == null)
{
subscriptionList = new List <Subscription>();
}
subscriptionList.Add(subscription);
}
}
}
}
public void LogEvent(Guid crids, EventType et, string s, params object[] rgo)
{
TCore.Logging.EventType etActual;
switch (et)
{
case EventType.Critical:
etActual = TCore.Logging.EventType.Critical;
break;
case EventType.Error:
etActual = TCore.Logging.EventType.Error;
break;
case EventType.Information:
etActual = TCore.Logging.EventType.Information;
break;
case EventType.Verbose:
etActual = TCore.Logging.EventType.Verbose;
break;
case EventType.Warning:
etActual = TCore.Logging.EventType.Warning;
break;
default:
etActual = TCore.Logging.EventType.Critical;
break;
}
m_ilpActual.LogEvent(CorrelationID.FromCrids(crids), etActual, s, rgo);
}
public string GetSubscriptionString(CorrelationID correlationId)
{
if (!IsKnownCorrelationId(correlationId))
{
throw new UnknownCorrelationIdException(correlationId);
}
return Session.GetSubscriptionString(correlationId);
}
private void DispatchScanCodeFromEnter(string sScanCode)
{
CorrelationID crid = new CorrelationID();
m_lp.LogEvent(crid, EventType.Information, "Dispatching ScanCode: {0}", sScanCode);
DispatchScanCode(sScanCode, m_fCheckOnly, crid);
}
public Session.SubscriptionStatus GetSubscriptionStatus(CorrelationID correlationId)
{
if (!IsKnownCorrelationId(correlationId))
{
throw new UnknownCorrelationIdException(correlationId);
}
return(Session.GetSubscriptionStatus(correlationId));
}
public string GetSubscriptionString(CorrelationID correlationId)
{
if (!IsKnownCorrelationId(correlationId))
{
throw new UnknownCorrelationIdException(correlationId);
}
return(Session.GetSubscriptionString(correlationId));
}
/*----------------------------------------------------------------------------
* %%Function: DoManual
* %%Qualified: UniversalUpc.MainPage.DoManual
* %%Contact: rlittle
*
* take the current title and scan code and create an entry for it.
* ----------------------------------------------------------------------------*/
private async void DoManual(object sender, RoutedEventArgs e)
{
string sTitle = ebTitle.Text;
if (m_fCheckOnly)
{
if (m_adasCurrent == UpcInvCore.ADAS.DVD)
{
await m_upccCore.DoCheckDvdTitleInventory(sTitle, new CorrelationID());
}
else if (m_adasCurrent == UpcInvCore.ADAS.Book)
{
await m_upccCore.DoCheckBookTitleInventory(sTitle, new CorrelationID());
}
else if (m_adasCurrent == UpcInvCore.ADAS.Wine)
{
m_sb.AddMessage(AlertType.BadInfo, "No manual operation available for Wine");
}
return;
}
if (sTitle.StartsWith("!!"))
{
m_sb.AddMessage(AlertType.BadInfo, "Can't add title with leading error text '!!'");
return;
}
CorrelationID crid = new CorrelationID();
bool fResult = false;
if (m_adasCurrent == UpcInvCore.ADAS.DVD)
{
fResult = await m_upccCore.DoCreateDvdTitle(ebScanCode.Text, sTitle, m_fCheckOnly, m_fErrorSoundsOnly, crid);
}
else if (m_adasCurrent == UpcInvCore.ADAS.Book)
{
fResult = await m_upccCore.DoCreateBookTitle(ebScanCode.Text, sTitle, ebLocation.Text, m_fCheckOnly, m_fErrorSoundsOnly, crid);
}
else if (m_adasCurrent == UpcInvCore.ADAS.Wine)
{
m_sb.AddMessage(AlertType.BadInfo, "No manual operation available for Wine");
}
if (fResult)
{
m_sb.AddMessage(
m_fErrorSoundsOnly ? AlertType.None : AlertType.GoodInfo,
"Added {0} as {1}",
ebScanCode.Text,
sTitle);
}
else
{
m_sb.AddMessage(AlertType.Halt, "FAILED to Added {0} as {1}", ebScanCode.Text, sTitle);
}
}
public IPromise <string> RequestToken()
{
return(new Promise <string>((resolve, reject) =>
{
var correlationId = new CorrelationID();
AsyncHandlers.Add(correlationId, AsyncPattern <string> .Create(resolve, reject));
Session.GenerateToken(correlationId);
}));
}
public void WriteDataTo(BinaryWriter writer)
{
writer.Write(CorrelationID.ToString());
writer.Write(Projects.Count);
foreach (var project in Projects)
{
writer.Write(project);
}
}
public IPromise <Service> Request(string uri)
{
return(new Promise <Service>((resolve, reject) =>
{
var correlationId = new CorrelationID();
AsyncHandlers.Add(correlationId, AsyncPattern <Service> .Create(resolve, reject));
Session.OpenServiceAsync(uri, correlationId);
}));
}
async private void DispatchDvdScanCode(string sResultText, bool fCheckOnly, CorrelationID crid)
{
string sCode = m_upccCore.SEnsureEan13(sResultText);
// guard against reentrancy on the same scan code.
m_lp.LogEvent(crid, EventType.Verbose, "About to check for already processing: {0}", sCode);
try
{
if (!FAddProcessingCode(sCode, crid))
{
return;
}
}
catch (Exception exc)
{
this.RunOnUiThread(() => { m_isr.AddMessage(AlertType.Halt, "Exception caught: {0}", exc.Message); });
}
// now handle this scan code
this.RunOnUiThread(() => m_ebScanCode.Text = sCode);
// The removal of the reentrancy guard will happen asynchronously
await m_upccCore.DoHandleDvdScanCode(
UpcInvCore.s_workIdNil,
sCode,
null /*sExtra*/,
null /*sExtra2*/,
fCheckOnly,
false /*fErrorSoundsOnly*/,
crid,
async (workId, scanCode, crids, sTitle, fResult) =>
{
await RunOnUiThreadAsync(
() =>
{
if (sTitle == null)
{
m_ebTitle.Text = "!!TITLE NOT FOUND";
SetFocus(m_ebTitle, true);
}
else
{
m_ebTitle.Text = sTitle;
SetFocus(m_ebScanCode, false);
}
});
m_lp.LogEvent(
crids,
fResult ? EventType.Information : EventType.Error,
"FinalScanCodeCleanup: {0}: {1}",
fResult,
sTitle);
FinishCode(sCode, CorrelationID.FromCrids(crids));
});
}
public bool TryGet(CorrelationID correlationId, out IObserver <TResponse> observer, out TCorrelation correlation)
{
if (!TryGet(correlationId, out observer))
{
correlation = default(TCorrelation);
return(false);
}
return(_correlationMap.TryGetValue(correlationId, out correlation));
}
public override IObservable <IntradayBarResponse> ToObservable(IntradayBarRequest request)
{
return(Observable.Create <IntradayBarResponse>(observer =>
{
var correlationId = new CorrelationID();
Add(correlationId, observer, request.Ticker);
Session.SendRequest(request.ToRequest(Service), Identity, correlationId);
return Disposable.Create(() => Session.Cancel(correlationId));
}));
}
/// <summary>
/// Dispatch the scancode with the given workitem delegate.
/// The scanCode must already be normalized. The delegate should take care of dispatching
/// to the correct upcc handler AND must include the delegate to remove the reentrancy item
/// </summary>
/// <param name="delDispatch"></param>
/// <param name="delAdjust"></param>
/// <param name="scanCode"></param>
/// <param name="fErrorSoundsOnly"></param>
/// <param name="crids"></param>
void DispatchScanCodeCore(
AdjustScanCode delAdjust,
DoHandleDispatchScanCodeDelegate delDispatch,
string scanCode,
string sExtra,
string sExtra2,
bool fCheckOnly,
bool fErrorSoundsOnly,
Guid crids)
{
string scanCodeAdjusted = delAdjust(scanCode);
if (scanCodeAdjusted.StartsWith("!!"))
{
m_lp.LogEvent(crids, EventType.Error, scanCodeAdjusted);
SetFocus(ebScanCode, false);
m_sb.AddMessage(m_fErrorSoundsOnly ? AlertType.None : AlertType.BadInfo, scanCodeAdjusted);
return;
}
// guard against reentrancy on the same scan code.
m_lp.LogEvent(crids, EventType.Verbose, "About to check for already processing: {0}", scanCodeAdjusted);
if (!FAddProcessingCode(scanCodeAdjusted, CorrelationID.FromCrids(crids)))
{
// even if we bail out...set the focus
SetFocus(ebScanCode, false);
return;
}
// The removal of the reentrancy guard will happen asynchronously
int workId = m_board.CreateWork(scanCodeAdjusted, null);
WorkBoard.WorkItemDispatch del = async() =>
{
await delDispatch(
workId,
scanCodeAdjusted,
sExtra,
sExtra2,
fCheckOnly,
fErrorSoundsOnly,
crids,
ReportAndRemoveReentrancyEntry);
};
m_board.SetWorkDelegate(workId, del);
WorkItemView view = m_board.GetWorkItemView(workId);
lstWorkBoard.Items.Insert(0, view);
m_pipeline.Producer.QueueRecord(new Transaction(workId));
SetFocus(ebScanCode, false);
ResetWineInventoryControls();
}
public override IPromise <bool> Request(Session session, Service service, Identity identity)
{
return(new Promise <bool>((resolve, reject) =>
{
var correlationId = new CorrelationID();
AsyncHandlers.Add(correlationId, AsyncPattern <bool> .Create(resolve, reject));
var request = CreateRequest(service, _clientIpAddress, _uuid);
SendAuthorizationRequest(session, identity, request, correlationId);
}));
}
private IPromise<bool> Request(Session session, Service service, Identity identity, string token)
{
return new Promise<bool>((resolve, reject) =>
{
var correlationId = new CorrelationID();
AsyncHandlers.Add(correlationId, AsyncPattern<bool>.Create(resolve, reject));
var request = CreateRequest(service, token);
SendAuthorizationRequest(session, identity, request, correlationId);
});
}
public override IPromise<bool> Request(Session session, Service service, Identity identity)
{
return new Promise<bool>((resolve, reject) =>
{
var correlationId = new CorrelationID();
AsyncHandlers.Add(correlationId, AsyncPattern<bool>.Create(resolve, reject));
var request = CreateRequest(service, _clientIpAddress, _uuid);
SendAuthorizationRequest(session, identity, request, correlationId);
});
}
//use for subscribing
internal EventMarket(EventType evtType, CorrelationID corr, IEnumerable<Subscription> subscriptions)
{
this._messages = new List<Message>();
switch (evtType)
{
case EventType.SESSION_STATUS:
base._type = evtType;
MessageMarketSessionOpened msgSessionOpened = new MessageMarketSessionOpened();
this._messages.Add(msgSessionOpened);
break;
case EventType.SERVICE_STATUS:
base._type = evtType;
MessageMarketServiceStatus msgServiceStatus = new MessageMarketServiceStatus(corr);
this._messages.Add(msgServiceStatus);
break;
case EventType.SUBSCRIPTION_STATUS:
base._type = evtType;
foreach (var item in subscriptions)
{
bool securityError = Types.Rules.IsSecurityError(item.Security);
if (securityError)
{
MessageMarketSubscriptionFailure msgError = new MessageMarketSubscriptionFailure(item);
this._messages.Add(msgError);
}
else
{
MessageMarketSubscriptionStarted msgSubStatus = new MessageMarketSubscriptionStarted(item);
this._messages.Add(msgSubStatus);
}
}
break;
case EventType.SUBSCRIPTION_DATA:
base._type = evtType;
foreach (var item in subscriptions)
{
bool securityError = Types.Rules.IsSecurityError(item.Security);
if (!securityError)
{
MessageMarketSubscriptionData msgSubData = new MessageMarketSubscriptionData(item, EventMarket.GenerateFakeMessageData(item));
this._messages.Add(msgSubData);
}
}
break;
default:
throw new NotImplementedException(string.Format("BEmu.MarketDataRequest.EventMarket.EventMarket: doesn't expect EventType {0}", evtType.ToString()));
}
}
public void MakeHistoryRequest(string securityName, string fieldName, DateTime startDate, DateTime endDate)
{
if (refDataService == null) return;
Request request = refDataService.CreateRequest("HistoricalDataRequest");
Element securities = request.GetElement("securities");
securities.AppendValue(securityName);
Element fieldNames = request.GetElement("fields");
fieldNames.AppendValue(fieldName);
request.GetElement("startDate").SetValue(DateParameterString(startDate));
request.GetElement("endDate").SetValue(DateParameterString(endDate));
request.Set("periodicitySelection", new Name("WEEKLY"));
CorrelationID cID = new CorrelationID(1);
session.Cancel(cID);
session.SendRequest(request, cID);
}
protected bool Authenticate(Session session, Identity identity, Request request)
{
var correlationId = new CorrelationID();
var eventQueue = new EventQueue();
session.SendAuthorizationRequest(request, identity, eventQueue, correlationId);
while (true)
{
var eventArgs = eventQueue.NextEvent();
foreach (var message in eventArgs.GetMessages())
{
if (MessageTypeNames.AuthorizationFailure.Equals(message.MessageType))
return false;
if (MessageTypeNames.AuthorizationSuccess.Equals(message.MessageType))
return true;
throw new Exception("Unknown message type: " + message);
}
}
}
internal MessageMarketSubscriptionStarted(Subscription sub)
: base(new Name("SubscriptionStarted"), sub.CorrelationID, null)
{
this._correlationId = sub.CorrelationID;
this._topicName = sub.Security;
{ //deal with bad fields
List<string> badFields = new List<string>(sub.Fields.Count);
for (int i = sub.Fields.Count - 1; i >= 0; i--)
{
if (Types.Rules.IsBadField(sub.Fields[i]))
{
badFields.Add(sub.Fields[i]);
sub.Fields.RemoveAt(i);
}
}
if (badFields.Count == 0)
this._exceptionsNull = new ElementMarketNull("exceptions");
else
this._exceptionsBadFields = new ElementMarketExceptionsArray(badFields);
}
}
internal MessageReference(CorrelationID corr, Dictionary<string, Dictionary<string, object>> fieldData)
: base(new Name("ReferenceDataResponse"), corr, null)
{
this._securities = new ElementReferenceSecurityDataArray(fieldData);
}
public bool IsHandler(CorrelationID correlationId)
{
return AsyncHandlers.ContainsKey(correlationId);
}
public virtual void Cancel(CorrelationID correlationId)
{
Session.Cancel(correlationId);
}
internal MessageHistoric(CorrelationID corr, string securityName, List<string> badFields, Dictionary<DateTime, Dictionary<string, object>> fieldData, int sequenceNumber)
: base(new Name("HistoricalDataResponse"), corr, null)
{
this._security = new ElementHistoricSecurityData(securityName, badFields, fieldData, sequenceNumber);
}
internal MessageMarketServiceStatus(CorrelationID corr)
: base(new Name("ServiceOpened"), corr, null)
{
this._serviceName = new ElementMarketString("serviceName", "//blp/mktdata");
}
private void HandleSessionStatusEvent(Event eventObject, Session session)
{
if (!IsSessionStartedEvent(eventObject)) return;
try
{
startToken = new CorrelationID(StartTokenValue);
session.OpenServiceAsync(ServiceUri, startToken);
}
catch (Exception ex)
{
throw;
}
}
public static DatedDataCollectionGen<string> GetHistoryString(DateTime startDate_, string security_, string field_, bool canBeRetrievedYesterday_)
{
DatedDataCollectionGen<string> ret = null;
Request req = Core.Instance.SyncRefService.CreateRequest("HistoricalDataRequest");
req.GetElement("securities").AppendValue(security_);
req.GetElement("fields").AppendValue(field_);
req.Set("startDate", startDate_.ToString("yyMMdd"));
CorrelationID id = new CorrelationID(Core.NextID());
Core.Instance.SyncSession.SendRequest(req, id);
while (true)
{
Event eventObj = Core.Instance.SyncSession.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE)
{
foreach (Message msg in eventObj.GetMessages())
{
if (msg.HasElement("responseError"))
{
}
else
{
Element secDataArray = msg.GetElement("securityData");
if (secDataArray.HasElement("securityError"))
{
}
//else if (secDataArray.HasElement("fieldExceptions"))
//{
// Element error = secDataArray.GetElement("fieldExceptions");
// for (int errorIndex = 0; errorIndex < error.NumValues; ++errorIndex)
// {
// Element errorException = error.GetValueAsElement(errorIndex);
// string field = errorException.GetElementAsString("fieldId");
// Element errorInfo = errorException.GetElement("errorInfo");
// string message = errorInfo.GetElementAsString("message");
// Console.WriteLine(string.Format("{0} - {1}", field, message));
// }
//}
else
{
// process securities data
for (int i = 0; i < secDataArray.NumValues; ++i)
{
foreach (Element secData in secDataArray.Elements)
{
if (secData.Name.Equals("fieldData"))
{
string[] vals = new string[secData.NumValues];
System.DateTime[] dates = new System.DateTime[secData.NumValues];
for (int j = 0; j < secData.NumValues; ++j)
{
Element o = secData.GetValueAsElement(j);
dates[j] = o.GetElementAsDate("date").ToSystemDateTime();
//vals[j] = Convert.ToDouble(o.GetElementAsFloat64(field_));
vals[j] = o.GetElementAsString(field_);
}
ret = new DatedDataCollectionGen<string>(dates, vals);
}
}
}
}
}
}
break;
}
}
return ret;
}
public static RDResult GetReferenceData(string security_, IEnumerable<string> fields_, Dictionary<string, string> overrides_, RefreshOption option_)
{
RDResult ret = null;
string path = string.Format(@"{0}\{1}.refCache",CACHE_PATH, security_);
DateTime? lastWrite = null;
{
if (File.Exists(path))
{
lastWrite = new FileInfo(path).LastWriteTime;
FileStream file = null;
try
{
file = new FileStream(path, FileMode.Open, FileAccess.Read);
BinaryFormatter bf = new BinaryFormatter();
ret = bf.Deserialize(file) as RDResult;
}
finally
{
if (file != null)
{
file.Close();
file.Dispose();
file = null;
}
}
}
}
bool needToMakeCall = false;
if (ret != null)
{
foreach (string field in fields_)
if (ret.FieldNames.Contains<string>(field) == false)
{
needToMakeCall = true;
break;
}
}
if (!needToMakeCall)
{
switch (option_)
{
case RefreshOption.AlwaysRefresh:
needToMakeCall = true;
break;
case RefreshOption.RefreshIfOlderThanToday:
if (!(lastWrite.HasValue && lastWrite.Value.Date == DateTime.Today))
needToMakeCall = true;
break;
case RefreshOption.RefreshIfOllderThan24Hours:
if (!(lastWrite.HasValue && Math.Abs((lastWrite.Value.Date - DateTime.Now).TotalHours)<24d))
needToMakeCall = true;
break;
}
}
if (ret != null && !needToMakeCall)
return ret;
{
lock (typeof(HistoryRequester))
{
Request req = Core.Instance.SyncRefService.CreateRequest("ReferenceDataRequest");
Element securities = req.GetElement("securities");
Element fields = req.GetElement("fields");
Element requestOverrides = req.GetElement("overrides");
securities.AppendValue(security_);
foreach (string field in fields_)
fields.AppendValue(field);
if (overrides_ != null && overrides_.Count > 0)
{
foreach (string key in overrides_.Keys)
{
Element ovr = requestOverrides.AppendElement();
ovr.SetElement("fieldId", key);
ovr.SetElement("value", overrides_[key]);
}
}
CorrelationID id = new CorrelationID(Core.NextID());
Core.Instance.SyncSession.SendRequest(req, id);
while (true)
{
Event eventObj = Core.Instance.SyncSession.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE)
{
foreach (Message msg in eventObj.GetMessages())
{
if (msg.HasElement("responseError"))
{
}
else
{
Element secDataArray = msg.GetElement("securityData");
// we have only submitted one security so there should only be one element
Element secData = secDataArray.GetValueAsElement(0);
Element securityElement = secData.GetElement("security");
ret = new RDResult(securityElement.GetValueAsString());
Element fieldData = secData.GetElement("fieldData");
// return toplevel result is always a SEQUENCE of results, so assume and iterate over them...
for (int j = 0; j < fieldData.NumElements; ++j)
{
Element e = fieldData.GetElement(j);
RDFieldData rdData = null;
string name = e.Name.ToString();
RDDataType dtype = (RDDataType)Enum.Parse(typeof(RDDataType), e.Datatype.ToString());
if (e.Datatype == Schema.Datatype.SEQUENCE)
{
if (e.NumValues > 0)
{
object[,] vals = new object[e.NumValues, e.GetValueAsElement(0).NumElements];
for (int y = 0; y < e.NumValues; ++y)
{
var rowElement = e.GetValueAsElement(y);
for (int yy = 0; yy < rowElement.NumElements; ++yy)
{
var cellElement = rowElement.GetElement(yy);
vals[y, yy] = getValueFromElement(cellElement);
}
}
rdData = new RDFieldData(name, dtype, vals);
}
else
rdData = null;
}
else
{
rdData = new RDFieldData(name, dtype, getValueFromElement(e));
}
//else if (e.Datatype == Schema.Datatype.DATE || e.Datatype == Schema.Datatype.DATETIME)
//{
// DateTime date = e.GetValueAsDatetime().ToSystemDateTime();
// rdData = new RDFieldData(name, dtype, date);
//}
//else if (e.Datatype == Schema.Datatype.STRING)
//{
// string s = e.GetValueAsString();
// rdData = new RDFieldData(name, dtype, s);
//}
//else if (e.Datatype == Schema.Datatype.INT32)
//{
// int v = e.GetValueAsInt32();
// rdData = new RDFieldData(name, dtype, v);
//}
//else if (e.Datatype == Schema.Datatype.FLOAT32)
//{
// float f = e.GetValueAsFloat32();
// rdData = new RDFieldData(name, dtype, f);
//}
//else if (e.Datatype == Schema.Datatype.FLOAT64)
//{
// double d = e.GetValueAsFloat64();
// rdData = new RDFieldData(name, dtype, d);
//}
//else
//{
//}
if (rdData != null)
ret.Add(rdData);
}
}
}
break; // break out of listening loop to messages
}
}
}
}
if (ret != null)
{
try
{
Stream a = File.OpenWrite(path);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(a, ret);
a.Flush();
a.Close();
a.Dispose();
}
catch { }
}
return ret;
}
public static DatedDataCollectionGen<double> GetHistory(DateTime startDate_, string security_, string field_, RefreshOption option_, Dictionary<string, string> overrides_ = null)
{
DatedDataCollectionGen<double> ret = null;
lock (CACHE_PATH)
{
string key = string.Format("{0}_{1}_{2}", security_, field_, startDate_.ToString("ddMMMyyyy"));
string path = string.Format(@"{0}\{1}", CACHE_PATH, key);
if (File.Exists(path) && overrides_ == null)
{
var lastWriteTime = File.GetLastWriteTime(path).Date;
bool doRead = true;
switch (option_)
{
case RefreshOption.AlwaysRefresh:
case RefreshOption.NeverRefreshIfAlreadyGot:
doRead = false;
break;
case RefreshOption.RefreshIfOlderThanToday:
doRead = lastWriteTime < DateTime.Today;
break;
case RefreshOption.RefreshIfOllderThan24Hours:
doRead = lastWriteTime < DateTime.Now.AddDays(-1d);
break;
}
if (!doRead)
{
File.Delete(path);
}
else
{
FileStream file = null;
try
{
file = new FileStream(path, FileMode.Open, FileAccess.Read);
BinaryFormatter bf = new BinaryFormatter();
ret = bf.Deserialize(file) as DatedDataCollectionGen<double>;
}
finally
{
if (file != null)
{
file.Close();
file.Dispose();
file = null;
}
}
}
}
if (ret == null || ret.Length == 0)
{
lock (typeof(HistoryRequester))
{
Request req = Core.Instance.SyncRefService.CreateRequest("HistoricalDataRequest");
req.GetElement("securities").AppendValue(security_);
req.GetElement("fields").AppendValue(field_);
req.Set("startDate", startDate_.ToString("yyMMdd"));
// set overrides
if (overrides_ != null)
{
Element overrides = req.GetElement("overrides");
foreach (string k in overrides_.Keys)
{
Element or = overrides.AppendElement();
or.SetElement("fieldId", k);
or.SetElement("value", overrides_[k]);
//req.Set(k, overrides_[k]);
}
}
CorrelationID id = new CorrelationID(Core.NextID());
Core.Instance.SyncSession.SendRequest(req, id);
while (true)
{
Event eventObj = Core.Instance.SyncSession.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE)
{
foreach (Message msg in eventObj.GetMessages())
{
if (msg.HasElement("responseError"))
{
}
else
{
Element secDataArray = msg.GetElement("securityData");
if (secDataArray.HasElement("securityError"))
{
}
//else if (secDataArray.HasElement("fieldExceptions"))
//{
// Element error = secDataArray.GetElement("fieldExceptions");
// for (int errorIndex = 0; errorIndex < error.NumValues; ++errorIndex)
// {
// Element errorException = error.GetValueAsElement(errorIndex);
// string field = errorException.GetElementAsString("fieldId");
// Element errorInfo = errorException.GetElement("errorInfo");
// string message = errorInfo.GetElementAsString("message");
// Console.WriteLine(string.Format("{0} - {1}", field, message));
// }
//}
else
{
// process securities data
for (int i = 0; i < secDataArray.NumValues; ++i)
{
foreach (Element secData in secDataArray.Elements)
{
if (secData.Name.Equals("fieldData"))
{
double[] vals = new double[secData.NumValues];
System.DateTime[] dates = new System.DateTime[secData.NumValues];
for (int j = 0; j < secData.NumValues; ++j)
{
Element o = secData.GetValueAsElement(j);
dates[j] = o.GetElementAsDate("date").ToSystemDateTime();
vals[j] = Convert.ToDouble(o.GetElementAsFloat64(field_));
}
ret = new DatedDataCollectionGen<double>(dates, vals);
}
}
}
}
}
}
break;
}
}
}
if (ret != null)
{
try
{
Stream a = File.OpenWrite(path);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(a, ret);
a.Flush();
a.Close();
a.Dispose();
}
catch
{
}
}
}
}
return ret;
}
public void Subscribe(string securityName, string fieldName)
{
session.OpenService("//blp/mktdata");
Service realtimeService = session.GetService("//blp/mktdata");
Subscription subscription = new Subscription(securityName, fieldName);
CorrelationID correlator = new CorrelationID(securityName + "!" + fieldName);
subscription.CorrelationID = correlator;
session.Cancel(correlator);
List<Subscription> subscriptions = new List<Subscription>();
subscriptions.Add(subscription);
session.Subscribe(subscriptions);
}
private bool IsKnownCorrelationId(CorrelationID correlationId)
{
return Subscriptions.ContainsKey(correlationId);
}
private void pullInitial(SessionOptions sessionOptions)
{
Session session = new Session(sessionOptions);
if (!session.Start())
{
Invoke(new Action(() => richTextBox1.AppendText("Could not start session 2.")));
}
if (!session.OpenService("//blp/refdata"))
{
Invoke(new Action(() => richTextBox1.AppendText("Could not open service " + "//blp/refdata")));
}
CorrelationID requestID = new CorrelationID(1);
Service refDataSvc = session.GetService("//blp/refdata");
Request request =
refDataSvc.CreateRequest("ReferenceDataRequest");
foreach (string security in securityList1)
{
request.Append("securities", security);
}
foreach (string security in securityList2)
{
request.Append("securities", security);
}
foreach (string currency in currencyList1)
{
if (currency == baseCurrency) { continue; }
string currencyID = currency + baseCurrency + " Curncy";
request.Append("securities", currencyID);
}
foreach (string currency in currencyList2)
{
if (currency == baseCurrency) { continue; }
string currencyID = currency + baseCurrency + " Curncy";
request.Append("securities", currencyID);
}
Invoke(new Action(() => richTextBox1.AppendText("added securities\n")));
List<string> _fields;
_fields = new List<String>();
_fields.Add("LAST_PRICE");
_fields.Add("BEST_BID");
_fields.Add("BEST_ASK");
_fields.Add("BEST_BID1_SZ");
_fields.Add("BEST_ASK1_SZ");
request.Append("fields", "LAST_PRICE");
request.Append("fields", "BEST_BID");
request.Append("fields", "BEST_ASK");
request.Append("fields", "BEST_BID1_SZ");
request.Append("fields", "BEST_ASK1_SZ");
session.SendRequest(request, requestID);
bool continueToLoop = true;
while (continueToLoop)
{
Bloomberglp.Blpapi.Event evt = session.NextEvent();
switch (evt.Type)
{
case Event.EventType.PARTIAL_RESPONSE:
Invoke(new Action(() => richTextBox1.AppendText("partial response\n")));
ProcessEvent(evt, _fields);
break;
case Event.EventType.RESPONSE: // final event
Invoke(new Action(() => richTextBox1.AppendText("final response\n")));
continueToLoop = false; // fall through
break;
}
}
Invoke(new Action(() => richTextBox1.AppendText("-------------- FINISHED INITIAL PULL -------------")));
Invoke(new Action(() => richTextBox1.AppendText("-------------- FINISHED INITIAL PULL -------------")));
Invoke(new Action(() => richTextBox1.AppendText("-------------- FINISHED INITIAL PULL -------------")));
}
public Session.SubscriptionStatus GetSubscriptionStatus(CorrelationID correlationId)
{
if (!IsKnownCorrelationId(correlationId))
throw new UnknownCorrelationIdException(correlationId);
return Session.GetSubscriptionStatus(correlationId);
}
public result Submit(string ISIN)
{
result FOSresult = new result();
//open excel to get two parameter
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = "WSG053";
sessionOptions.ServerPort = 0x2002;
Session session = new Session(sessionOptions);
if (!session.Start())
{
Console.WriteLine("Could not start session.");
Environment.Exit(1);
}
if (!session.OpenService("//blp/refdata"))
{
Console.WriteLine("Could not open service //blp/refdata");
Environment.Exit(1);
}
CorrelationID requestID = new CorrelationID(1L);
Request request = session.GetService("//blp/refdata").CreateRequest("ReferenceDataRequest");
request.GetElement("securities").AppendValue(ISIN + " corp");
Element fields = request.GetElement("fields");
fields.AppendValue("SECURITY_DES");
fields.AppendValue("CRNCY");
fields.AppendValue("ISSUER");
fields.AppendValue("COUNTRY_FULL_NAME");
fields.AppendValue("MARKET_SECTOR_DES");
fields.AppendValue("INDUSTRY_SECTOR");
fields.AppendValue("PX_BID");
fields.AppendValue("COUPON");
fields.AppendValue("YLD_YTM_BID");
fields.AppendValue("DUR_BID");
fields.AppendValue("RTG_SP");
fields.AppendValue("RTG_SP_LT_LC_ISSUER_CREDIT");
fields.AppendValue("RTG_MOODY");
fields.AppendValue("RTG_MOODY_LONG_TERM");
fields.AppendValue("RTG_MDY_LC_CURR_ISSUER_RATING");
fields.AppendValue("RTG_FITCH");
fields.AppendValue("RTG_FITCH_LT_ISSUER_DEFAULT");
fields.AppendValue("COLLAT_TYP");
fields.AppendValue("MTY_YEARS_TDY");
fields.AppendValue("NXT_CALL_DT");
fields.AppendValue("MATURITY");
fields.AppendValue("GUARANTOR");
Console.WriteLine("Sending Request:" + request);
session.SendRequest(request, null);
while (true)
{
Event eventObj = session.NextEvent();
this.processEvent(eventObj, session);
if (eventObj.Type == Event.EventType.RESPONSE)
{
IssueRating = RTG_SP + "/" + this.GetMoody(RTG_MOODY, RTG_MOODY_LONG_TERM) + "/" + RTG_FITCH;
IssuerRating = RTG_SP_LT_LC_ISSUER_CREDIT + "/" + RTG_MDY_LC_CURR_ISSUER_RATING + "/" + RTG_FITCH_LT_ISSUER_DEFAULT;
if (CallDate != "NA")
{
DateTime newdate = DateTime.Parse(CallDate);
DateTime nowdate = DateTime.Now;
decimal dCallDate = (decimal)(((TimeSpan)(newdate - nowdate)).Days) / 365;
CallDate = StandardFormat(Math.Round(dCallDate, 2).ToString(), 2);
}
FOSresult.CallDate = CallDate;
FOSresult.COLLATERAL_TYPE = COLLATERAL_TYPE;
FOSresult.COUNTRY_FULL_NAME = COUNTRY_FULL_NAME;
FOSresult.COUPON = COUPON;
FOSresult.CRNCY = CRNCY;
FOSresult.DUR_BID = DUR_BID;
FOSresult.INDUSTRY_SECTOR = INDUSTRY_SECTOR.ToUpper();
FOSresult.PX_BID = PX_BID;
FOSresult.YLD_YTM_BID = YLD_YTM_BID;
FOSresult.SECURITY_DES = SECURITY_DES;
FOSresult.IssueRating = IssueRating;
FOSresult.IssuerRating = IssuerRating;
FOSresult.MARKET_SECTOR_DES = MARKET_SECTOR_DES;
FOSresult.YearToMaturity = Maturity;
FOSresult.ISSUER = ISSUER;
GetInfoFromExcel(FOSresult);
//undoImpersonation();
return FOSresult;
//return base.Json(new { SECURITY_DES = SECURITY_DES, CRNCY = CRNCY, ISSUER = ISSUER, COUNTRY_FULL_NAME = COUNTRY_FULL_NAME, MARKET_SECTOR_DES = MARKET_SECTOR_DES, INDUSTRY_SECTOR = INDUSTRY_SECTOR.ToUpper(), PX_BID = PX_BID, COUPON = COUPON, YLD_YTM_BID = YLD_YTM_BID, DUR_BID = DUR_BID, IssueRating = IssueRating, IssuerRating = IssuerRating, COLLATERAL_TYPE = COLLATERAL_TYPE, YearToMaturity = Maturity, CallDate = CallDate });
}
}
}
protected void SendAuthorizationRequest(Session session, Identity identity, Request request, CorrelationID correlationId)
{
session.SendAuthorizationRequest(request, identity, correlationId);
}
public static void GetTickRequest(string security_, DateTime startDate_, DateTime endDate_)
{
lock (typeof(HistoryRequester))
{
Request req = Core.Instance.SyncRefService.CreateRequest("IntradayTickRequest");
req.Set("security", security_);
req.Set("startDateTime", startDate_.ToString("yyMMdd"));
req.Set("endDateTime", endDate_.ToString("yyMMdd"));
req.Set("eventTypes", "TRADE");
var id = new CorrelationID(Core.NextID());
Core.Instance.SyncSession.SendRequest(req, id);
while (true)
{
var eventObj = Core.Instance.SyncSession.NextEvent();
foreach (Message msg in eventObj.GetMessages())
{
}
}
}
}
