public void ProcessTransaction(OrderTransaction trans)
{
string comment;
if (trans.OrderId == 8)
{
comment = "";
}
IPositionInventory openPosition = OpenPositions.FirstOrDefault(p => p.GetSymbol() == trans.Symbol);
if (openPosition == null)
{
openPosition = OpenPosition(trans, PositionInventoryMethod.Lifo);
OpenPositions.Add(openPosition);
}
else
{
OrderTransaction transaction = ResolvePosition(openPosition, trans);
if (openPosition.BuysCount() == 0 && openPosition.SellsCount() == 0)
{
OpenPositions.Remove(openPosition);
}
}
}
public void NoOpenPositionsReturnNull()
{
OrderTransaction trans = new OrderTransaction();
trans.Symbol = "AAPL";
IPositionInventory openPosition = p.OpenPositions.FirstOrDefault(s => s.GetSymbol() == trans.Symbol);
Assert.IsNull(openPosition);
}
public void CanOpenPosition()
{
OrderTransaction trans = new OrderTransaction();
trans.Symbol = "AAPL";
trans.Direction = OrderDirection.Buy;
OrderTransactionProcessor processor = new OrderTransactionProcessor();
IPositionInventory openPosition = processor.OpenPosition(trans, PositionInventoryMethod.Fifo);
processor.OpenPositions.Add(openPosition);
Assert.IsTrue(processor.OpenPositions.Count > 0);
}
private OrderTransaction ResolvePosition(IPositionInventory position, OrderTransaction trans)
{
OrderTransaction buytrans = new OrderTransaction();
OrderTransaction selltrans = new OrderTransaction();
OrderTransaction l = new OrderTransaction();
if (trans.Direction == OrderDirection.Buy)
{
if (position.SellsCount() > 0)
{
selltrans = position.RemoveSell();
if (Math.Abs(trans.Quantity) == Math.Abs(selltrans.Quantity))
{
return(CreateTrade(trans, selltrans));
}
// if the buytrans qty is greater than the selltrans qty, split the buy
if (trans.Quantity > Math.Abs(selltrans.Quantity))
{
#region "Trans is Buy and buy greater than sell"
var unitcost = Math.Abs(trans.Amount / trans.Quantity);
// split the (buy)trans to equalize with the selltrans quantity
l = CopyTransaction(trans);
l.Quantity = trans.Quantity + selltrans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
buytrans = CopyTransaction(trans);
buytrans.Quantity = Math.Abs(selltrans.Quantity);
buytrans.Amount = unitcost * buytrans.Quantity * -1;
buytrans.Net = buytrans.Amount + buytrans.Commission + buytrans.Fees;
CreateTrade(buytrans, selltrans);
return(ResolvePosition(position, l));
#endregion
}
else
{
#region "Trans is Buy and sell greater than buy"
var unitcost = Math.Abs(selltrans.Amount / selltrans.Quantity);
// Split the sell
l = CopyTransaction(selltrans);
l.Quantity = selltrans.Quantity + trans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
// split the sell. The Sell gets no ICF
selltrans.Quantity = selltrans.Quantity - l.Quantity; // sell qty is negative
selltrans.Amount = unitcost * selltrans.Quantity * -1;
selltrans.Net = selltrans.Amount + selltrans.Commission + selltrans.Fees;
CreateTrade(trans, selltrans);
return(ResolvePosition(position, l));
#endregion
}
}
else
{
position.Add(trans);
}
}
else
{
if (position.BuysCount() > 0)
{
buytrans = position.RemoveBuy();
if (Math.Abs(trans.Quantity) == Math.Abs(buytrans.Quantity))
{
return(CreateTrade(buytrans, trans));
}
Decimal unitcost = 0;
if (Math.Abs(trans.Quantity) > buytrans.Quantity)
{
#region "Trans is sell and sell is greater than buy"
unitcost = Math.Abs(trans.Amount / trans.Quantity);
// split the sell, buytrans keeps the IFC
l = CopyTransaction(trans);
l.Quantity = trans.Quantity + buytrans.Quantity;
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
selltrans = CopyTransaction(trans);
selltrans.Quantity = selltrans.Quantity - l.Quantity;
selltrans.Amount = unitcost * selltrans.Quantity * -1;
selltrans.Net = selltrans.Amount + selltrans.Commission + selltrans.Fees;
CreateTrade(buytrans, selltrans);
return(ResolvePosition(position, l));
#endregion
}
else
{
#region "Trans is sell and buy is greater than sell"
unitcost = Math.Abs(buytrans.Amount / buytrans.Quantity);
// split the (buy)trans to equalize with the selltrans quantity
l = CopyTransaction(buytrans);
l.Quantity = buytrans.Quantity + trans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
buytrans.Quantity = buytrans.Quantity - l.Quantity;
buytrans.Amount = unitcost * buytrans.Quantity * -1;
buytrans.Net = buytrans.Amount + buytrans.Commission + buytrans.Fees;
CreateTrade(buytrans, trans);
return(ResolvePosition(position, l));
#endregion
}
}
else
{
position.Add(trans);
}
}
return(l);
}
private OrderTransaction ResolvePosition(IPositionInventory position, OrderTransaction trans)
{
OrderTransaction buytrans = new OrderTransaction();
OrderTransaction selltrans = new OrderTransaction();
OrderTransaction l = new OrderTransaction();
if (trans.Direction == OrderDirection.Buy)
{
if (position.SellsCount() > 0)
{
selltrans = position.RemoveSell();
if (Math.Abs(trans.Quantity) == Math.Abs(selltrans.Quantity))
{
return CreateTrade(trans, selltrans);
}
// if the buytrans qty is greater than the selltrans qty, split the buy
if (trans.Quantity > Math.Abs(selltrans.Quantity))
{
#region "Trans is Buy and buy greater than sell"
var unitcost = Math.Abs(trans.Amount / trans.Quantity);
// split the (buy)trans to equalize with the selltrans quantity
l = CopyTransaction(trans);
l.Quantity = trans.Quantity + selltrans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
buytrans = CopyTransaction(trans);
buytrans.Quantity = Math.Abs(selltrans.Quantity);
buytrans.Amount = unitcost * buytrans.Quantity * -1;
buytrans.Net = buytrans.Amount + buytrans.Commission + buytrans.Fees;
CreateTrade(buytrans, selltrans);
return ResolvePosition(position, l);
#endregion
}
else
{
#region "Trans is Buy and sell greater than buy"
var unitcost = Math.Abs(selltrans.Amount / selltrans.Quantity);
// Split the sell
l = CopyTransaction(selltrans);
l.Quantity = selltrans.Quantity + trans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
// split the sell. The Sell gets no ICF
selltrans.Quantity = selltrans.Quantity - l.Quantity; // sell qty is negative
selltrans.Amount = unitcost * selltrans.Quantity * -1;
selltrans.Net = selltrans.Amount + selltrans.Commission + selltrans.Fees;
CreateTrade(trans, selltrans);
return ResolvePosition(position, l);
#endregion
}
}
else
{
position.Add(trans);
}
}
else
{
if (position.BuysCount() > 0)
{
buytrans = position.RemoveBuy();
if (Math.Abs(trans.Quantity) == Math.Abs(buytrans.Quantity))
{
return CreateTrade(buytrans, trans);
}
Decimal unitcost = 0;
if (Math.Abs(trans.Quantity) > buytrans.Quantity)
{
#region "Trans is sell and sell is greater than buy"
unitcost = Math.Abs(trans.Amount / trans.Quantity);
// split the sell, buytrans keeps the IFC
l = CopyTransaction(trans);
l.Quantity = trans.Quantity + buytrans.Quantity;
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
selltrans = CopyTransaction(trans);
selltrans.Quantity = selltrans.Quantity - l.Quantity;
selltrans.Amount = unitcost * selltrans.Quantity * -1;
selltrans.Net = selltrans.Amount + selltrans.Commission + selltrans.Fees;
CreateTrade(buytrans, selltrans);
return ResolvePosition(position, l);
#endregion
}
else
{
#region "Trans is sell and buy is greater than sell"
unitcost = Math.Abs(buytrans.Amount / buytrans.Quantity);
// split the (buy)trans to equalize with the selltrans quantity
l = CopyTransaction(buytrans);
l.Quantity = buytrans.Quantity + trans.Quantity; // sell quantity will be negative
l.Amount = unitcost * l.Quantity * -1;
l.Commission = 0;
l.Fees = 0;
l.Interest = 0;
l.Net = l.Amount;
buytrans.Quantity = buytrans.Quantity - l.Quantity;
buytrans.Amount = unitcost * buytrans.Quantity * -1;
buytrans.Net = buytrans.Amount + buytrans.Commission + buytrans.Fees;
CreateTrade(buytrans, trans);
return ResolvePosition(position, l);
#endregion
}
}
else
{
position.Add(trans);
}
}
return l;
}
