/// <summary>
/// Show an exeption alert
/// </summary>
/// <param name="recordNotFoundException"></param>
public void Show(FaultException <RecordNotFoundFault> recordNotFoundException)
{
Display(String.Format(FluidTrade.Core.Properties.Resources.RecordNotFoundError,
CommonConversion.FromArray(recordNotFoundException.Detail.Key),
recordNotFoundException.Detail.TableName),
AlertMessageBoxType.RecordNotFoundError);
}
/// <summary>
/// Updates a Working Order record.
/// </summary>
/// <param name="state">The generic thread initialization parameter.</param>
private void UpdateDataModel(object state)
{
// Extract the specific instructions for changing the working order from the generic argument.
MatchChange matchChange = state as MatchChange;
try
{
// Create a channel to the middle tier.
DataModelClient dataModelClient = new DataModelClient(Guardian.Properties.Settings.Default.DataModelEndpoint);
// Call the handler to update the working order record.
matchChange.Handler(dataModelClient, matchChange.MatchRow, matchChange.Value);
// At this point the client can be shut down gracefully.
dataModelClient.Close();
}
catch (FaultException <OptimisticConcurrencyFault> optimisticConcurrencyException)
{
// The record is busy.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
String.Format(FluidTrade.Core.Properties.Resources.OptimisticConcurrencyError,
optimisticConcurrencyException.Detail.TableName));
}
catch (FaultException <RecordNotFoundFault> recordNotFoundException)
{
// The record is busy.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
String.Format(FluidTrade.Core.Properties.Resources.RecordNotFoundError,
CommonConversion.FromArray(recordNotFoundException.Detail.Key),
recordNotFoundException.Detail.TableName));
}
catch (CommunicationException communicationException)
{
// Log communication problems.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
communicationException.Message);
}
catch (Exception exception)
{
// Log communication problems.
EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace);
}
}
private void ExecuteSlice(object state)
{
List <WorkingOrderRow> workingOrders = state as List <WorkingOrderRow>;
try
{
List <TradingSupportReference.DestinationOrderInfo> destinationOrders = new List <TradingSupportReference.DestinationOrderInfo>();
lock (DataModel.SyncRoot)
{
DestinationRow destinationRow = DataModel.Destination.DestinationKeyExternalId0.Find("GUARDIAN ECN");
foreach (WorkingOrderRow workingOrderRow in workingOrders)
{
decimal sourceOrderQuantity = 0.0M;
foreach (SourceOrderRow sourceOrderRow in workingOrderRow.GetSourceOrderRows())
{
sourceOrderQuantity += sourceOrderRow.OrderedQuantity;
}
Decimal destinationOrderQuantity = 0.0M;
foreach (DestinationOrderRow destinationOrderRow in workingOrderRow.GetDestinationOrderRows())
{
destinationOrderQuantity += destinationOrderRow.OrderedQuantity;
}
if (sourceOrderQuantity > destinationOrderQuantity)
{
TradingSupportReference.DestinationOrderInfo destinationOrderInfo = new TradingSupportReference.DestinationOrderInfo();
destinationOrderInfo.BlotterId = workingOrderRow.BlotterId;
destinationOrderInfo.DestinationId = destinationRow.DestinationId;
destinationOrderInfo.OrderedQuantity = sourceOrderQuantity - destinationOrderQuantity;
destinationOrderInfo.OrderTypeId = workingOrderRow.OrderTypeId;
destinationOrderInfo.SecurityId = workingOrderRow.SecurityId;
destinationOrderInfo.SettlementId = workingOrderRow.SettlementId;
destinationOrderInfo.SideCodeId = workingOrderRow.SideId;
destinationOrderInfo.TimeInForceCodeId = workingOrderRow.TimeInForceId;
destinationOrderInfo.WorkingOrderId = workingOrderRow.WorkingOrderId;
destinationOrders.Add(destinationOrderInfo);
}
}
}
// Create a channel to the middle tier.
TradingSupportReference.TradingSupportClient tradingSupportClient = new TradingSupportReference.TradingSupportClient(Guardian.Properties.Settings.Default.TradingSupportEndpoint);
tradingSupportClient.CreateDestinationOrders(destinationOrders.ToArray());
// At this point the client can be shut down gracefully.
tradingSupportClient.Close();
}
catch (FaultException <OptimisticConcurrencyFault> optimisticConcurrencyException)
{
// The record is busy.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
String.Format(FluidTrade.Core.Properties.Resources.OptimisticConcurrencyError,
optimisticConcurrencyException.Detail.TableName));
}
catch (FaultException <RecordNotFoundFault> recordNotFoundException)
{
// The record is busy.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
String.Format(FluidTrade.Core.Properties.Resources.RecordNotFoundError,
CommonConversion.FromArray(recordNotFoundException.Detail.Key),
recordNotFoundException.Detail.TableName));
}
catch (CommunicationException communicationException)
{
// Log communication problems.
this.Dispatcher.Invoke(DispatcherPriority.Normal,
(MessageDelegate)((string message) => { MessageBox.Show(message, Application.Current.MainWindow.Title); }),
communicationException.Message);
}
catch (Exception exception)
{
// Log communication problems.
EventLog.Error("{0}, {1}", exception.Message, exception.StackTrace);
}
}
/// <summary>
/// Creates a method plan from the parameters listed.
/// </summary>
/// <param name="methodElement">An XML node where the method and parameters are found.</param>
bool ExecuteMethod(XElement methodElement)
{
// Indicates the success or failure of an individual method execution.
bool isSuccessful = false;
try
{
// The client channel on which this method is to be executed is described by the 'client' attribute.
XAttribute clientAttribte = methodElement.Attribute("client");
String clientName = clientAttribte == null ? String.Empty : clientAttribte.Value;
ClientChannel client;
if (!this.clientTable.TryGetValue(clientName, out client))
{
throw new Exception(String.Format("The client {0} hasn't been defined", clientName == String.Empty ? "<default>" : clientName));
}
// Reflection is used here to find the method to be executed.
XAttribute methodNameAttribute = methodElement.Attribute("name");
String methodName = methodNameAttribute == null ? String.Empty : methodNameAttribute.Value;
MethodInfo methodInfo = client.ChannelType.GetMethod(methodNameAttribute.Value);
if (methodInfo == null)
{
throw new Exception(String.Format("The method {0} isn't part of the library", methodNameAttribute.Value));
}
// This will pull apart the XML that contains the parameters and construct a dictionary of method arguments.
Dictionary <String, XElement> parameterDictionary = new Dictionary <String, XElement>();
foreach (XElement parameterElement in methodElement.Elements("parameter"))
{
XAttribute parameterNameAttribute = parameterElement.Attribute("name");
parameterDictionary.Add(parameterNameAttribute.Value, parameterElement);
}
// This will correlate the parameter in the XML with the parameter of the actual method found through reflection and convert the parameter into the
// proper destination type. The end result is a parameter array that is compatible with a reflection call to the method specified in the XML.
ParameterInfo[] parameterInfoArray = methodInfo.GetParameters();
Object[] parameterArray = new Object[parameterInfoArray.Length];
for (int index = 0; index < parameterInfoArray.Length; index++)
{
ParameterInfo parameterInfo = parameterInfoArray[index];
XElement parameterElement;
if (parameterDictionary.TryGetValue(parameterInfo.Name, out parameterElement))
{
parameterArray[index] = ScriptLoader.ConvertElement(parameterInfo.ParameterType, parameterElement, Path.GetDirectoryName(this.FileName));
}
}
try
{
// At this point, the only thing left to do is call the method using the parsed parameters.
methodInfo.Invoke(client.ChannelObject, parameterArray);
}
catch (TargetInvocationException targetInvocationException)
{
// We use reflection to execute the method, so naturally we're going to get a reflection error. This will dig out the real reason that this
// method failed and throw it.
throw targetInvocationException.InnerException;
}
// The method invocation was successful at this point.
isSuccessful = true;
}
catch (FaultException <IndexNotFoundFault> indexNotFoundException)
{
// The record wasn't found.
Console.WriteLine(Teraque.Properties.Resources.IndexNotFoundError, indexNotFoundException.Detail.IndexName,
indexNotFoundException.Detail.TableName);
}
catch (FaultException <RecordNotFoundFault> recordNotFoundException)
{
// The record wasn't found.
Console.WriteLine(Teraque.Properties.Resources.RecordNotFoundError,
CommonConversion.FromArray(recordNotFoundException.Detail.Key),
recordNotFoundException.Detail.TableName);
}
catch (FaultException <ConstraintFault> constraintFaultException)
{
// The arguments weren't in the proper range.
Console.WriteLine(constraintFaultException.Detail.Message);
}
catch (FaultException <ArgumentFault> argumentFaultException)
{
// The arguments weren't in the proper range.
Console.WriteLine(argumentFaultException.Detail.Message);
}
catch (FaultException <FormatFault> formatFaultException)
{
// The arguments weren't in the proper range.
Console.WriteLine(formatFaultException.Detail.Message);
}
catch (FaultException <ExceptionDetail> exceptionDetail)
{
// This is a general purpose exception for debugging.
Console.WriteLine(exceptionDetail.Message);
}
// This is the final indication of whether the method was successful or not.
return(isSuccessful);
}