/// <summary>
/// Update this object based on another.
/// </summary>
/// <param name="obj">The object to draw updates from.</param>
public override void Update(GuardianObject obj)
{
WorkingOrder workingOrder = obj as WorkingOrder;
if (!workingOrder.Modified)
{
this.rowVersion = workingOrder.rowVersion;
this.modifiedTime = workingOrder.ModifiedTime;
this.securityId = workingOrder.SecurityId;
this.symbol = workingOrder.Symbol;
}
}
/// <summary>
/// Populates trading support records for the securities of each working order in a set.
/// </summary>
/// <param name="orders">The working orders to populate records for.</param>
/// <returns>The populated records.</returns>
protected virtual BaseRecord[] PopulateSecurityRecords(List <IMovableObject> orders)
{
BaseRecord[] records = new BaseRecord[orders.Count];
for (Int32 index = 0; index < orders.Count; ++index)
{
WorkingOrder order = orders[index] as WorkingOrder;
records[index] = new BaseRecord {
RowId = order.WorkingOrderId, RowVersion = order.RowVersion
};
}
return(records);
}
/// <summary>
/// Delete an set of working orders.
/// </summary>
/// <param name="workingOrders">The set of working orders.</param>
/// <returns>The actual bulk size used.</returns>
protected override Int32 Delete(List <GuardianObject> workingOrders)
{
Int32 attemptedBulkSize = workingOrders.Count;
Int32 actualBulkSize = attemptedBulkSize;
GuardianObject failedObject = null;
TradingSupportReference.WorkingOrderRecord[] records;
Dictionary <TradingSupportReference.WorkingOrderRecord, WorkingOrder> recordsToOrders =
new Dictionary <TradingSupportReference.WorkingOrderRecord, WorkingOrder>();
records = new TradingSupportReference.WorkingOrderRecord[workingOrders.Count];
// Convert the GuardianObjects to records we can push up to the server.
for (Int32 index = 0; index < records.Length; ++index)
{
WorkingOrder workingOrder = workingOrders[0] as WorkingOrder;
records[index] = new TradingSupportReference.WorkingOrderRecord();
workingOrder.PopulateRecord(records[index]);
recordsToOrders[records[index]] = workingOrder;
workingOrders.RemoveAt(0);
}
try
{
Int32 sentSize;
MethodResponseErrorCode response;
response = NetworkHelper.Attempt <MethodResponseErrorCode>(
(client, a) =>
client.DeleteWorkingOrder(a as TradingSupportReference.WorkingOrderRecord[]),
records,
true,
out sentSize);
if (sentSize < attemptedBulkSize)
{
actualBulkSize = sentSize;
}
if (!response.IsSuccessful)
{
foreach (ErrorInfo errorInfo in response.Errors)
{
// The bulk index is an index into the set we sent, which may be smaller than the set passed in.
failedObject = recordsToOrders[records[errorInfo.BulkIndex]];
// If the error's "just" a deadlock, add it to the retry list we can attempt it again.
if (errorInfo.ErrorCode == ErrorCode.RecordExists)
{
throw new IsSettledException(this.ToString() + " is settled");
}
// We can safely ignore not-found errors (we are deleting after all), but if the error's more severe, forget the whole
// thing and throw up the error.
else if (errorInfo.ErrorCode != ErrorCode.RecordNotFound)
{
GuardianObject.ThrowErrorInfo(response.Errors[0]);
}
}
}
}
catch (Exception exception)
{
// Any issues trying to communicate to the server are logged.
EventLog.Warning("{0}: {1}\n{2}", exception.GetType(), exception.Message, exception.StackTrace);
throw new DeleteException(failedObject, exception);
}
return(actualBulkSize);
}