private static void SQ_OrderManager_NewOrder(OrderEventArgs args)
{
Order order;
if (Map.SQ_OQ_Order.ContainsKey(args.Order))
{
order = (Map.SQ_OQ_Order[args.Order] as Order);
}
else
{
order = new Order(args.Order);
Map.OQ_SQ_Order[order] = args.Order;
Map.SQ_OQ_Order[args.Order] = order;
}
OpenQuant.orders.Add(order);
}
private void Combos_Delete(object sender, OrderEventArgs e)
{
_orderComboRepository.Remove(_orderComboRepository.Get(e.Id));
_orderComboRepository.Save();
_viewModel.CombosSource.Orders.Remove(_viewModel.CombosSource.Orders.First(x => x.Id == e.Id));
}
private void Offals_Delete(object sender, OrderEventArgs e)
{
_orderDetailRepository.Remove(_orderDetailRepository.Get(e.OrderDetailId));
_orderDetailRepository.Save();
_viewModel.OffalsSource.Orders.Remove(_viewModel.OffalsSource.Orders.First(x => x.OrderDetailId == e.OrderDetailId));
}
private void OnOrderUpdate(object sender, OrderEventArgs e)
{
if (e.Order.Account.Strategies.Count > 0)
{
AtmStrategy atmStrategy;
StrategyBase stratbase;
lock (e.Order.Account.Strategies)
{
stratbase = e.Order.Account.Strategies.FirstOrDefault(s => { lock (s.Orders) return(s.Orders.FirstOrDefault(order => order == e.Order) != null); });
atmStrategy = stratbase as AtmStrategy;
}
if (atmStrategy != null)
{
Print(atmStrategy.Template + " " + atmStrategy.Id + " " + atmStrategy.Name + " " + e.Order.Name + " " + e.OrderState + " " + e.Order.OrderType.ToString() + " " + e.Order.OrderId);
Print(stratbase.Id);
Print("");
bool newATM = true;
foreach (ATMStrat strat in ATMStrats.Values)
{
if (strat.Id == atmStrategy.Id.ToString())
{
newATM = false;
}
}
if (newATM)
{
ATMStrats.Add(atmStrategy.Id.ToString(), new ATMStrat(atmStrategy.Id.ToString()));
}
// Entry Submitted
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Entry" && e.OrderState == OrderState.Submitted && e.Order.OrderId != null && e.Order.IsShort)
{
Print("ATM1 entered short");
shortEntry = e.Order;
longEntry = null;
ATMStrats[atmStrategy.Id.ToString()].Entry = e.Order;
}
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Entry" && e.OrderState == OrderState.Submitted && e.Order.OrderId != null && e.Order.IsLong)
{
Print("ATM1 entered long");
longEntry = e.Order;
shortEntry = null;
ATMStrats[atmStrategy.Id.ToString()].Entry = e.Order;
}
// Entry Filled
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Entry" && e.OrderState == OrderState.Filled && e.Order.OrderId != null && e.Order.IsShort)
{
shortEntryPrice = e.AverageFillPrice;
ATMStrats[atmStrategy.Id.ToString()].Entry = e.Order;
}
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Entry" && e.OrderState == OrderState.Filled && e.Order.OrderId != null && e.Order.IsLong)
{
longEntryPrice = e.AverageFillPrice;
ATMStrats[atmStrategy.Id.ToString()].Entry = e.Order;
}
// Stop Submitted
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Stop1" && e.OrderState == OrderState.Submitted && e.Order.OrderId != null && e.Order.IsLong)
{
Print("Stop assigned");
shortExit = e.Order;
longExit = null;
ATMStrats[atmStrategy.Id.ToString()].Exit = e.Order;
}
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Stop1" && e.OrderState == OrderState.Submitted && e.Order.OrderId != null && e.Order.IsShort)
{
Print("Stop assigned");
longExit = e.Order;
shortExit = null;
ATMStrats[atmStrategy.Id.ToString()].Exit = e.Order;
}
// Stop Filled
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Stop1" && e.OrderState == OrderState.Filled && e.Order.OrderId != null && e.Order.IsLong)
{
Print(String.Format("Realized PnL: {0}", shortExit.AverageFillPrice - shortEntryPrice));
shortExit = shortEntry = null;
ATMStrats[atmStrategy.Id.ToString()].Exit = e.Order;
}
if (atmStrategy.Template == "ATM1" && e.Order.Name == "Stop1" && e.OrderState == OrderState.Filled && e.Order.OrderId != null && e.Order.IsShort)
{
Print(String.Format("Realized PnL: {0}", longExit.AverageFillPrice - longEntryPrice));
longExit = longEntry = null;
ATMStrats[atmStrategy.Id.ToString()].Exit = e.Order;
}
}
// Check if Orders are in a twerminal state and set to null
if (shortEntry != null)
{
if (Order.IsTerminalState(shortEntry.OrderState))
{
shortEntry = null;
}
}
if (longEntry != null)
{
if (Order.IsTerminalState(longEntry.OrderState))
{
longEntry = null;
}
}
if (shortExit != null)
{
if (Order.IsTerminalState(shortExit.OrderState))
{
shortExit = null;
}
}
if (longExit != null)
{
if (Order.IsTerminalState(longExit.OrderState))
{
longExit = null;
}
}
}
}
public override void HandleOrder(OrderEventArgs args)
{
base.HandleOrder(args);
if (args.Handled)
{
return;
}
var source = args.Source;
var order = args.Order;
var segment = Segment;
/* example: buy all*/
/* example: buy (item) */
if (_buy.TryGetMatch(order, out var buyMatch))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
var items = segment.GetItemsAt(counter, buyMatch.Groups[1].Value, (i) => i is Gold).ToList();
var totalValue = (uint)items.Sum(i => i.ActualPrice * i.Amount);
if (totalValue > 0)
{
foreach (var item in items)
{
item.Delete();
}
var gold = new Gold()
{
Amount = totalValue,
};
gold.Move(counter, true, Segment);
SayTo(source, 6300350); /* Thank you for your business. */
}
else
{
SayTo(source, 6300264); /* There is nothing of value here. */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
}
/* example: appraise gem */
else if (_appraise.TryGetMatch(order, out var appraiseMatch))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
var item = segment.GetItemAt(counter, appraiseMatch.Groups[1].Value, (i) => i is Gold);
if (item != default(ItemEntity))
{
item.Identified = true;
var entries = new List <LocalizationEntry>();
item.GetDescriptionPrefix(entries);
item.GetDescription(entries);
item.GetDescriptionSuffix(entries);
var grammar = Name.IsPlural() ? "are" : "is";
var actualPrice = item.ActualPrice;
if (actualPrice > 0)
{
entries.Add(new LocalizationEntry(6300261, item.Name, grammar, actualPrice.ToString()));
}
else
{
entries.Add(new LocalizationEntry(6300262, item.Name, grammar));
}
SayTo(source, entries.ToArray());
}
else
{
SayTo(source, 6300263); /* Please put the item on the counter. */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
}
else if (_showPrices.TryGetMatch(order, out var _))
{
args.Handled = true;
if (AtCounter(source, out var _))
{
/* We Iterate all the items in the stock to keep index values consistent with list. */
if (_stock.Any(s => !s.IsEmpty))
{
SayTo(source, 6300382); /* I will sell to you .. */
for (int i = 0; i < _stock.Count; i++)
{
var stock = _stock[i];
/* Do not list empty entries. */
if (!stock.IsEmpty)
{
SayTo(source, 6300384, stock.Name.WithArticle(), stock.Cost.ToString(), (i + 1).ToString());
}
}
}
else
{
SayTo(source, 6300381); /* I don't have anything of interest. */
if (_stock.Any(s => !s.IsFull) && (_restockTimer == null || !_restockTimer.Running))
{
Log.Warn($"[{Segment.Name}] Shopkeeper '{Name}' at {Location} not restocking.");
}
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
}
/* example: sell scales */
else if (_sell.TryGetMatch(order, out var sellMatch))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
/* Try to find the stock by name if index does not resolve. */
if (!int.TryParse(sellMatch.Groups[1].Value, out var index))
{
var stockName = sellMatch.Groups[1].Value;
var matchedStock = _stock.FirstOrDefault(st => st.RespondsTo(stockName));
if (matchedStock != null)
{
index = _stock.IndexOf(matchedStock) + 1;
}
}
var stock = default(StockEntry);
if (index > 0 && index <= _stock.Count)
{
stock = _stock[index - 1];
}
if (stock != null && stock.CurrentQuantity > 0)
{
var gold = Segment.GetItemsAt(counter).OfType <Gold>().ToList();
if (gold.Any())
{
if (ConsumeFromLocation <Gold>(counter, (uint)stock.Cost))
{
var item = Sell(stock, source);
if (item != null)
{
if (!item.Deleted)
{
item.Move(counter, true, Segment);
}
SayTo(source, 6300350); /* Thank you for your business. */
}
}
else
{
SayTo(source, 6300243); /* Are you trying to be funny? */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300246); /* Please put some coins on the counter. */
}
else
{
SayTo(source, 6300247); /* Please put some coins on the ground. */
}
}
}
else
{
SayTo(source, 6300243); /* Are you trying to be funny? */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
}
}
void OrderToNoLossHandler(object sender, OrderEventArgs e)
{
TradesManager.DeleteEntryOrderLimit(e.Order.OrderID);
}
private static void SQ_OrderManager_OrderRemoved(OrderEventArgs args)
{
Order order = Map.SQ_OQ_Order[args.Order] as Order;
OpenQuant.orders.Remove(order);
Map.SQ_OQ_Order.Remove(args.Order);
Map.OQ_SQ_Order.Remove(order);
}
private void HandleOnOrderFailed(object sender, OrderEventArgs e)
{
}
public override void HandleOrder(OrderEventArgs args)
{
base.HandleOrder(args);
if (args.Handled)
{
return;
}
var source = args.Source;
var order = args.Order;
if (_teach.TryGetMatch(order, out var teachMatch))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
OnTeach(source);
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
if (order.Matches("yes", true))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
OnAccept(source);
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
if (order.Matches("no", true))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
OnDecline(source);
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
}
/// <summary>
/// Doesn't use becuse of finish-chain hero
/// </summary>
public void ReceiveFairyObject(object sender, OrderEventArgs args)
{
// не нужно ничего кузнецу, чтобы помочь курочке
}
private void MatchSellLogic(OrderEventArgs e)
{
foreach (Order curOrder in e.BuyBook)
{
if (e.Order.OrderType == "Market" && e.Order.Quantity > 0)
{
//Console.WriteLine("Match found..Generate Market Order Trade..");
int quantity = 0;
if (curOrder.Quantity >= e.Order.Quantity)
{
quantity = e.Order.Quantity;
}
else
{
quantity = curOrder.Quantity;
}
curOrder.Quantity = curOrder.Quantity - quantity;
e.Order.Quantity = e.Order.Quantity - quantity;
MatchedOrderArgs args = new MatchedOrderArgs(curOrder.OrderID, e.Order.OrderID, quantity, OrderBook.marketPrice);
// Console.WriteLine(curOrder.OrderID);
// Console.WriteLine(e.Order.OrderID);
tempDomain.onOrderMatched(args, curOrder.OrderID);
tempDomain.onOrderMatched(args, e.Order.OrderID);
Console.WriteLine("Market order matched at buy logic" + " at price" + OrderBook.marketPrice + " order ID's " + curOrder.OrderID.ToString() + " & " + e.Order.OrderID.ToString() + " matched quantity " + quantity);
}
else if (curOrder.Price >= e.Order.Price && e.Order.Quantity > 0)
{
Console.WriteLine("Match found..Generate Trade..");
int quantity;
if (curOrder.Quantity >= e.Order.Quantity)
{
quantity = e.Order.Quantity;
}
else
{
quantity = curOrder.Quantity;
}
curOrder.Quantity = curOrder.Quantity - quantity;
e.Order.Quantity = e.Order.Quantity - quantity;
lock (syc)
{
OrderBook.marketPrice = curOrder.Price;
}
MatchedOrderArgs args = new MatchedOrderArgs(curOrder.OrderID, e.Order.OrderID, quantity, OrderBook.marketPrice);
tempDomain.onOrderMatched(args, curOrder.OrderID);
tempDomain.onOrderMatched(args, e.Order.OrderID);
Thread thread = new Thread(tempDomain.OrderBook.StopToMarket);
thread.Start(new FuturesOrder("MSFT", "Stop", "B", 1, 1, "New"));//just instrument and ordertype are useful
Console.WriteLine(" Limit order matched at buy logic" + " at price " + curOrder.Price + " order ID's " + curOrder.OrderID.ToString() + " & " + e.Order.OrderID.ToString() + "matched Quantity " + quantity);
// Console.WriteLine(" Limit order matched at buy logic" + " at price" + OrderBook.marketPrice + " order ID's " + curOrder.OrderID.ToString() + " & " + e.Order.OrderID.ToString() + " current quote " + OrderBook.marketPrice);
}
else
{
break;
}
}
}
private void OrderManager_OrderDone(OrderEventArgs args)
{
this.metaStrategyBase.SetOrderDone(args);
}
private void OrderManager_OrderStatusChanged(OrderEventArgs args)
{
this.metaStrategyBase.SetOrderStatusChanged(args);
}
private void OrderManager_NewOrder(OrderEventArgs args)
{
this.metaStrategyBase.SetNewOrder(args);
}
public override void HandleOrder(OrderEventArgs args)
{
base.HandleOrder(args);
if (args.Handled)
{
return;
}
var source = args.Source;
var order = args.Order;
/* example: sell book */
if (_sell.TryGetMatch(order, out var sellMatch) && sellMatch.Groups[1].Value.Matches("book", true))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
var skillLevel = (int)source.GetSkillLevel(Skill.Magic) + 1;
var cost = (uint)(skillLevel * 100);
var segment = Segment;
var gold = segment.GetItemsAt(counter).OfType <Gold>().ToList();
if (gold.Any())
{
if (ConsumeFromLocation <Gold>(counter, cost))
{
new Spellbook(source)
.Move(counter, true, segment);
SayTo(source, 6300340); /* Don't go losing it again. */
}
else
{
SayTo(source, 6300339, cost); /* For you, I will sell one for {0} coins. */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300246); /* Please put some coins on the counter. */
}
else
{
SayTo(source, 6300247); /* Please put some coins on the ground. */
}
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
}
private void HandleOnContactDetailsError(object sender, OrderEventArgs e)
{
var step = unitOfWork.OrderStepRepository.Get(x => x.OrderId == e.OrderId && x.StepName == EnumStepName.ContactDetails).FirstOrDefault();
Run(step, EnumStatus.Fail);
}
private void MatchOpen(OrderEventArgs e)
{
bool ordersLeft = true;
double BuyQuantity = 0;
double SellQuantity = 0;
ArrayList matchedLimitOrders = new ArrayList();
ArrayList matchedMarketOrders = new ArrayList();
e.BuyBook.Reset();
e.SellBook.Reset();
e.BuyBook.MoveNext();
e.SellBook.MoveNext();
Order BuyOrder = e.BuyBook.Current as Order;
Order SellOrder = e.SellBook.Current as Order;
int quantityMatched;
while (true) //need to pull the orders off of the datastore
{
if (SellOrder.LimitPrice < BuyOrder.LimitPrice)
{
if (BuyOrder.Quantity < SellOrder.Quantity)
{
quantityMatched = BuyOrder.Quantity;
BuyQuantity += BuyOrder.Quantity;
BuyOrder.Quantity = 0;
FuturesOrder executedOrder1 = (FuturesOrder)BuyOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
//ExecutedOrders executedOrder1 = new ExecutedOrders(BuyOrder, quantityMatched, 0);
//BuyOrder.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder1);
SellOrder.Quantity = SellOrder.Quantity - quantityMatched;
FuturesOrder executedOrder2 = (FuturesOrder)SellOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
//ExecutedOrders executedOrder2 = new ExecutedOrders(SellOrder, quantityMatched, 0);
matchedLimitOrders.Add(executedOrder2);
if (ordersLeft = e.BuyBook.MoveNext() == false)
{
break;
}
BuyOrder = e.BuyBook.Current as Order;
}
else
{
quantityMatched = SellOrder.Quantity;
SellQuantity += SellOrder.Quantity;
SellOrder.Quantity = 0;
BuyOrder.Quantity = BuyOrder.Quantity - quantityMatched;
FuturesOrder executedOrder1 = (FuturesOrder)BuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = quantityMatched;
FuturesOrder executedOrder2 = (FuturesOrder)SellOrder.Clone();
executedOrder1.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder1);
//SellOrder.ExecutionQuantity = quantityMatched;
matchedLimitOrders.Add(executedOrder2);
if (e.SellBook.MoveNext() == false)
{
break;
}
SellOrder = e.SellBook.Current as Order;
}
}
else
{
break;
}
}
double openPrice = Math.Round((SellOrder.LimitPrice + BuyOrder.LimitPrice) / 2.0, 2);
e.BuyBook.ResetMktOrder();
e.SellBook.ResetMktOrder();
ordersLeft = true;
ordersLeft = e.BuyBook.MoveNextMktOrder();
if (ordersLeft == false)
{
e.SellBook.MoveNextMktOrder();
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as Order));
while (e.SellBook.MoveNextMktOrder())
{
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as Order));
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice));
return;
}
ordersLeft = e.SellBook.MoveNextMktOrder();
if (ordersLeft == false)
{
e.BuyBook.MoveNextMktOrder();
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as Order));
while (e.BuyBook.MoveNextMktOrder())
{
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as Order));
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice));
return;
}
Order MktBuyOrder = e.BuyBook.CurrentMktOrder as Order;
Order MktSellOrder = e.SellBook.CurrentMktOrder as Order;
int ordersMatched;
while (true)
{
if (MktBuyOrder.Quantity > MktSellOrder.Quantity)
{
ordersMatched = MktSellOrder.Quantity;
MktSellOrder.Quantity = 0;
//ExecutedOrders executedOrder1 = new ExecutedOrders(MktSellOrder, ordersMatched, openPrice);
MktBuyOrder.Quantity = MktBuyOrder.Quantity - ordersMatched;
FuturesOrder executedOrder1 = (FuturesOrder)MktSellOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
FuturesOrder executedOrder2 = (FuturesOrder)MktBuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
matchedMarketOrders.Add(executedOrder1);
matchedMarketOrders.Add(executedOrder2);
//ExecutedOrders executedOrder2 = new ExecutedOrders(MktBuyOrder, ordersMatched, openPrice);
//send executed order back
if (e.SellBook.MoveNextMktOrder() == false)
{
//do something with remaining Market Sell orders
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => e.BuyBook.ProcessOrder(MktBuyOrder));
while (e.BuyBook.MoveNextMktOrder())
{
e.BuyBook.ProcessOrder(e.BuyBook.CurrentMktOrder as FuturesOrder);
}
break;
}
}
else //(MktBuyOrder.Quantity < MktSellOrder.Quantity)
{
ordersMatched = MktBuyOrder.Quantity;
MktBuyOrder.Quantity = 0;
//ExecutedOrders executedOrder2 = new ExecutedOrders((e.SellBook.CurrentMktOrder as Order), ordersMatched, openPrice);
MktSellOrder.Quantity = MktSellOrder.Quantity - ordersMatched;
FuturesOrder executedOrder1 = (FuturesOrder)MktSellOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
FuturesOrder executedOrder2 = (FuturesOrder)MktBuyOrder.Clone(); //make copy so original order is not effected in case of partial fill
executedOrder1.ExecutionQuantity = ordersMatched;
matchedMarketOrders.Add(executedOrder1);
matchedMarketOrders.Add(executedOrder2);
//ExecutedOrders executedOrder1 = new ExecutedOrders(e.Order, ordersMatched, openPrice);
if (e.BuyBook.MoveNextMktOrder() == false)
{
//do something with remaining Market Buy orders
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => e.SellBook.ProcessOrder(MktSellOrder));
while (e.SellBook.MoveNextMktOrder())
{
e.SellBook.ProcessOrder(e.SellBook.CurrentMktOrder as FuturesOrder);
}
break;
}
}
}
LeafContainer.openPriceFound.Set();
Task.Factory.StartNew(() => processMatchedLimitOrders(matchedLimitOrders, openPrice, matchedMarketOrders));
}
private void HandleOnDeliveryError(object sender, OrderEventArgs e)
{
var step = unitOfWork.OrderStepRepository.Get(x => x.OrderId == e.OrderId && x.StepName == EnumStepName.ProcessDeliveryAppointment).FirstOrDefault();
Run(step, EnumStatus.Fail);
}
public override void HandleOrder(OrderEventArgs args)
{
base.HandleOrder(args);
if (args.Handled)
{
return;
}
var source = args.Source;
var order = args.Order;
/* example: show spells */
if (order.Matches("show spells", true))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
var skillLevel = source.GetSkillLevel(Skill.Magic);
var profession = source.Profession;
var spells = profession.GetSpells();
var available = spells.Where(st => st.SkillLevel <= skillLevel &&
!st.IsTaught(source)).ToList();
if (available.Any())
{
for (var i = 0; i < available.Count; i++)
{
SayTo(source, $"{i + 1}. {available[i].Name} - {available[i].Cost} coins.");
}
}
else
{
SayTo(source, 6300323); /* There are no spells I can teach you. */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
/* example: teach (spell name, index) */
if (_teach.TryGetMatch(order, out var teachMatch))
{
args.Handled = true;
if (AtCounter(source, out var counter))
{
if (teachMatch.Groups[1].Success)
{
var skillLevel = source.GetSkillLevel(Skill.Magic);
var profession = source.Profession;
var spells = profession.GetSpells();
var available = spells.Where(st => st.SkillLevel <= skillLevel &&
!st.IsTaught(source)).ToList();
if (available.Any())
{
/* Try to find the spell by name if index does not resolve. */
if (!int.TryParse(teachMatch.Groups[1].Value, out var index))
{
var spellName = teachMatch.Groups[1].Value;
var spell = available.FirstOrDefault(sp => sp.RespondsTo(spellName));
if (spell != null)
{
index = available.IndexOf(spell) + 1;
}
}
if (index > 0 && index <= available.Count)
{
var spell = available[index - 1];
var gold = Segment.GetItemsAt(counter).OfType <Gold>().ToList();
if (gold.Any())
{
var totalGold = gold.Sum(g => g.Amount);
var spellCost = (uint)spell.Cost;
if (totalGold >= spellCost && ConsumeFromLocation <Gold>(counter, spellCost))
{
foreach (var spellType in spell.Spells)
{
source.Spells.Learn(spellType);
}
SayTo(source, 6300325, spell.Name); /* You have learned the {0} spell. */
}
else
{
SayTo(source, 6300243); /* Are you trying to be funny? */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300246); /* Please put some coins on the counter. */
}
else
{
SayTo(source, 6300247); /* Please put some coins on the ground. */
}
}
}
else
{
SayTo(source, 6300321); /* That spell is not yet available to you. */
}
}
else
{
SayTo(source, 6300323); /* There are no spells I can teach you. */
}
}
else
{
SayTo(source, 6300324); /* I don't know what spell you mean. */
}
}
else
{
if (_counters.Any())
{
SayTo(source, 6300236); /* Please step up to a counter. */
}
else
{
SayTo(source, 6300237); /* Please stand closer to me. */
}
}
return;
}
}
}//Filled()
//
//
// *************************************************************
// **** OrderStateChanged() ****
// *************************************************************
/// <summary>
/// Called by the strategy hub when it recieves and order state change event from an orderbook
/// </summary>
/// <param name="orderEventArgs"></param>
public void OrderStateChanged(OrderEventArgs orderEventArgs)
{
Log.NewEntry(LogLevel.Major, "OrderStateChanged: Order State Updates : Not implemented yet");
}
//
// *************************************************************
// **** OrderSubmitted() ****
// *************************************************************
/// <summary>
/// Called by the strategy hub when it recieves confirmation of an order submission
/// </summary>
/// <param name="orderEventArgs"></param>
public void OrderSubmitted(OrderEventArgs orderEventArgs)
{
m_RiskManager.OrderBook(orderEventArgs);
}
//
//
private void OrderBook_OrderUpdated(object sender, EventArgs e)
{
OrderEventArgs orderEventArgs = (OrderEventArgs)e;
ProcessOrderEvent(orderEventArgs);
}
private List <OrderDetail> AddOffallabel(double poundWeight, OmsScaleWeighStatus status = OmsScaleWeighStatus.Success, OrderEventArgs e = null, string formattedDisplay = null, int quantity = 1)
{
if (status == OmsScaleWeighStatus.Success)
{
List <OrderDetail> orderDetails = new List <OrderDetail>();
for (int i = 0; i < quantity; i++)
{
var od = new OrderDetail
{
CustomerLocationId = e.LocationId,
OrderId = _viewModel.CurrentOrderId,
ProductId = e.ProductId,
SideTypeId = null,
Product = _productRepository.GetOffalProduct(e.ProductId)
};
orderDetails.Add(od);
}
_orderDetailRepository.AddRange(orderDetails);
_orderDetailRepository.Save();
_labelCreateService.ProduceCustomBagLabels(orderDetails, (double)poundWeight, _activeLabelType, _viewModel.ProcessDate
, null, new AnimalLabelsViewModel()
{
Name = orderDetails.FirstOrDefault().Product.EnglishDescription,
IsOrganic = false,
Species = null
});
DisplayScaleOutput(formattedDisplay ?? string.Empty);
return(orderDetails);
}
DisplayScaleOutput(String.Format("error reading scale. Scale Status: [{0}]", status), true);
return(null);
}
private void onOrderAdded(object sender, OrderEventArgs e)
{
this.displayAddedOrder(e.order);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnOrderAdded(object sender, OrderEventArgs e)
{
OrderViewModel viewModel = new OrderViewModel(e.Order, repositorys);
this.AllOrders.Add(viewModel);
}
