internal StgSizeOrder(IStgAmtOrder childOrder, InstrumentSize value, Price price, IOrderRouteMapper routeMapper)
: base(childOrder.Account, value, false)
{
// Used for TypeConversion
// Some check
if (childOrder.ParentOrder != null)
throw new ApplicationException("This order has a parent order and can no longer be converted.");
this.IsTypeConverted = true;
setInitialValues(routeMapper);
this.price = price;
this.ChildOrders.Add(childOrder);
childOrder.Approve();
//this.CommissionDetails = childOrder.CommissionDetails;
this.exRate = childOrder.ExRate;
Validate();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="account">User account</param>
/// <param name="childOrder">Child order to create for this stichting order</param>
/// <param name="routeMapper">Route information</param>
public StgAmtOrder(IAccountTypeInternal account, IAggregateAmtOrder childOrder, IOrderRouteMapper routeMapper)
: base(account, (IOrderAmountBased)childOrder)
{
setInitialValues(routeMapper);
}
private void setInitialValues(IOrderRouteMapper routeMapper)
{
this.Route = routeMapper.GetRoute(this);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="account">User account</param>
/// <param name="value">Value of the order</param>
/// <param name="tradedInstrument">The traded instrument</param>
/// <param name="routeMapper">Route information</param>
public StgAmtOrder(IAccountTypeInternal account, Money value, IInstrument tradedInstrument, IOrderRouteMapper routeMapper)
: base(account, value, tradedInstrument)
{
setInitialValues(routeMapper);
setServiceChargeForAmountBasedOrder();
}
public virtual IStgSizeOrder ConvertBondOrder(Price price, DateTime settlementDate, IOrderRouteMapper routeMapper)
{
if (TradedInstrument.SecCategory.Key != SecCategories.Bond)
throw new ApplicationException("This is not a bond order.");
IBond bond = (IBond)TradedInstrument;
if (bond.DoesPayInterest)
{
// Calculate backwards the number of bonds
InstrumentSize value = bond.CalculateSizeBackwards(Amount, price, settlementDate);
StgSizeOrder convertedOrder = new StgSizeOrder(this, value, price, routeMapper);
AccruedInterestDetails calc = bond.AccruedInterest(value, settlementDate, null);
if (calc.IsRelevant)
convertedOrder.AccruedInterest = calc.AccruedInterest;
return convertedOrder;
}
else
return (IStgSizeOrder)this.Convert(price, routeMapper);
}
public new virtual ISecurityOrder Convert(Price price, IOrderRouteMapper routeMapper)
{
InstrumentSize value = Amount.CalculateSize(price);
return new StgSizeOrder(this, value, price, routeMapper);
}
public new virtual ISecurityOrder Convert(Price price, IOrderRouteMapper routeMapper)
{
Money value = this.Value.CalculateAmount(price);
return new StgAmtOrder(this, value);
}
private static OrderSearchKey addToList(Order newOrder, IOrderRouteMapper routeMapper, bool aggrOnStg, bool netting)
{
int index;
OrderSearchKey SearchKey = new OrderSearchKey(newOrder, netting);
if (!getKeyFromAggregatedOrders(ref SearchKey))
{
if (!(newOrder.parentOrder == null))
{
aggregatedOrders.Add(SearchKey, newOrder.parentOrder);
}
else
{
switch (newOrder.OrderType)
{
case OrderTypes.Monetary:
if (aggrOnStg)
{
if (netting)
aggregatedOrders.Add(SearchKey, new StgMonetaryOrder((IStgMonetaryOrder)newOrder));
else
aggregatedOrders.Add(SearchKey, new StgMonetaryOrder(getClearingAccount(newOrder), (IAggregateMonetaryOrder)newOrder, routeMapper));
}
else
aggregatedOrders.Add(SearchKey, new AggregateMonetaryOrder(getClearingAccount(newOrder), (IMonetaryOrder)newOrder));
break;
case OrderTypes.SizeBased:
if (aggrOnStg)
{
if (netting)
aggregatedOrders.Add(SearchKey, new StgSizeOrder((IStgSizeOrder)newOrder));
else
aggregatedOrders.Add(SearchKey, new StgSizeOrder(getClearingAccount(newOrder), (IAggregateSizeOrder)newOrder, routeMapper));
}
else
aggregatedOrders.Add(SearchKey, new AggregateSizeOrder(getClearingAccount(newOrder), (IOrderSizeBased)newOrder));
break;
default:
//OrderTypes.AmountBased:
if (aggrOnStg)
{
if (netting)
aggregatedOrders.Add(SearchKey, new StgAmtOrder((IStgAmtOrder)newOrder));
else
aggregatedOrders.Add(SearchKey, new StgAmtOrder(getClearingAccount(newOrder), (IAggregateAmtOrder)newOrder, routeMapper));
}
else
aggregatedOrders.Add(SearchKey, new AggregateAmtOrder(getClearingAccount(newOrder), (IOrderAmountBased)newOrder));
break;
}
}
aggregatedOrderKeys.Add(SearchKey);
}
else
{
// return same Key -> stored in collection
int i = aggregatedOrderKeys.IndexOf(SearchKey);
aggregatedOrderKeys[i] = SearchKey;
}
return SearchKey;
}
public static IList<IOrder> AggregateOrdersForStichting(IList<IOrder> aggregateUnApprovedStgOrders, IList<IOrder> unStgAggregatedApprovedOrders, IOrderRouteMapper routeMapper, out string message)
{
aggregatedOrders = new Dictionary<OrderSearchKey, IOrder>();
aggregatedOrderKeys = new List<OrderSearchKey>();
IList<IOrder> result = new List<IOrder>();
OrderSearchKey SearchKey = null;
//IList unStgAggregatedApprovedOrders = new Order.DataAccessLayer().GetUnAggregatedOrders(true);
int count = 0;
if (unStgAggregatedApprovedOrders == null || unStgAggregatedApprovedOrders.Count == 0)
{
message = "";
return null;
}
checkAggregateOrders(aggregateUnApprovedStgOrders, false);
foreach (Order newOrder in unStgAggregatedApprovedOrders)
{
if (newOrder.parentOrder == null)
{
if (newOrder.Approved)
{
SearchKey = addToList(newOrder, routeMapper, true, false);
((IOrder)aggregatedOrders[SearchKey]).ChildOrders.Add(newOrder);
SearchKey.Updated = true;
}
else
count++;
}
}
message = "";
if (count > 0)
message = string.Format("{0} orders could not be aggregated since they were not approved.", count.ToString());
//saveAggregatedOrders();
IStgOrder orderToSave;
for (int i = 0; i < aggregatedOrderKeys.Count; i++)
{
OrderSearchKey key = (OrderSearchKey)aggregatedOrderKeys[i];
if (key.Updated)
{
orderToSave = (IStgOrder)aggregatedOrders[key];
// Calculate Service Charge
if (((IOrder)orderToSave).OrderType == OrderTypes.AmountBased)
{
StgAmtOrder o = (StgAmtOrder)orderToSave;
o.setServiceChargeForAmountBasedOrder();
}
((IOrder)orderToSave).Validate();
result.Add((IOrder)orderToSave);
}
}
return result;
}