public CompleteOrder SaveCurrentOrderInDb(CartCollection cartCollection, ShipmentInfo shipmentInfo)
{
if (shipmentInfo.ShipmentOption == null)
{
Console.WriteLine("empty shipment option");
}
var currentOrder = GetCurrentCompleteOrder(cartCollection, shipmentInfo);
var baseOrder = BaseOrder.CreateBaseOrder(currentOrder);
baseOrder = _baseOrderRepository.SaveAndFlush(baseOrder);
currentOrder.OrderId = baseOrder.Id;
var orderEventList = OrderEvent.createOrderEventList(currentOrder);
_orderEventRepository.SaveAll(orderEventList);
if (VerifyOrder(orderEventList))
{
baseOrder.OrderStatus = OrderProcessingStatus.Verified.ToString();
}
else
{
baseOrder.OrderStatus = OrderProcessingStatus.VerificationFailed.ToString();
}
baseOrder = _baseOrderRepository.Update(baseOrder);
return(currentOrder);
}
private static BaseOrder CreateOrder(string tradeType, bool hasBaseAmount)
{
OrderType typeParse;
if (!Enum.TryParse <OrderType>(tradeType, out typeParse))
{
throw new OrderImportDataException();
}
if (typeParse == OrderType.Buy)
{
if (!hasBaseAmount)
{
typeParse = OrderType.Deposit;
}
}
else if (typeParse == OrderType.Sell)
{
if (!hasBaseAmount)
{
typeParse = OrderType.Withdraw;
}
}
else
{
throw new OrderImportDataException();
}
return(BaseOrder.CreateOrder(typeParse));
}
/// <summary>
/// Gets and removes the first order from the order queue
/// </summary>
/// <returns>The first order from the queue</returns>
public BaseOrder DequeueOrder()
{
//this is technically not safe, and should probably be changed back to a queue after i find a way to display the queue in the editor
BaseOrder o = orderQueue[0];
orderQueue.RemoveAt(0);
return(o);
}
public BaseOrder Update(BaseOrder baseOrder)
{
using (var shopDbContext = ShopDbContext.GetInstance())
{
shopDbContext.BaseOrders.Update(baseOrder);
shopDbContext.SaveChanges();
return(baseOrder);
}
}
public BaseOrder SaveAndFlush(BaseOrder baseOrder)
{
using (var shopDbContext = ShopDbContext.GetInstance())
{
shopDbContext.BaseOrders.Add(baseOrder);
shopDbContext.SaveChanges();
return(baseOrder);
}
}
internal override JsonNewOrder GetJsonRequest()
{
BaseOrder.ClientOrderId = ClientOrderId;
BaseOrder.ExtendedHours = ExtendedHours;
BaseOrder.Duration = Duration;
return(BaseOrder.GetJsonRequest()
.WithOrderClass(OrderClass));
}
public void SearchForTarget(BaseOrder order)
{
if (IsMarkedForDeletion)
{
return;
}
SearchForTarget(order.SecondId, order.StringParameter, true);
}
/// <summary>Clears the order queue and sets the current order</summary>
public void OverrideOrder(BaseOrder o)
{
orderQueue.Clear();
if (currentOrder != null)
{
currentOrder.Cancel();
}
idle = false;
currentOrder = o;
}
/// <summary>
/// Starts the actor panicing, pauses current orders and starts executing the given response order
/// </summary>
/// <param name="response">Response order</param>
public void Panic(BaseOrder response)
{
if (!idle)
{
Debug.Log("Pausing order!");
currentOrder.Pause();
orderQueue.Insert(0, currentOrder);
}
currentOrder = response;
}
/// <summary>Changes to the given state</summary>
public void GoToState(string state, ActorController actor)
{
if (!States.ContainsKey(state))
{
throw new ArgumentOutOfRangeException(nameof(state), $"Nonexistant order state: {state}");
}
OrderStateInfo info = States[state];
currentState = state;
currentOrder = info.StartState(actor);
}
public static ShipmentInfo CreateShipmentInfo(BaseOrder baseOrder)
{
return(new ShipmentInfo
{
FullName = baseOrder.FullName,
PhoneNumber = baseOrder.PhoneNumber,
City = baseOrder.City,
PostalAddress = baseOrder.PostalAddress,
Street = baseOrder.Street,
HouseNumber = baseOrder.HouseNumber
});
}
private void ProcessRequest(BaseOrder request)
{
Console.WriteLine("Recived request");
var order = new Order(request.Id, request.Product, request.Customer)
{
ReplyTo = nameof(Order)
};
_outstandingOrders.Add(order);
_bus.Publish(order, request.Customer.Country);
Console.WriteLine("Published Request");
}
private void checkMoveEntity(double x, double y)
{
PositionDB target;
_game.CurrentDateTime.AddSeconds(5.0);
_ship.GetDataBlob <ShipInfoDB>().Orders.Clear();
_player.Orders.ClearOrders();
target = new PositionDB(_ship.GetDataBlob <PositionDB>());
target.X += x;
target.Y += y;
_target.GetDataBlob <PositionDB>().X = target.X;
_target.GetDataBlob <PositionDB>().Y = target.Y;
_player.Orders.MoveOrder(_ship, _target);
BaseOrder order = _player.Orders.PeekNextOrder();
Assert.AreEqual(1, _player.Orders.NumOrders());
OrderProcessor.Process(_game);
Assert.AreEqual(0, _player.Orders.NumOrders());
Assert.AreEqual(1, _ship.GetDataBlob <ShipInfoDB>().Orders.Count);
Assert.Contains(order, _ship.GetDataBlob <ShipInfoDB>().Orders);
OrderProcessor.ProcessShip(_ship);
Assert.AreEqual(0, _player.Orders.NumOrders());
Assert.AreEqual(1, _ship.GetDataBlob <ShipInfoDB>().Orders.Count);
Assert.Contains(order, _ship.GetDataBlob <ShipInfoDB>().Orders);
OrderProcessor.ProcessShip(_ship);
// Check speed
Vector4 speed = _shipPropulsionDB.CurrentSpeed;
double length = Math.Sqrt((x * x) + (y * y));
double speedX, speedY;
// multiplier to modify overly slow speeds
speedX = Distance.KmToAU((x / length) * _shipPropulsionDB.MaximumSpeed);
speedY = Distance.KmToAU((y / length) * _shipPropulsionDB.MaximumSpeed);
// Allowing for very small discrepancies
Assert.LessOrEqual(Math.Abs(speedX - speed.X), 0.0001);
Assert.LessOrEqual(Math.Abs(speedY - speed.Y), 0.0001);
}
/// <summary>Changes to the given state</summary>
public void GoToState(string state, ActorController actor)
{
if (States.ContainsKey(state))
{
OrderStateInfo info = States[state];
currentState = state;
currentOrder = info.StartState(actor);
}
else
{
throw new ArgumentOutOfRangeException("Nonexistant order state: " + state);
}
}
// Handles FixedUpdate event
public virtual void FixedUpdate()
{
double feedMe = (double)(Time.fixedDeltaTime * 0.025f);
var logisticsManager = logisticsActor.logisticsManager;
LogisticsNetwork network = logisticsManager ? logisticsManager.FindNearestNetwork(transform.position) : null;
if (network != null && network.Foodbuffer > feedMe)
{
network.Foodbuffer -= feedMe;
health = System.Math.Min(1, health + feedMe);
}
else
{
health -= feedMe;
}
if (health <= 0.0)
{
Destroy(gameObject);
return;
}
if (currentOrder != null && currentOrder.Done)
{
currentOrder = null;
}
if (currentOrder == null)
{
if (orderQueue.Count > 0)
{
currentOrder = DequeueOrder();
idle = false;
}
else
{
currentOrder = new IdleOrder(this);
idle = true;
}
}
currentOrder.Update(this);
queueLength = orderQueue.Count;
}
public OrderPosition(BaseOrder baseOrder, List <OrderEvent> orderEvents)
{
BaseOrder = baseOrder;
OrderEvents = orderEvents;
}
/// <summary>Adds an order to the pending order queue</summary>
public void EnqueueOrder(BaseOrder o)
{
orderQueue.Add(o);
//orderQueue.Enqueue(o);
}
/// <summary>
/// Constructs an order from the orderTag against the given target,
/// and assigns it to all selected actors
/// </summary>
public void IssueOrder(CommandType orderTag, NeolithicObject target)
{
var actors = selected.Select(go => go.GetComponent <ActorController>()).Where(a => a != null);
foreach (var actor in actors)
{
BaseOrder newOrder = null;
switch (orderTag)
{
case CommandType.ChopWood:
case CommandType.MineGold:
case CommandType.MineStone:
case CommandType.Forage:
newOrder = new HarvestFromReservoirOrder(actor, target);
break;
case CommandType.ChuckWood:
newOrder = new TransmuteOrder(actor, target, ResourceKind.Wood, ResourceKind.Gold);
break;
case CommandType.Meditate:
newOrder = new MeditateOrder(actor, target);
break;
case CommandType.Hunt:
newOrder = new HuntOrder(actor, target.GetComponentInParent <Herd>());
break;
case CommandType.Fish:
newOrder = new FishOrder(actor, target);
break;
case CommandType.Construct:
newOrder = new ConstructOrder(actor, target);
break;
case CommandType.TearDown:
newOrder = new TearDownOrder(actor, target);
break;
case CommandType.ForestGarden:
var prefab = (GameObject)Resources.Load("Buildings/ForestGarden");
if (prefab == null)
{
throw new InvalidOperationException("Can't find prefab");
}
newOrder = new UpgradeReservoirOrder(actor, target, prefab);
break;
default:
throw new InvalidOperationException("Unrecognized order tag " + orderTag);
}
Factory.InjectObject(newOrder);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
actor.EnqueueOrder(newOrder);
}
else
{
actor.OverrideOrder(newOrder);
}
}
}
internal override JsonNewOrder GetJsonRequest() => BaseOrder.GetJsonRequest() .WithOrderClass(OrderClass);
public T HandleOrder(BaseOrder order)
{
return(OrderDispatcher[order.GetType()](order));
}
internal override Boolean IsQuantityInvalid() => BaseOrder.IsQuantityInvalid();
public OrderViewModel(BaseOrder order)
: this()
{
_order = order;
}
private static BaseOrder ImportOrder(string importString)
{
string[] orderData = importString.Split(new char[] { ',' }, StringSplitOptions.None);
BaseOrder newOrder = CreateOrder(orderData[1], !string.IsNullOrWhiteSpace(orderData[3]));
Currency coinParse;
decimal amountParse;
Location locationParse;
// Parse the order instant
newOrder.OrderInstant = DateTime.Parse(orderData[0]);
// Parse the trading location
if (!Enum.TryParse <Location>(orderData[7], out locationParse))
{
throw new OrderImportDataException();
}
newOrder.Location = locationParse;
// Parse the trade currency type
if (!Enum.TryParse <Currency>(orderData[4], out coinParse))
{
throw new OrderImportDataException();
}
newOrder.TradeCurrency = coinParse;
// Parse the trade amount (used for deposits/withdrawals as well)
if (!decimal.TryParse(orderData[5], out amountParse))
{
throw new OrderImportDataException();
}
newOrder.TradeAmount = amountParse;
// Extra parsing for buy/sell orders
if (newOrder is ExchangeOrder)
{
ExchangeOrder newExchangeOrder = (ExchangeOrder)newOrder;
// Parse the base currency type
if (!Enum.TryParse <Currency>(orderData[2], out coinParse))
{
throw new OrderImportDataException();
}
newExchangeOrder.BaseCurrency = coinParse;
// Parse the base amount
if (!decimal.TryParse(orderData[3], out amountParse))
{
throw new OrderImportDataException();
}
newExchangeOrder.BaseAmount = amountParse;
// Parse the fee amount (stored in the base currency)
if (!decimal.TryParse(orderData[6], out amountParse))
{
throw new OrderImportDataException();
}
newExchangeOrder.BaseFee = amountParse;
}
return(newOrder);
}
public OrderViewModel(OrderType type)
: this(BaseOrder.CreateOrder(type))
{
}
public OrderViewModel(OrderViewModel orderVM)
: this(BaseOrder.CreateOrder(orderVM.Order))
{
}
/// <summary>
/// Applies a series of orders on an IQueryable.
/// </summary>
/// <typeparam name="T">The entity that you are ordering.</typeparam>
/// <param name="queryable">An IQueryable of type T entity.</param>
/// <param name="baseOrder">An order object that will apply a series of orders.</param>
/// <returns>An IOrderedQueryable of type T.</returns>
public static IOrderedQueryable <T> NPredicateBuilderEFOrder <T>(this IQueryable <T> queryable, BaseOrder <T> baseOrder)
{
if (baseOrder.FirstOrder == null)
{
throw new ArgumentNullException(nameof(queryable));
}
var orderedEntities = baseOrder.FirstOrder.Order(queryable);
foreach (var orderer in baseOrder.SecondaryOrders)
{
orderedEntities = orderer.Order(orderedEntities);
}
return(orderedEntities);
}
public void AutomaticFormationOrderTest()
{
GameManager.Instance.Log.LogDebug("Running test AutomaticFormationOrderTest().");
Player player = new Player();
player.Name = "GoodGuy";
player.IsComputerPlayer = true;
Player playerEnemy = new Player();
playerEnemy.Name = "BadGuy";
playerEnemy.IsComputerPlayer = true;
Group group = new Group();
GameManager.Instance.GameData.InitAllData();
Game game = GameManager.Instance.CreateGame(player, "test game");
game.Players.Add(player);
game.Players.Add(playerEnemy);
GameManager.Instance.Game.SetAllPlayersEnemies();
GameManager.Instance.GameData.InitAllData();
GameManager.Instance.CreateGame(player, "test game");
Position pos = new Position(60, 3, 0, 45);
BaseUnit unitMain = GameManager.Instance.GameData.CreateUnit(player, group, "arleighburke", "lead",
pos, true);
BaseUnit unit1 = GameManager.Instance.GameData.CreateUnit(player, group, "arleighburke", "follow1",
pos.Offset(30, 300), true);
BaseUnit unit2 = GameManager.Instance.GameData.CreateUnit(player, group, "arleighburke", "follow2",
pos.Offset(120, 400), true);
unitMain.MovementOrder.AddWaypoint(new Waypoint(new Position(61.0, 4.0)));
unitMain.SetActualSpeed(40.0);
Assert.IsTrue(unitMain.GetActiveWaypoint() != null, "ActiveWaypoint should not be null.");
group.AutoAssignUnitsToFormation();
game.IsNetworkEnabled = false;
ScheduledOrder sched = new ScheduledOrder(1);
var innerOrder = new BaseOrder(unit1.OwnerPlayer, GameConstants.OrderType.SetSpeed);
innerOrder.UnitSpeedType = GameConstants.UnitSpeedType.Slow;
sched.Orders.Add(innerOrder);
unit1.Orders.Enqueue(sched);
GameManager.Instance.Game.RunGameInSec = 1;
GameManager.Instance.Game.StartGamePlay();
unitMain.ReCalculateEta();
unit1.ReCalculateEta();
unit2.ReCalculateEta();
Assert.IsTrue(unit1.MovementOrder is MovementFormationOrder, "Unit 1 should have a movement formation order.");
Assert.IsTrue(unit2.MovementOrder is MovementFormationOrder, "Unit 2 should have a movement formation order.");
Assert.IsFalse(unitMain.MovementOrder is MovementFormationOrder, " MainUnit should NOT have movement formation order.");
unitMain.HitPoints = 0;
unitMain.IsMarkedForDeletion = true;
group.AutoAssignUnitsToFormation();
//GameManager.Instance.Game.RunGameInSec = 1;
//GameManager.Instance.Game.StartGamePlay();
Assert.IsTrue(group.MainUnit.Id == unit1.Id, "Unit 1 should now be main unit.");
Assert.IsFalse(unit1.MovementOrder is MovementFormationOrder, "Unit 1 should NOT have a movement formation order.");
Assert.IsTrue(unit2.MovementOrder is MovementFormationOrder, "Unit 2 should still have a movement formation order.");
var activeWp = unit1.GetActiveWaypoint();
Assert.IsTrue(activeWp != null, "Unit 1 should have an ActiveWaypoint.");
GameManager.Instance.TerminateGame();
}
public OrderVMComparer(OrderSortType sortBy, ListSortDirection sortDir, bool uniqueSort)
{
BaseOrder.SetComparisonParameters(sortBy, sortDir, uniqueSort);
}
static void Main(string[] args)
{
//K-d1b145144afec7e52afd98ab18fcdd3b5d9ce6c8
//S-b457848406b1cebaa503782234048dade4e92e42
//ExmoCryptoExchenge ex = new ExmoCryptoExchenge();
//ex.SetAutentification("K-d1b145144afec7e52afd98ab18fcdd3b5d9ce6c8", "S-b457848406b1cebaa503782234048dade4e92e42");
//List<CriptoExchengLib.Interfaces.ICurrencyPair> cps = new List<CriptoExchengLib.Interfaces.ICurrencyPair>();
//BaseCurrencyPair cp = new BaseCurrencyPair("BTC_USD");
//cps.Add(cp);
//ex.GetCurrencyPair();
//BaseOrder bo = new BaseOrder();
//bo.Pair = new BaseCurrencyPair("BTC_USD");
//bo.Price = 0;
//bo.Quantity = 0;
//bo.Type = BaseOrderType.Buy;
//ex.PostOrder(bo);
//ex.GetOrderStatus(12345);
//ex.GetAccountsList();
//ex.GetHistoryRecords(DateTime.Now);
//ex.GetOrdersHistory(cp,100);
//string json = JsonConvert.SerializeObject(ex.GetBookWarrants(cps, 10), Formatting.Indented);
//Console.WriteLine(json);
//nead fix error
BitfinexCryptoExchenge bf = new BitfinexCryptoExchenge();
bf.SetAutentification("Za8bnEr09Q45b6y5Ri7fq71UKoCHByMR7LMr4XqRO9g", "zI3lrqhbNUXTxHaxui3w816Tl3WxorgtrZPqHKml3e1");
//List<BaseCurrencyPair> cps = new List<BaseCurrencyPair>();
////BaseCurrencyPair bc = new BaseCurrencyPair("tBTCUSD");
////cps.Add(bc);
////bf.GetBookWarrants(cps,100);
////bf.GetCurrencyPair();
BaseOrder bo = new BaseOrder();
bo.Pair = new BaseCurrencyPair("tBTCUSD");
bo.Price = 0;
bo.Quantity = 0;
bo.Type = BifinexOrderType.Exchange_fok;
bf.PostOrder(bo);
//bf.CanselOrder(1);
//Console.ReadKey();
//List<BaseCurrencyPair> cps = new List<BaseCurrencyPair>();
//BaseCurrencyPair cp = new BaseCurrencyPair("ADACAD");
//cps.Add(cp);
//KrakenCryptoExchenge kc = new KrakenCryptoExchenge();
//kc.SetAutentification("OIav92RTeccxQp4zrM6SH3RN07jEyk3POiPByg/54w1wToBRTtVz3120", "eDxzDp0LL1JQhK+pJF2MYbNz+B/WA203vg76PNtAqnT+zgpURWGO/t/S0aqhO1plyIs3OgNjRaHbk0cwkk6prw==");
//kc.GetCurrencyPair();
//kc.GetBookWarrants(cps, 100);
//AddOrder("ADACAD","buy","limit",1,1,1);
//KrakenOrder ko = new KrakenOrder();
//ko.Pair = new BaseCurrencyPair("ADACAD");
//ko.Type = KrakenOrderType.Buy;
//ko.Ordertype = KrakenOrderType.Limit;
//ko.Price = 1;
//ko.Quantity = 1;
//kc.PostOrder(ko);
//kc.CanselOrder(10);
//kc.GetOrderStatus(10);
// kc.GetAccountsList();
//BinanceCryptoExchenge bce = new BinanceCryptoExchenge();
//bce.SetAutentification("IYTZ2ugTwRN3FjfGSWc7GXkiR4unBiPhLtTlx31oUWfAnAvmW6VCj8r9fqYO878k", "g4VYUr1TCGfQLNhq0jSAtFCsXbgLww7Xjjd9BFrleFCi1TeRK2DD26WFZdrknCiu");
//List<BaseCurrencyPair> cps = new List<BaseCurrencyPair>();
//BaseCurrencyPair bc = new BaseCurrencyPair("BNBBTC");
//cps.Add(bc);
//bce.GetBookWarrants(cps,500);
//bce.GetCurrencyPair();
//BinanceOrder bo = new BinanceOrder();
//bo.Pair = new BaseCurrencyPair("LTCBTC");
//bo.Side = BinanceOrderType.Buy;
//bo.Type = BinanceOrderType.Limit;
//bo.Quantity = 1;
//bo.Price = 1;
//bo.TimeInForce = TimeInForce.GTC;
//bce.PostOrder(bo);
//bce.CanselOrder(new BaseCurrencyPair("LTCBTC"),10);
//bce.GetAccountsList();
//bce.GetOrdersHistory(new BaseCurrencyPair("LTCBTC"), 100);
}
