public void changeState(String orderID, OrderState newState)
{
if(orders.ContainsKey(orderID))
((Order)orders[orderID]).State= newState;
if (orderChangedEvent != null)
orderChangedEvent((Order)orders[orderID]);
}
/// <summary>
/// Full Constructor
/// </summary>
/// <param name="orderId">The order Id assigned by TWS. Used to cancel or update the order.</param>
/// <param name="contract">Describes the contract for the open order.</param>
/// <param name="order">Gives the details of the open order.</param>
/// <param name="orderState">The openOrder() callback with the new OrderState() object will now be invoked each time TWS receives commission information for a trade.</param>
public OpenOrderEventArgs(int orderId, Contract contract, Order order, OrderState orderState)
{
OrderId = orderId;
Order = order;
Contract = contract;
OrderState = orderState;
}
public static QuickFix.Fields.OrdStatus c(OrderState s)
{
var val = s_ordState.Find(v => v.second == s);
if (val == null)
throw new Exception("Unmapped OrderState value : " + s.ToString());
return val.first;
}
public ResponseResult<OrderModel> Get(string orderId,OrderState order_state = OrderState.ALL, string optional_fields = "")
{
//OAuth oauth = new OAuth(Config._AppKey,Config._AppSecret);
var code = "121313"; //session_code
IJdClient client = new DefaultJdClient("http://gw.api.360buy.com/routerjson",
Config._AppKey, Config._AppSecret);
var request = new OrderGetRequest();
request.OptionalFields = optional_fields;
if (order_state != OrderState.ALL) //可能这里是要拼接所有的订单状态信息
{
request.OrderState = order_state.ToString();
}
request.OrderId = orderId;
var response= client.Execute(request, Config._SessionCode,DateTime.Now.ToLocalTime());
var model=new WrapOrderModel().WrapModel(response.Order);
return new ResponseResult<OrderModel>() {
Code= int.Parse(response.ErrCode),//TODO: string转为int可能存在错误
Result=model
};
}
public virtual void TakeToProcess()
{
if (State != OrderState.Draft)
throw new InvalidOperationException("Текущий статус заказа не позволяет взять его в работу");
State = OrderState.TakedToProcess;
}
public virtual void MarkExecuted()
{
if (State != OrderState.TakedToProcess)
throw new InvalidOperationException("Текущий статус заказа не позволяет отметить его выполненным");
State = OrderState.Executed;
}
public OrderPostProcessorStateHook(string purpose, Order order, OrderState orderState, Action<Order, ReporterPokeUnit> hook) {
this.Purpose = purpose;
this.Order = order;
this.OrderState = orderState;
this.Delegate = hook;
this.InvokedThusCanBeDeleted = false;
}
///<summary>
/// Parameterless OpenOrderEventArgs Constructor
///</summary>
public OpenOrderEventArgs()
{
OrderId = -1;
Order = new Order();
Contract = new Contract();
OrderState = new OrderState();
}
/// <summary>
/// Constructor from the API.
/// </summary>
/// <param name="src">The source.</param>
/// <exception cref="System.ArgumentNullException">src</exception>
protected MarketOrder(SerializableOrderListItem src)
{
src.ThrowIfNull(nameof(src));
PopulateOrderInfo(src);
LastStateChange = DateTime.UtcNow;
m_state = GetState(src);
}
/// <summary>
/// Try to update this order with a serialization object from the API.
/// </summary>
/// <param name="src"></param>
/// <param name="issuedFor">Whether the order was issued for a corporation or a
/// character.</param>
/// <param name="endedOrders"></param>
/// <returns></returns>
internal bool TryImport(EsiOrderListItem src, IssuedFor issuedFor,
ICollection <MarketOrder> endedOrders)
{
// Note that, before a match is found, all orders have been marked for deletion:
// m_markedForDeletion == true
// Checks whether ID is the same (IDs can be recycled ?)
if (!MatchesWith(src))
{
return(false);
}
// Prevent deletion
MarkedForDeletion = false;
// Update infos (if ID is the same it may have been modified either by the market
// or by the user [modify order] so we update the orders info that are changeable)
if (IsModified(src))
{
if (Item != null)
{
// If it is a buy order, escrow may have changed
var buyOrder = this as BuyOrder;
if (src.IsBuyOrder && buyOrder != null)
{
buyOrder.Escrow = src.Escrow;
}
UnitaryPrice = src.UnitaryPrice;
RemainingVolume = src.RemainingVolume;
Issued = src.Issued;
}
LastStateChange = DateTime.UtcNow;
m_state = OrderState.Modified;
}
else if (m_state == OrderState.Modified)
{
LastStateChange = DateTime.UtcNow;
m_state = OrderState.Active;
}
// Order is from a serialized object, so populate the missing info
if (Item == null)
{
PopulateOrderInfo(src, issuedFor);
}
OrderState state = GetState(src);
if (m_state == OrderState.Modified || state == m_state)
{
return(true);
}
// It has either expired or fulfilled
m_state = state;
LastStateChange = DateTime.UtcNow;
// Should we notify it to the user ?
if (state == OrderState.Expired || state == OrderState.Fulfilled)
{
endedOrders.Add(this);
}
return(true);
}
public OrderStateViewModel Create(OrderState orderState)
{
return(new OrderStateViewModel()
{
Id = orderState.Id,
Name = orderState.Name.GetLocalizationValue(),
Position = orderState.Position
});
}
/// <summary>
/// Constructor from the API.
/// </summary>
/// <param name="src">The source.</param>
/// <param name="character">The owning character.</param>
/// <exception cref="System.ArgumentNullException">src</exception>
protected MarketOrder(SerializableOrderListItem src, CCPCharacter character)
{
src.ThrowIfNull(nameof(src));
PopulateOrderInfo(src);
LastStateChange = DateTime.UtcNow;
m_character = character;
m_state = GetState(src);
}
public void Set(OrderState state)
{
if (state != Current)
{
Add(new OrderStateEntry {
Value = state, Changed = DateTime.UtcNow
});
}
}
void EWrapper.completedOrder(Contract contract, Order order, OrderState orderState)
{
var tmp = CompletedOrder;
if (tmp != null)
{
sc.Post(t => tmp(new CompletedOrderMessage(contract, order, orderState)), null);
}
}
public Order(SerializationInfo info, StreamingContext ctxt)
{
this.Customer = (Customer)info.GetValue("Customer", typeof(Customer));
this.Shop = (Shop)info.GetValue("Shop", typeof(Shop));
this.Items = (List<OrderItem>)info.GetValue("Items", typeof(List<OrderItem>));
this.TotalPrice = (decimal)info.GetValue("TotalPrice", typeof(decimal));
this.State = (OrderState)info.GetValue("State", typeof(OrderState));
this.Timestamps = (Dictionary<OrderState, DateTime>)info.GetValue("Timestamps", typeof(Dictionary<OrderState, DateTime>));
}
public Hashtable GetOptions(string name)
{
var options = new Hashtable();
if (name == "Notification sending frequency")
{
foreach (NotificationFrequency frequencyLevel in Enum.GetValues(typeof(NotificationFrequency)))
{
options.Add(((int)frequencyLevel).ToString(), GetNotificationFrequencyText(frequencyLevel));
}
}
else if (name == "Order state after export succeeded" || name == "Order state after export failed")
{
options.Add("", "Leave unchanged");
foreach (var state in OrderState.GetAllOrderStates())
{
options.Add(state.Id, state.Name);
}
}
else if (name == "Shop")
{
options.Add("", "Any");
var shops = Shop.GetShops();
foreach (var shop in shops)
{
options.Add(shop.Id, shop.Name);
}
}
else if (name == "Cart communication type")
{
options.Add(Constants.CartCommunicationType.None, Constants.CartCommunicationType.None);
options.Add(Constants.CartCommunicationType.Full, Constants.CartCommunicationType.Full);
options.Add(Constants.CartCommunicationType.OnlyOnOrderComplete, Constants.CartCommunicationType.OnlyOnOrderComplete);
}
else if (name == "Synchronize on event")
{
options.Add(Constants.UserCommunicationType.None, Constants.UserCommunicationType.None);
options.Add(Constants.UserCommunicationType.Full, Constants.UserCommunicationType.Full);
options.Add(Constants.UserCommunicationType.OrderSubmit2NewUsers, Constants.UserCommunicationType.OrderSubmit2NewUsers);
options.Add(Constants.UserCommunicationType.OrderSubmitAlways, Constants.UserCommunicationType.OrderSubmitAlways);
}
else if (name == "Type of user to sync")
{
options.Add(Constants.UserSyncType.None, Constants.UserSyncType.None);
options.Add(Constants.UserSyncType.All, Constants.UserSyncType.All);
options.Add(Constants.UserSyncType.LoginUsers, Constants.UserSyncType.LoginUsers);
options.Add(Constants.UserSyncType.ImpersonateUsers, Constants.UserSyncType.ImpersonateUsers);
}
else
{
foreach (var cacheLevel in Enum.GetNames(typeof(CacheLevel)))
{
options.Add(cacheLevel, cacheLevel);
}
}
return(options);
}
private ICollection <DeliveryOrder> GetOrdersWithState(OrderState state)
{
ICollection <DeliveryOrder> allOrders = orderRepository.RetrieveAllOrders();
ICollection <DeliveryOrder> readyOrders = allOrders
.Where(order => order.state == state)
.ToList();
return(readyOrders);
}
public OrderItem(int orderItemID, int quantity, MenuItem menuItem, int orderID, OrderState orderState, string comments)
{
OrderItemID = orderItemID;
Quantity = quantity;
MenuItem = menuItem;
OrderID = orderID;
OrderState = orderState;
Comments = comments;
}
public void SetState(OrderState state)
{
if (State.Next() != state)
{
throw new ArgumentException("setstate");
}
State = state;
}
/// <summary>
/// 获取相关订单数量
/// </summary>
/// <param name="state">订单状态</param>
/// <param name="ids">订单列表字符串</param>
/// <returns></returns>
public int GetOIDCount(OrderState state, string ids)
{
string cmd = @"SELECT count(1)
FROM [Orders] as o
where OrderState=" + (int)state + @"
and OID not in( " + ids + " )";
return((int)adao.ExcuteScalar(cmd, null));
}
private SqlCommand CommandUpdateOrder(int idComputer, string commentary, OrderState newStateOrder)
{
var commandUpdateError = new SqlCommand($"update [Order] set Commentary += @{PARAM_COMMENTARY}, OrderState = @{PARAM_STATE_ORDER} where ID = (select o.ID from [Order] o inner join Computer c on c.ID_Order = o.ID where c.ID = @{PARAM_COMPUTER})");
commandUpdateError.Parameters.AddWithValue(PARAM_COMMENTARY, commentary);
commandUpdateError.Parameters.AddWithValue(PARAM_COMPUTER, idComputer);
commandUpdateError.Parameters.AddWithValue(PARAM_STATE_ORDER, newStateOrder);
return(commandUpdateError);
}
void EWrapper.openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
var tmp = OpenOrder;
if (tmp != null)
{
sc.Post((t) => tmp(new OpenOrderMessage(orderId, contract, order, orderState)), null);
}
}
void EWrapper.openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
var tmp = OpenOrder;
if (tmp != null)
{
tmp(orderId, contract, order, orderState);
}
}
public LimitOrder(
string id,
DateTime createTime,
OrderState state,
ClientExtensions?clientExtensions,
OrderType type,
string instrument,
TimeInForce timeInForce,
DateTime?gtdTime,
OrderPositionFill positionFill,
OrderTriggerCondition triggerCondition,
TakeProfitDetails?takeProfitOnFill,
StopLossDetails?stopLossOnFill,
GuaranteedStopLossDetails?guaranteedStopLossOnFill,
TrailingStopLossDetails?trailingStopLossOnFill,
ClientExtensions?tradeClientExtensions,
string?fillingTransactionID,
DateTime?filledTime,
string?tradeOpenedID,
string?tradeReducedID,
ImmutableList <string>?tradeClosedIDs,
string?cancellingTransactionID,
DateTime?cancelledTime,
string?replacesOrderID,
string?replacedByOrderID,
decimal units,
decimal price)
: base(
id,
createTime,
state,
clientExtensions,
type,
instrument,
timeInForce,
gtdTime,
positionFill,
triggerCondition,
takeProfitOnFill,
stopLossOnFill,
guaranteedStopLossOnFill,
trailingStopLossOnFill,
tradeClientExtensions,
fillingTransactionID,
filledTime,
tradeOpenedID,
tradeReducedID,
tradeClosedIDs,
cancellingTransactionID,
cancelledTime,
replacesOrderID,
replacedByOrderID)
{
Units = units;
Price = price;
}
public void CompletePurchase(Nullable <DateTime> scheduledDelivery = null, Nullable <bool> bookTable = null)
{
IEnumerable <Restaurant> restaurants = _unitOfWork.ShoppingCartRepository
.Query()
.Where(sc => sc.UserProfileId == _id)
.Select(sc => sc.Restaurant)
.Distinct();
OrderState orderState = _unitOfWork.OrderStateRepository
.Get((os => os.Name == "UNPROCESSED")).First();
OrderType orderType = _unitOfWork.OrderTypeRepository
.Get(ot => ot.Name == "DELIVERY").First();
foreach (Restaurant restaurant in restaurants)
{
Order order = new Order()
{
CreatedAt = DateTime.Now,
UserProfileId = _id,
Restaurant = restaurant,
OrderState = orderState,
OrderType = orderType,
ScheduledDelivery = scheduledDelivery,
BookTable = bookTable
};
if (restaurant.MinOrderFreeDelivery > GetRestaurantSubTotal(restaurant.RestaurantId))
{
order.DeliveryPrice = 0;
}
else
{
order.DeliveryPrice = restaurant.DeliveryPrice;
}
_unitOfWork.OrderRepository.Add(order);
IEnumerable <ShoppingCart> shoppingCartItems = _unitOfWork.ShoppingCartRepository
.Get(sc => (sc.UserProfileId == _id) && (sc.RestaurantId == restaurant.RestaurantId));
foreach (ShoppingCart shoppingCart in shoppingCartItems)
{
OrderItem orderItem = new OrderItem()
{
Order = order,
Dish = shoppingCart.Dish,
Quantity = shoppingCart.Quantity
};
_unitOfWork.ShoppingCartRepository.Remove(shoppingCart);
_unitOfWork.OrderItemRepository.Add(orderItem);
}
}
_unitOfWork.Complete();
}
public static QuickFix.Fields.OrdStatus c(OrderState s)
{
var val = s_ordState.Find(v => v.second == s);
if (val == null)
{
throw new Exception("Unmapped OrderState value : " + s.ToString());
}
return(val.first);
}
public Order(int id, Book book, string name, string address, string email, int quantity, Order.OrderState state)
{
this.id = id;
this.book = book;
this.name = name;
this.address = address;
this.email = email;
this.quantity = quantity;
this.state = state;
}
public OrderViewModel(OrderState order)
{
Id = order.Id;
Dispatched = order.DispatchedDate.HasValue;
Name = order.Name;
Date = order.Date;
TotalAmount = order.TotalAmount;
order.Items = order.Items ?? new List <OrderStateItem>();
Items = order.Items?.Select(x => new OrderItemViewModel(x)).ToList();
}
public void UpdateOrderStatus(Guid orderRef, OrderState newState)
{
_logger.LogDebug($"Updating order state to {newState} for orderRef: {orderRef}");
var order = _orderRepository.GetOrderByOrderRef(orderRef);
order.OrderStatus = newState;
_orderRepository.UpdateOrder(order);
}
public void openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
OpenOrderUpdateReceived?.Invoke(this, new OpenOrderUpdate
{
OrderId = orderId,
Contract = contract,
Order = order,
OrderState = orderState
});
}
void OnCollisionStay2D(Collision2D collision)
{
// Debug.Log("Collision stay");
_physic._timeAtLastColision = Time.fixedTime;
if (_orderState == OrderState.EXECUTING)
{
_orderState = OrderState.FINALISING_BY_COLLISION;
}
_physic.ResetGravity();
}
private void ExceptionWhenSendingOrderFromInvalidState(OrderState initialState)
{
var order = new Order();
order.SetProperty(a => a.Status, initialState);
Action sendAction = () => order.Send(DateTime.Now);
sendAction.Should().Throw <InvalidOperationException>();
}
public ActionResult Edit([Bind(Include = "orderStateID,state")] OrderState orderState)
{
if (ModelState.IsValid)
{
db.Entry(orderState).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(orderState));
}
private SecurityContext CreateContextForPremiumOrder(OrderState orderState, PaymentState paymentState, Delivery delivery)
{
var states = new Dictionary <string, Enum>();
states.Add("State", orderState);
states.Add("Payment", paymentState);
states.Add("Delivery", delivery);
return(SecurityContext.Create(typeof(PremiumOrder), "owner", "ownerGroup", "ownerTenant", states, new Enum[0]));
}
/// <summary>
/// Constructor from the API.
/// </summary>
/// <param name="src">The source.</param>
/// <param name="issuedFor">Whether the order was issued for a corporation or a
/// character.</param>
/// <param name="character">The owning character.</param>
/// <exception cref="System.ArgumentNullException">src</exception>
protected MarketOrder(EsiOrderListItem src, IssuedFor issuedFor,
CCPCharacter character)
{
src.ThrowIfNull(nameof(src));
PopulateOrderInfo(src, issuedFor);
LastStateChange = DateTime.UtcNow;
m_character = character;
m_state = GetState(src);
}
public void Verify()
{
if (State == OrderState.Ready)
{
return;
}
State = OrderState.Ready;
DomainEvents.Raise(new OrderReadyEvent(OrderId));
}
public OrderStateButtonViewModel(IEnumerable <Order> selectedOrders, OrderStateGroup stateGroup, OrderState model)
{
_selectedOrders = selectedOrders;
Model = model;
OrderStateGroup = stateGroup;
if (string.IsNullOrEmpty(model.Name))
{
model.Name = string.Format("[{0}]", Resources.NewProperty);
}
}
public Order(Customer customer, Shop shop)
{
this.Customer = customer;
this.Shop = shop;
this.Items = new List<OrderItem>();
this.TotalPrice = 0m;
this.State = OrderState.UnderConstruction;
this.Timestamps = new Dictionary<OrderState,DateTime>();
this.Timestamps[this.State] = DateTime.UtcNow;
this.Shop.AddOrder(this);
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitor(O2GOrderRow order)
{
mOrder = order;
mTrades = new List <O2GTradeRow>();
mClosedTrades = new List <O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
//! [orderstatus]
//! [openorder]
public virtual void openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
Console.WriteLine("OpenOrder. ID: " + orderId + ", " + contract.Symbol + ", " + contract.SecType + " @ " + contract.Exchange + ": " + order.Action + ", " + order.OrderType + " " + order.TotalQuantity + ", " + orderState.Status);
if (order.WhatIf)
{
Console.WriteLine("What-If. ID: " + orderId +
", InitMarginBefore: " + Util.formatDoubleString(orderState.InitMarginBefore) + ", MaintMarginBefore: " + Util.formatDoubleString(orderState.MaintMarginBefore) + " EquityWithLoanBefore: " + Util.formatDoubleString(orderState.EquityWithLoanBefore) +
", InitMarginChange: " + Util.formatDoubleString(orderState.InitMarginChange) + ", MaintMarginChange: " + Util.formatDoubleString(orderState.MaintMarginChange) + " EquityWithLoanChange: " + Util.formatDoubleString(orderState.EquityWithLoanChange) +
", InitMarginAfter: " + Util.formatDoubleString(orderState.InitMarginAfter) + ", MaintMarginAfter: " + Util.formatDoubleString(orderState.MaintMarginAfter) + " EquityWithLoanAfter: " + Util.formatDoubleString(orderState.EquityWithLoanAfter));
}
}
public async Task Execute()
{
_logger.Debug("############# LoadAggregateWithFewEventsTest ###########");
// arrange
var id = Guid.NewGuid();
await DatabaseHelper
.CreateEventStream(id, typeof(Order).AssemblyQualifiedName)
.ConfigureAwait(false);
var expectedState = new OrderState(
Fixture.Create<string>(),
Fixture.Create<string>(),
Fixture.Create<Guid>(),
OrderStatus.Delivered,
Fixture.Create<string>());
var events = new List<DomainEvent>
{
new OrderCreated(id, expectedState.UserOrdering, expectedState.ShippingAddress, expectedState.ProductIdToSend),
new StartedFulfilment(id),
new ShipOrder(id),
new OrderDelivered(id, expectedState.PersonWhoReceivedOrder)
};
await DatabaseHelper
.CreateEvents(id, GetStoredEvents(events))
.ConfigureAwait(false);
var stopWatch = new Stopwatch();
// act
stopWatch.Start();
var aggregate = await AggregateContext
.Load<Order, OrderState>(id)
.ConfigureAwait(false);
stopWatch.Stop();
// assert
Console.WriteLine(stopWatch.Elapsed.ToString());
aggregate
.State
.ShouldBeEquivalentTo(expectedState);
stopWatch
.ElapsedMilliseconds
.Should()
.BeLessOrEqualTo(1000);
_logger.Debug("###################################################################");
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="Order"/> с заданными значениями.
/// </summary>
/// <param name="id">Уникальный идентификатор.</param>
/// <param name="clientId">Уникальный идентификатор клиента.</param>
/// <param name="basket">Корзина товаров заказа.</param>
/// <param name="state">Статус заказа.</param>
/// <param name="date">Дата заказа.</param>
public Order(string id,
string clientId,
Basket basket,
OrderState state,
DateTime date) : base(id)
{
ClientId = clientId;
Basket = basket;
State = state;
Date = date;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
public OrderMonitor(O2GOrderRow order)
{
mOrder = order;
mTrades = new List<O2GTradeRow>();
mClosedTrades = new List<O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
/// <summary>
/// 更新订单状态
/// </summary>
/// <param name="oid">订单id</param>
/// <param name="orderState">订单状态</param>
public void UpdateOrderState(int oid, OrderState orderState)
{
DbParameter[] parms =
{
GenerateInParam("@oid", SqlDbType.Int, 4, oid),
GenerateInParam("@orderstate", SqlDbType.TinyInt, 1, (int)orderState)
};
RDBSHelper.ExecuteNonQuery(CommandType.StoredProcedure,
string.Format("{0}updateorderstate", RDBSHelper.RDBSTablePre),
parms);
}
/// <summary>
/// Constructor from an object deserialized from the settings file.
/// </summary>
/// <param name="src">The source.</param>
/// <exception cref="System.ArgumentNullException">src</exception>
protected MarketOrder(SerializableOrderBase src)
{
src.ThrowIfNull(nameof(src));
ID = src.OrderID;
UnitaryPrice = src.UnitaryPrice;
RemainingVolume = src.RemainingVolume;
Issued = src.Issued;
IssuedFor = src.IssuedFor == IssuedFor.None ? IssuedFor.Character : src.IssuedFor;
LastStateChange = src.LastStateChange;
m_state = src.State;
}
/// <summary>
/// ctor
/// </summary>
/// <param name="order">Order for monitoring of execution</param>
/// <param name="iNetPositionAmount">Initial amount of trade</param>
public OrderMonitorNetting(O2GOrderRow order, int iNetPositionAmount)
{
mOrder = order;
mTrades = new List<O2GTradeRow>();
mUpdatedTrades = new List<O2GTradeRow>();
mClosedTrades = new List<O2GClosedTradeRow>();
mState = OrderState.OrderExecuting;
mResult = ExecutionResult.Executing;
mInitialAmount = iNetPositionAmount;
mTotalAmount = 0;
mRejectAmount = 0;
mRejectMessage = "";
}
public Order(int account, string symbol, int id, DateTime time, Operation operation, OrderType type, int size, double price, string comment, string addInfo)
{
_account = account;
_symbol = symbol;
_id = id;
_time = time;
_operation = operation;
_type = type;
_size = size;
_price = price;
_state = _type == OrderType.Market ? OrderState.Filled : OrderState.Working;
_comment = comment;
_addInfo = addInfo;
}
/// <summary>
/// Constructor from the API.
/// </summary>
/// <param name="src"></param>
protected MarketOrder(SerializableOrderListItem src)
{
m_state = GetState(src);
m_orderID = src.OrderID;
m_itemID = src.ItemID;
m_item = StaticItems.GetItemByID(src.ItemID);
m_station = GetStationByID(src.StationID);
m_unitaryPrice = src.UnitaryPrice;
m_initialVolume = src.InitialVolume;
m_remainingVolume = src.RemainingVolume;
m_lastStateChange = DateTime.UtcNow;
m_minVolume = src.MinVolume;
m_duration = src.Duration;
m_issued = src.Issued;
m_issuedFor = src.IssuedFor;
}
public OrderDetailInKitchenWindow(Int64 orderNo, string tableNo, OrderState state)
{
this.InitializeComponent();
// Insert code required on object creation below this point.
this.orderNo = orderNo;
this.tableNo = tableNo;
this.state = state;
if (state == OrderState.Canceled)
{
btnPrint.IsEnabled = false;
btnReadyToServe.IsEnabled = false;
OrderGridView.IsEnabled = false;
}
txbOrderNo.Text = orderNo.ToString();
txbTableNo.Text = tableNo;
}
/// <summary>
/// Constructor from an object deserialized from the settings file.
/// </summary>
/// <param name="src"></param>
protected MarketOrder(SerializableOrderBase src)
{
Ignored = src.Ignored;
m_orderID = src.OrderID;
m_state = src.State;
m_itemID = GetItemID(src);
m_item = GetItem(src);
m_station = GetStationByID(src.StationID);
m_unitaryPrice = src.UnitaryPrice;
m_initialVolume = src.InitialVolume;
m_remainingVolume = src.RemainingVolume;
m_lastStateChange = src.LastStateChange;
m_minVolume = src.MinVolume;
m_duration = src.Duration;
m_issued = src.Issued;
m_issuedFor = (src.IssuedFor == IssuedFor.None ? IssuedFor.Character : src.IssuedFor);
}
private void removeEmergencyLock(Order filledEmergencyOrder, OrderState stateCompletedOrInterrupted) {
OrderPostProcessorEmergencyLock emergencyLock = new OrderPostProcessorEmergencyLock(filledEmergencyOrder);
string msgPost = "EmergencyLock Removed [" + emergencyLock + "]";
if (this.emergencyLocks.Contains(emergencyLock) == false) {
string msg = "no EmergencyLock to remove: multiple QUIK callbacks? if u can find [" + msgPost
+ "] earlier in thisOrder.Messages then it's ok";
this.orderProcessor.AppendOrderMessageAndPropagateCheckThrowOrderNull(filledEmergencyOrder, msg);
Assembler.PopupException(msg);
//throw new Exception(msg);
return;
}
lock (this.emergencyLocks) {
this.emergencyLocks.Remove(emergencyLock);
}
OrderStateMessage omsgPost = new OrderStateMessage(filledEmergencyOrder, stateCompletedOrInterrupted, msgPost);
this.orderProcessor.UpdateOrderStateAndPostProcess(filledEmergencyOrder, omsgPost);
}
public void AddOrder(Order order)
{
Log.Instance.Debug("Order: {0}", order);
bool isMarket = order.Type == OrderType.Market;
bool isStop = order.Type == OrderType.StopOrder;
double price = GetPrice(order);
var orderNo = _orders.AddOrder(order.Security.SecBoard, order.Security.SecCode, order.Operation,
order.Quantity, price, isMarket, isStop, order.AlertPrice);
if (orderNo == -1)
order.IsError = true;
else
{
order.OrderNo = orderNo;
var state = new OrderState { Status = OrderStatus.NotReady, Timestamp = DateTime.Now };
order.SetState(state);
AddOrderToList(order);
}
}
public ResponseResult<OrderModel> Get(int page, int page_size, DateTime start_date, DateTime end_date, OrderState order_state, string optional_fields = "", SortType sortType = SortType.Ase, DateType dateType = DateType.Modify_Time)
{
IJdClient client = new DefaultJdClient("","","");
//http://jos.jd.com/api/detail.htm?id=691 接口地址
var response = client.Execute(new UnionOrderServiceQueryOrdersRequest());
//判断 是否接受错误 可忽略
if (response.IsError)
{
}
//对结果进行解析 理论上是响应的结果
var t = response.queryordersResult;
//是一窜json格式 OrderModel需要 对响应结果解析并且转换
var parse=JsonConvert.DeserializeObject<OrderModel>(t);
return new ResponseResult<OrderModel> {
Code = int.Parse(response.ErrCode),
Result = parse
};
//throw new NotImplementedException();
}
internal void SetOrderDelegateCallbackFn(ImportOrder order)
{
if (importOrder.ImportOrderItems.Count > 0)
{
var result = MessageBox.Show(this,
"Bạn có muốn lưu lại đơn đang làm hay không?",
"Lưu đơn hàng",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question);
if(result == DialogResult.Yes)
{
saveOrder();
}
}
importOrder = db.ImportOrders.Where(i => i.order_id.Equals(order.order_id))
//.Include(i => i.ImportOrderItems)
.First();
foreach (var item in importOrder.ImportOrderItems)
{
item.ProductName = item.Product.prod_name;
item.TotalItemPrice = item.quantity_by_stock * item.base_price_by_stock +
item.base_price_by_stock * item.quantity_by_unit / item.quantity_control;
}
dataGridView.DataSource = importOrder.ImportOrderItems.ToList();
updateLblTotal();
if (importOrder.order_status.Trim() == "Done")
{
orderState = OrderState.Done;
cbbStatus.Text = "Done";
}
else
{
orderState = OrderState.OnProgress;
cbbStatus.Text = "On progress";
}
}
internal Visual GetContent(Int64 orderNo, string tableNo, OrderState state, bool isRepeated)
{
if (isRepeated)
{
txbRepeatedPrint.Visibility = Visibility.Visible;
}
Visual returnContent = null;
DataTable dt = OrderContent(orderNo);
if (dt != null)
{
if (state == OrderState.New)
{
txbTitle.Text = "New Order";
EditAmountColumn.Width = 0;
}
else if (state == OrderState.Edited)
{
txbTitle.Text = "Edited Order";
EditAmountColumn.Width = 60;
}
else if (state == OrderState.Canceled)
{
txbTitle.Text = "Canceled Order";
EditAmountColumn.Width = 0;
CancelSign.Visibility = Visibility.Visible;
}
txbOrderNo.Text = orderNo.ToString();
txbTableNo.Text = tableNo;
txbPrintDateTime.Text = DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToLongTimeString();
lstContent.ItemsSource = dt.DefaultView;
lstContent.SelectedIndex = -1;
mainBorder.Width = 300;
returnContent = mainBorder;
}
return returnContent;
}
public ResponseResult<SerachModel> Search(int page, int page_size, DateTime start_date, DateTime end_date, OrderState order_state, string optional_fields = "", SortType sortType = SortType.Ase, DateType dateType = DateType.Modify_Time)
{
throw new NotImplementedException();
}
void OnCollisionStay2D(Collision2D collision)
{
// Debug.Log("Collision stay");
_physic._timeAtLastColision = Time.fixedTime;
if (_orderState == OrderState.EXECUTING)
_orderState = OrderState.FINALISING_BY_COLLISION;
_physic.ResetGravity();
}
/* COOROUTINES */
IEnumerator ExecuteImpulseOrder(OrderImpulse order)
{
// Start order execution
// Initialise oder
_orderState = OrderState.INITIALISING;
// Execute order
_debug_useGravity = true;
_physic.AddImpulse(order._impulse);
// Wait until order is executed
_orderState = OrderState.EXECUTING;
// Wait for a base delay
float delayMin = 0.1f;
while (delayMin > 0 && _orderState != OrderState.FINALISING_BY_NODE) {
delayMin -= Time.deltaTime;
yield return null;
}
// If not stop on node during base delay
if(_orderState != OrderState.FINALISING_BY_NODE) {
// Wait for the unit to stop
_orderState = OrderState.EXECUTING;
while (!(_orderState == OrderState.FINALISING_BY_COLLISION || _orderState == OrderState.FINALISING_BY_NODE)) {
yield return null;
}
}
// Reset gravity
_physic.ResetGravity();
// Reset all impulses
_physic.ResetImpulses();
// Stop applying gravity
_debug_useGravity = false;
if (order._endWorldPos == Vector3.zero) {
order._endWorldPos = transform.position;
}
// Open a new path if the travel do not finish on an already existing node
if(_currentNode == null && _lastNode != null) {
_lastNode.AddFrontNode(this, order);
} else {
StartCoroutine("CorrectPosition");
}
// End order execution
_orderState = OrderState.IDLE;
yield return null;
}
public void Ship()
{
if (State == OrderState.Pending)
state = OrderState.Shipped;
}
public void Cancel()
{
if (State != OrderState.Shipped)
state = OrderState.Cancelled;
}
