private void setupNewOrder(Order.OrderType id)
{
if (curOrder != null)
{
curOrder.Cleanup();
}
curOrder = orderDict[id];
curOrder.PrepareForInput();
}
public void OrderButtonClicked(Order.OrderType orderId)
{
if (dead)
{
return;
}
newOrderId = orderId;
shouldSetupNewOrder = true;
InputManager.Instance.OnRightMouseUp -= hideOrders;
displayOrders(false);
}
public void PlaceOrder(BasePlayer player, int rate, int qty, Order.OrderType orderType)
{
if (CanOrder())
{
if (orderType == Order.OrderType.Buy)
{
playerBussinessManager.IssueBuyOrder(player, rate, qty);
}
else
{
playerBussinessManager.IssueSellOrder(player, rate, qty);
}
}
}
public override void PlaceOrder()
{
int qtyMax = 0;
int rateMax = int.MaxValue;
bool found = false;
Order.OrderType orderType = Order.OrderType.NotSet;
foreach (Order order in playerBussinessManager.book.ordersList)
{
if (order.rate < rateMax && order.orderStatus != Order.OrderStatus.Executed)
{
found = true;
qtyMax = order.number;
rateMax = order.rate;
orderType = order.orderType == Order.OrderType.Buy ? Order.OrderType.Sell : Order.OrderType.Buy;
}
}
if (found)
{
PlaceOrder(this, rateMax + 1, qtyMax + 10, orderType);
}
}
private void buttonSend_Click(object sender, EventArgs e)
{
try
{
bool detectedErrors = false;
if (string.IsNullOrEmpty(txtClOrdID.Text))
{
errorProvider.SetIconPadding(txtClOrdID, 4);
errorProvider.SetError(txtClOrdID, "ClOrdID must be specified");
detectedErrors = true;
}
if (!tradingManager.IsClientOrderIdUnique(txtClOrdID.Text))
{
errorProvider.SetIconPadding(txtClOrdID, 4);
errorProvider.SetError(txtClOrdID, "ClOrdID must be unique");
detectedErrors = true;
}
if (string.IsNullOrEmpty(cmbSymbol.Text))
{
errorProvider.SetIconPadding(cmbSymbol, 4);
errorProvider.SetError(cmbSymbol, "Symbol must be specified");
detectedErrors = true;
}
double price;
if (!double.TryParse(txtPrice.Text, NumberStyles.Currency, CultureInfo.InvariantCulture, out price))
{
errorProvider.SetIconPadding(txtPrice, 4);
errorProvider.SetError(txtPrice, "Price must be specified as correct number");
detectedErrors = true;
}
double quantity;
if (!double.TryParse(txtQuantity.Text, NumberStyles.Integer, CultureInfo.InvariantCulture, out quantity))
{
errorProvider.SetIconPadding(txtQuantity, 4);
errorProvider.SetError(txtQuantity, "Quantity must be specified as correct number");
detectedErrors = true;
}
if (detectedErrors)
{
return;
}
Order order;
if (null == orderToModify)
{
Order.OrderType orderType = (Order.OrderType)Enum.Parse(typeof(Order.OrderType), cmbOrderType.Text);
Order.OrderSide orderSide = (Order.OrderSide)Enum.Parse(typeof(Order.OrderSide), cmbSide.Text);
order = new Order(txtClOrdID.Text, orderType, orderSide, cmbSymbol.Text);
order.ClientOrderID = txtClOrdID.Text;
if (!string.IsNullOrEmpty(cmbCurrency.Text))
{
order.Currency = cmbCurrency.Text;
}
}
else
{
order = orderToModify;
}
if (!string.IsNullOrEmpty(txtText.Text))
{
order.Text = txtText.Text;
}
order.TransactTime = DateTime.Now;
order.Quantity = double.Parse(txtQuantity.Text, System.Globalization.CultureInfo.InvariantCulture);
if (Order.OrderType.Market != order.Type && Order.OrderType.ForeignExchangeMarketOrder != order.Type)
{
order.Price = price;
}
if (null == orderToModify)
{
tradingManager.SendNewOrder(order);
}
}
catch (Exception ex)
{
logger_.LogError("Cannot Send Order: " + ex.Message);
Trace.TraceError("Cannot Send Order: " + ex.Message);
MessageBox.Show(this, ex.Message, "Cannot Send Order", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
txtClOrdID.Text = TradingManager.GetNextClientOrderID();
}
//Sends an alert to the web service for the mobile app
private void SendExecutionAlertToServer(string orderID, Orders.Status OrderStatus, string symbol, DateTime ExecTime,
Orders.Side Side, int Quantity, double EntryPrice, Order.OrderType OrderType,
Order.Expiration Expires, double Limit)
{
string key = "ALERT|" + Convert.ToString(ExecTime) + "|ORDER|" + symbol + "|" + orderID;
string data = orderID + "|" + Orders.StatusToString(OrderStatus) + "|" + symbol + "|" +
Convert.ToString(ExecTime) + "|" + Orders.SideToString(Side) + "|" +
Convert.ToString(Quantity) + "|" + Convert.ToString(EntryPrice) + "|" +
Order.OrderTypeToString(OrderType) + "|" + Order.ExpirationToString(Expires) + "|" +
Convert.ToString(Limit);
try
{
svc.SetUserData(frmMain2.ClientId, frmMain2.ClientPassword, frmMain2.LicenseKey, key, data);
}
catch (Exception)
{
return;
}
}
//#############################
//WARNING! Example code only!
//Your order entry API is responsible for returning order status events to update the portfolio!
//#############################
//Call this routine when your order entry API returns a fill, cancel, reject, etc. message
//If the orderID is not found, it is created
//Orderid, status, time, symbol, type, qty, entry, last, $ gain, % gain
public void ExecuteOrder(string orderID, Orders.Status OrderStatus, string symbol,
DateTime ExecTime, Orders.Side Side, int Quantity, double EntryPrice,
Order.OrderType OrderType, Order.Expiration Expires, double Limit)
{
//Details for the order including order type, expiration and limit price (if not market)
string details;
if (OrderType != Order.OrderType.Market)
{
details = Order.OrderTypeToString(OrderType) + " (" + Convert.ToString(Limit) + ") " +
Order.ExpirationToString(Expires);
}
else
{
details = Order.OrderTypeToString(OrderType) + " " + Order.ExpirationToString(Expires);
}
if ((DateTime.Compare(ExecTime, DateTime.MinValue) != 0) |
(DateTime.Compare(ExecTime, Convert.ToDateTime("12:00:00 AM")) == 0))
{
ExecTime = DateTime.Now; //Time must be valid
}
//Try to find the order to update it
for (int n = 0; n <= m_PortfolioGrid.Rows.Count - 1; n++)
{
if (m_PortfolioGrid.Rows[n].Cells["orderID"].Value.ToString().ToLower() != orderID.ToLower())
{
continue;
}
if (OrderStatus != Orders.Status.Unknown)
{
m_PortfolioGrid.Rows[n].Cells["Status"].Value = Orders.StatusToString(OrderStatus);
}
if (OrderType != Order.OrderType.Unknown)
{
m_PortfolioGrid.Rows[n].Cells["Details"].Value = details;
}
if (symbol != "")
{
m_PortfolioGrid.Rows[n].Cells["symbol"].Value = symbol;
}
if (Side != Orders.Side.Unknown)
{
m_PortfolioGrid.Rows[n].Cells["Type"].Value = Orders.SideToString(Side);
}
if (Quantity != 0)
{
m_PortfolioGrid.Rows[n].Cells["Qty"].Value = Quantity;
}
if (EntryPrice != 0.0)
{
m_PortfolioGrid.Rows[n].Cells["Entry"].Value = EntryPrice;
}
//Send an alert
SendExecutionAlertToServer(orderID, OrderStatus, symbol, ExecTime, Side, Quantity, EntryPrice, OrderType,
Expires, Limit);
//Speak the order change 'TODO: optional
string text = Orders.StatusToString(OrderStatus);
//m_frmMain.Speak("an order has been updated to," + text + ",for,symbol,[" + symbol + "]");
return;
}
//Couldn't find the order so add it
try
{
m_PortfolioGrid.Rows.Add(new object[]
{
orderID, Orders.StatusToString(OrderStatus), details, ExecTime, symbol,
Orders.SideToString(Side), Quantity, EntryPrice
});
//Send an alert
SendExecutionAlertToServer(orderID, OrderStatus, symbol, ExecTime, Side, Quantity, EntryPrice, OrderType,
Expires, Limit);
////Speak the order 'TODO: optional
//switch (Side)
//{
// case Orders.Side.LongSide:
// m_frmMain.Speak("a buy order has been submitted,[" + Convert.ToString(Quantity) + "],shares of,symbol,[" +
// symbol + "]");
// break;
// case Orders.Side.ShortSide:
// m_frmMain.Speak("a sell order has been submitted,[" + Convert.ToString(Quantity) +
// "]symbol,shares of,symbol,[" + symbol + "]");
// break;
//}
}
catch (Exception)
{
//Form was closing when adding an order to the grid
}
UpdatePortolioScreen(); //Refresh the data grid view
// Send an update to twitter, if requested
//if (frmMain2.GInstance.TweetTrades)
//{
// string trade = Side.ToString().Replace("Side", "") + " " + symbol + " @ " + EntryPrice; // TODO: change message as desired
// frmMain2.GInstance.SendTweet(trade);
//}
}
public MobileBuilder WithOrderType(Order.OrderType withOrderType)
{
orderType = withOrderType;
return(this);
}
public void Create(ItemType itemType, long blockIndex, Order.OrderType orderType)
{
ITradableItem tradableItem;
Guid itemId = new Guid("15396359-04db-68d5-f24a-d89c18665900");
switch (itemType)
{
case ItemType.Consumable:
tradableItem = ItemFactory.CreateItemUsable(
_tableSheets.ConsumableItemSheet.First,
itemId,
0);
break;
case ItemType.Costume:
tradableItem = ItemFactory.CreateCostume(
_tableSheets.CostumeItemSheet.First,
itemId);
break;
case ItemType.Equipment:
tradableItem = ItemFactory.CreateItemUsable(
_tableSheets.EquipmentItemSheet.First,
itemId,
0);
break;
case ItemType.Material:
var tradableMaterialRow = _tableSheets.MaterialItemSheet.OrderedList
.First(row => row.ItemSubType == ItemSubType.Hourglass);
tradableItem = ItemFactory.CreateTradableMaterial(tradableMaterialRow);
itemId = tradableItem.TradableId;
break;
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
var currency = new Currency("NCG", 2, minter: null);
Guid orderId = new Guid("6d460c1a-755d-48e4-ad67-65d5f519dbc8");
Order order = OrderFactory.Create(
Addresses.Admin,
Addresses.Blacksmith,
orderId,
new FungibleAssetValue(currency, 1, 0),
tradableItem.TradableId,
blockIndex,
tradableItem.ItemSubType,
1
);
Assert.Equal(orderType, order.Type);
Assert.Equal(blockIndex, order.StartedBlockIndex);
Assert.Equal(currency * 1, order.Price);
Assert.Equal(Addresses.Admin, order.SellerAgentAddress);
Assert.Equal(Addresses.Blacksmith, order.SellerAvatarAddress);
Assert.Equal(orderId, order.OrderId);
Assert.Equal(itemId, order.TradableId);
if (orderType == Order.OrderType.Fungible)
{
Assert.Equal(1, ((FungibleOrder)order).ItemCount);
}
}
