public void available_for_purchase_is_false_for_basic_property()
{
var owner = new Trader();
var property = new Property("Test Property", ref owner);
Assert.IsFalse(property.AvailableForPurchase());
}
public void constructorTest()
{
Trader t2 = new Trader("Player2", 1500);
Assert.AreEqual(t2.getName(), "Player2");
Assert.AreEqual(t2.getBalance(), 1500);
}
public DeliverGoods(Actor self)
{
trader = self.Trait<Trader>();
traderInfo = self.Info.Traits.Get<TraderInfo>();
move = self.Trait<IMove>();
pathFinder = self.World.WorldActor.Trait<IPathFinder>();
}
public void to_string_has_correct_output()
{
var trader = new Trader("Josh", 500);
const string expected = "Name: Josh \nBalance: 500";
var actual = trader.ToString();
Assert.AreEqual(expected, actual);
}
private static void StartTrading()
{
// setup traders
var t1 = new Trader (20000);
var t2 = new Trader (30000);
var t3 = new Trader (100000);
var t4 = new Trader (5000);
var t5 = new Trader (1000);
// spin off threads for trades
// todo
}
public void checkBankruptNegative()
{
Trader t = new Trader("Player1", -100);
try
{
t.checkBankrupt();//exception should be thrown so should not run follwing line
Assert.Fail();
}
catch (Exception ex)
{
Console.Write("Exception Thrown: " + ex.Message);
}
}
public void checkBankrupt()
{
Trader t = new Trader("Player1", 1500);
try
{
t.checkBankrupt();//nothing should happen (no exception thrown)
}
catch (Exception ex)
{
Console.Write("Exception Thrown: " + ex.Message);
Assert.Fail();
}
}
public ActionResult Edit(Trader trader)
{
if (ModelState.IsValid)
{
trader.Number = (trader.Weight * trader.NumberOfOne) / 1000;
trader.PricePerOne = db.FreezerCeteogries.Find(trader.cat_Id).PricePerTon;
trader.Change = (trader.Number * db.FreezerCeteogries.Find(trader.cat_Id).PricePerTon) - trader.Cash;
db.Entry(trader).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.FrID = new SelectList(db.Fridages, "Fr_id", "Fr_Name");
ViewBag.cat_Id = new SelectList(db.FreezerCeteogries, "id", "Type", trader.cat_Id);
// ViewBag.PeriodId = new SelectList(db.periods.Where(x => x.isActive), "Id", "PeriodName", trader.PeriodId);
return(View(trader));
}
/// <summary>
/// Creates a buy order on the exchange.
/// </summary>
/// <param name="freeTrader">The trader placing the order</param>
/// <param name="pair">The pair we're buying</param>
/// <returns></returns>
private async Task <Trade> CreateBuyOrder(Trader freeTrader, string pair)
{
// Take the amount to invest per trader OR the current balance for this trader.
var btcToSpend = freeTrader.CurrentBalance > Constants.AmountOfBtcToInvestPerTrader
? Constants.AmountOfBtcToInvestPerTrader
: freeTrader.CurrentBalance;
// The amount here is an indication and will probably not be precisely what you get.
var ticker = await _api.GetTicker(pair);
var openRate = GetTargetBid(ticker);
var amount = btcToSpend / openRate;
var amountYouGet = (btcToSpend * (1 - Constants.TransactionFeePercentage)) / openRate;
// Get the order ID, this is the most important because we need this to check
// up on our trade. We update the data below later when the final data is present.
var orderId = await _api.Buy(pair, amount, openRate);
await SendNotification($"Buying {pair} at {openRate:0.0000000 BTC} which was spotted at bid: {ticker.Bid:0.00000000}, " +
$"ask: {ticker.Ask:0.00000000}, " +
$"last: {ticker.Last:0.00000000}, " +
$"({amountYouGet:0.0000} units).");
return(new Trade()
{
TraderId = freeTrader.RowKey,
Market = pair,
StakeAmount = btcToSpend,
OpenRate = openRate,
OpenDate = DateTime.UtcNow,
Quantity = amountYouGet,
OpenOrderId = orderId,
BuyOrderId = orderId,
IsOpen = true,
IsBuying = true,
StrategyUsed = _strategy.Name,
PartitionKey = "TRADE",
SellType = SellType.None,
RowKey = $"MNT{(DateTime.MaxValue.Ticks - DateTime.UtcNow.Ticks):d19}"
});
}
protected override void OnItemMoved(Trader trader, TradeItem item, bool modified, int difference)
{
if (trader == Crafter)
{
base.OnItemMoved(trader, item, modified, difference);
if (!modified && item.Stack > 0)
{
InventoryHandler.SendExchangeObjectAddedMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectAddedMessage(Receiver.Character.Client, Receiver != trader, item);
}
else if (item.Stack <= 0)
{
InventoryHandler.SendExchangeObjectRemovedMessage(Crafter.Character.Client, Crafter != trader, item.Guid);
InventoryHandler.SendExchangeObjectRemovedMessage(Receiver.Character.Client, Receiver != trader, item.Guid);
}
else
{
InventoryHandler.SendExchangeObjectModifiedMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectModifiedMessage(Receiver.Character.Client, Receiver != trader, item);
}
}
else
{
if (!modified && item.Stack > 0)
{
InventoryHandler.SendExchangeObjectPutInBagMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectPutInBagMessage(Receiver.Character.Client, Receiver != trader, item);
}
else if (item.Stack <= 0)
{
InventoryHandler.SendExchangeObjectRemovedFromBagMessage(Crafter.Character.Client, Crafter != trader, item.Guid);
InventoryHandler.SendExchangeObjectRemovedFromBagMessage(Receiver.Character.Client, Receiver != trader, item.Guid);
}
else
{
InventoryHandler.SendExchangeObjectModifiedInBagMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectModifiedInBagMessage(Receiver.Character.Client, Receiver != trader, item);
}
}
}
/// <summary>ArchiveChildrens a Blotter record.</summary>
/// <param name="transaction">Commits or rejects a set of commands as a unit</param>
/// <param name="rowVersion">the version number of this row.</param>
/// <param name="blotterId">The value for the BlotterId column.</param>
/// <param name="archive">true to archive the object, false to unarchive it.</param>
internal static void ArchiveChildren(AdoTransaction adoTransaction, SqlTransaction sqlTransaction, long rowVersion, int blotterId)
{
// Accessor for the Blotter Table.
ServerMarketData.BlotterDataTable blotterTable = ServerMarketData.Blotter;
// This record can be used to iterate through all the children.
ServerMarketData.BlotterRow blotterRow = blotterTable.FindByBlotterId(blotterId);
// Archive the child records.
for (int index = 0; (index < blotterRow.GetBranchRows().Length); index = (index + 1))
{
ServerMarketData.BranchRow childBranchRow = blotterRow.GetBranchRows()[index];
Branch.ArchiveChildren(adoTransaction, sqlTransaction, childBranchRow.RowVersion, childBranchRow.BranchId);
}
for (int index = 0; (index < blotterRow.GetSourceRows().Length); index = (index + 1))
{
ServerMarketData.SourceRow childSourceRow = blotterRow.GetSourceRows()[index];
Source.ArchiveChildren(adoTransaction, sqlTransaction, childSourceRow.RowVersion, childSourceRow.SourceId);
}
for (int index = 0; (index < blotterRow.GetTraderRows().Length); index = (index + 1))
{
ServerMarketData.TraderRow childTraderRow = blotterRow.GetTraderRows()[index];
Trader.ArchiveChildren(adoTransaction, sqlTransaction, childTraderRow.RowVersion, childTraderRow.TraderId);
}
for (int index = 0; (index < blotterRow.GetWorkingOrderRows().Length); index = (index + 1))
{
ServerMarketData.WorkingOrderRow childWorkingOrderRow = blotterRow.GetWorkingOrderRows()[index];
WorkingOrder.Archive(adoTransaction, sqlTransaction, childWorkingOrderRow.RowVersion, childWorkingOrderRow.WorkingOrderId);
}
// Increment the row version
rowVersion = ServerMarketData.RowVersion.Increment();
// Delete the record in the ADO database.
blotterRow[blotterTable.RowVersionColumn] = rowVersion;
adoTransaction.DataRows.Add(blotterRow);
blotterRow.Delete();
// Archive the record in the SQL database.
SqlCommand sqlCommand = new SqlCommand("update \"Blotter\" set \"IsArchived\" = 1 where \"BlotterId\"=@blotterId");
sqlCommand.Connection = sqlTransaction.Connection;
sqlCommand.Transaction = sqlTransaction;
sqlCommand.Parameters.Add(new SqlParameter("@blotterId", SqlDbType.Int, 0, ParameterDirection.Input, false, 0, 0, null, DataRowVersion.Current, blotterId));
sqlCommand.ExecuteNonQuery();
}
public static int GetClosableCount(this Trader t, string code, TradeDirectType dir)
{
try
{
var p = t.GetPositionSummary(code, PositionType.权利仓);
if (p == null)
{
return(0);
}
if (p.PositionType == "权利仓" && dir == TradeDirectType.买)
{
return(0);
}
if (p.PositionType == "义务仓" && dir == TradeDirectType.卖)
{
return(0);
}
if (t.Orders() == null || t.Orders().Count == 0)
{
return(p.Count);
}
var tl = t.Orders();
if (tl == null)
{
return(p.Count);
}
var c = tl.GetCloseCount(code, dir);
var r = p.Count - c;
return(r);
}
catch (Exception e)
{
Singleton <TextLog> .Instance.Error(e, "getclosablecountextension");
return(0);
}
}
private static void LoadTradersFromNodes(XmlNodeList nodes)
{
foreach (XmlNode node in nodes)
{
var trader = new Trader(node.AttributeAsInt("ID"), node.SelectSingleNode("./Name")?.InnerText ?? "");
foreach (XmlNode childNode in node.SelectNodes("./InventoryItems/Item"))
{
int quantity = childNode.AttributeAsInt("Quantity");
// Create a new GameItem object for each item we add.
// This is to allow for unique items, like swords with enchantments.
for (int i = 0; i < quantity; i++)
{
trader.AddItemToInventory(ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID")));
}
}
_traders.Add(trader);
}
}
public void SubmitTrader()
{
Trader trader = null;
int id = 0;
var dbName = "SubmitTrader";
"Given I have a new trader".x(() => trader = TestTradeDataStatic.MargamanTrader);
"When I submit the trader".x(async() =>
{
var traderRepository = new TraderRepository(CreateNewContext(dbName));
await traderRepository.New(trader);
id = trader.Id;
});
"Then the trader is displayed".x(async() =>
{
var traderRepository = new TraderRepository(CreateNewContext(dbName));
AssertTrader(await traderRepository.Get(id), trader);
});
}
public void TradeFinished(PokeRoutineExecutor routine, PokeTradeDetail <T> info, T result)
{
OnFinish?.Invoke(routine);
var tradedToUser = Data.Species;
var message = tradedToUser != 0 ? $"Trade finished. Enjoy your {(Species)tradedToUser}!" : "Trade finished!";
Trader.SendMessageAsync(message).ConfigureAwait(false);
if (result.Species != 0 && Hub.Config.Discord.ReturnPK8s)
{
Trader.SendPKMAsync(result, "Here's what you traded me!").ConfigureAwait(false);
}
if (info.Type == PokeTradeType.TradeCord)
{
var user = Trader.Id.ToString();
var origPath = TradeExtensions.TradeCordPath.FirstOrDefault(x => x.Contains(user));
var tradedPath = System.IO.Path.Combine($"TradeCord\\Backup\\{user}", origPath.Split('\\')[2]);
System.IO.File.Move(origPath, tradedPath);
TradeExtensions.TradeCordPath.Remove(origPath);
}
}
public IActionResult Trader([FromForm] Trader trader, PerfilTrader perfil)
{
Login login = new Login();
login = _loginUsuario.GetLogin(login);
trader.UsuarioID = login.UsuarioID;
List <Trader> traders = new List <Trader>();
traders.Add(trader);
foreach (Trader t in traders)
{
trader = t;
}
if (perfil.Nome.Equals(trader.PerfilTrader))
{
trader.PerfilTraderID = perfil.PerfilTraderID;
}
_traderRep.InserirDadosTrader(trader);
//MENSAGEM TRADER INSERIDO
return(View());
}
private static void LoadTradersFromNodes(XmlNodeList nodes)
{
foreach (XmlNode node in nodes)
{
Trader trader =
new Trader(node.AttributeAsInt("ID"),
node.SelectSingleNode("./Name")?.InnerText ?? "");
foreach (XmlNode childNode in node.SelectNodes("./InventoryItems/Item"))
{
int quantity = childNode.AttributeAsInt("Quantity");
for (int i = 0; i < quantity; i++)
{
trader.AddItemToInventory(ItemFactory.CreateGameItem(childNode.AttributeAsInt("ID")));
}
}
_traders.Add(trader);
}
}
/// <summary>
/// 计算平仓比率:需要平仓的份数
/// 每份合约得到的资金数=释放的维持保证金-买入价格
/// </summary>
/// <param name="up"></param>
/// <returns></returns>
decimal CalRatio(Trader t, PositionSummary up, decimal needed)
{
try
{
if (up == null)
{
Log.Info(string.Format("计算比例时合约为空:仓{0}-人{1}", up.CName, t.Name));
return(0);
}
var cp = Market.Get(up.CName).NewestDealPrice;
var pp = up.GetReleasePerPos((a) => { return(model.Contracts.Where(c => c.Code == a).FirstOrDefault()); }, cp);
var r = needed / pp;
Log.Info(string.Format("平仓份数:{0}-{1}-价{2}-释{3}-份{4}", t.Name, up.CName, cp, pp, r));
return(r);
}
catch (Exception ex)
{
Log.Error(ex);
return(0);
}
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
if (obj.GetType() != this.GetType())
{
return(false);
}
BoxedPosition other = (BoxedPosition)obj;
return(Trader.Equals(other.Trader) &&
Symbol.Equals(other.Symbol) &&
Qty.Equals(other.qty));
}
public void MainLoop()
{
while (true)
{
Decision = Refreash();
if (Trader.CheckTrad(Decision, Ticker.CurrentValue) == ExchangeStatus.buy && firstBuyFlag)
{
firstBuyFlag = false;
}
RefreashedEventArgs refreashEA = new RefreashedEventArgs(Ticker.CurrentValue, Ticker.LastValue, Ticker.Status, Decision,
Trader.CurrentBitcoinNum, Trader.CurrentCashNum);
onRefreash(refreashEA);
if (IsAlert && ((AlertUpper != 0 && Ticker.CurrentValue >= AlertUpper) || (AlertLower != 0 && Ticker.CurrentValue <= AlertLower)))
{
AlertEventArgs alertEA = new AlertEventArgs(Ticker.CurrentValue, AlertUpper, AlertLower);
alerted(alertEA);
}
Thread.Sleep((int)SleepTime);
}
}
public static decimal TransBonus(Trader t, List <string> invitedNames)
{
if (t == null || invitedNames == null || invitedNames.Count == 0)
{
return(0);
}
decimal result = 0;
foreach (var v in invitedNames)
{
if (string.IsNullOrEmpty(v))
{
continue;
}
bool r = TraderService.OperateInvitorBonus(t, InvitorBonusInCny, "被推荐人" + v);
result += InvitorBonusInCny;
log.Info(string.Format("{0}成功推荐了{1},获取奖金{2}元", t.Name, v, InvitorBonusInCny));
}
return(result);
}
static TraderFactory()
{
Trader susan = new Trader("Susan");
susan.AddItemToInventory(ItemFactory.CreateGameItem(1001));
susan.AddItemToInventory(ItemFactory.CreateGameItem(1003));
susan.AddItemToInventory(ItemFactory.CreateGameItem(1004));
Trader farmerTed = new Trader("Farmer Ted");
farmerTed.AddItemToInventory(ItemFactory.CreateGameItem(1001));
Trader peteTheHerbalist = new Trader("Pete the Herbalist");
peteTheHerbalist.AddItemToInventory(ItemFactory.CreateGameItem(1001));
peteTheHerbalist.AddItemToInventory(ItemFactory.CreateGameItem(1001));
AddTraderToList(susan);
AddTraderToList(farmerTed);
AddTraderToList(peteTheHerbalist);
}
/// <summary>
/// Display the TradeDialogBox and allow the user to trade.
/// </summary>
/// <param name="tradeShip"></param>
public void ShowTradeDialogBox(TraderShipController tradeShip)
{
DialogBoxManager dbm = GameObject.Find("Dialog Boxes").GetComponent <DialogBoxManager>();
Trader playerTrader = Trader.FromPlayer(World.Current.Wallet[tradeShip.Trader.Currency.Name]);
Trade trade = new Trade(playerTrader, tradeShip.Trader);
dbm.dialogBoxTrade.SetupTrade(trade);
dbm.dialogBoxTrade.TradeCancelled = () =>
{
tradeShip.TradeCompleted = true;
TradeShips.Remove(tradeShip);
};
dbm.dialogBoxTrade.TradeCompleted = () =>
{
tradeShip.TradeCompleted = true;
TrasfertTradedItems(trade, tradeShip.LandingCoordinates);
TradeShips.Remove(tradeShip);
};
dbm.dialogBoxTrade.ShowDialog();
}
public IEnumerable <ClientForTraders> ClientsForTrader(int id, string filter)
{
TraderService.CheckCredentials(id);
Trader trader = TraderService.FindEntity(id);
TraderService.CollectCl(trader);
var ret = new List <ClientForTraders>();
Func <ClientForTraders, bool> test = filter.ToTest <ClientForTraders>();
foreach (CommercialLink cl in trader.CommercialLink)
{
PrivateClient privateClient = ClientService.EntityToDTO(cl.Client);
ClientForTraders clientForTrader = privateClient.CastAs <ClientForTraders>();
clientForTrader.CommercialRelation = ClService.GetClStatus(cl);
if (test(clientForTrader))
{
ret.Add(clientForTrader);
}
}
return(ret);
}
public async Task <ActionResult <string> > Put([FromBody] TraderToUpdate trader)
{
Trader traderToUpdate = null;
try
{
traderToUpdate = contextProvider.Traders.Find(trader.TraderId);
}
catch
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (traderToUpdate != null || trader != null)
{
traderToUpdate.FirstName = trader.FirstName;
traderToUpdate.LastName = trader.LastName;
traderToUpdate.PhoneNumber = trader.PhoneNumber;
}
else
{
return(BadRequest());
}
try
{
contextProvider.SaveChanges();
}
catch (Exception)
{
return(BadRequest());
}
return("Trader updated");
}
/// <summary>
/// 如果是平仓,直接支付;否则检查保证金是否足够
/// </summary>
/// <param name="t"></param>
/// <param name="delta"></param>
/// <param name="m"></param>
/// <param name="o"></param>
/// <returns></returns>
public static bool BailPay(this Trader t, decimal delta, Market m, Order o, AccountChangeType type)
{
lock (t.Account.BailAccount)
{
SystemAccount.Instance.Log.Info(string.Format("支付(可能借款):{0}-线程{1}-委托{2}", DateTime.Now.ToString("HH:mm:ss.fff"),
Thread.CurrentThread.ManagedThreadId, o == null?"":o.Id.ToString()));
if (o != null && o.OrderType == OrderType.平仓)
{
//系统借款记录处理
if (t.Account.BailAccount.Sum < delta)
{
var needed = delta * (TraderService.CommissionRatio + 1) - t.Account.BailAccount.Sum;
var borrowResult = SystemAccount.Instance.Borrow(needed, o);
}
var r = t.Account.BailAccount.Sub(delta);
TraderService.OperateAccount(t, delta, type, "system", o, t.Account.BailAccount.Total);
return(r);
}
else
{
var maintain = GetMaintain(t, m);
var remain = t.Account.BailAccount.Sum - maintain;
if (t.Account.BailAccount.Sum < delta || remain < delta)
{
//执行保证金自动转入
var d1 = delta - t.Account.BailAccount.Sum;
var d2 = delta - remain;
var d = d1 >= d2 ? d1 : d2;
var tr = TraderService.OperateAddBailFromCache(t, d, o);
if (!tr)
{
return(false);
}
}
var r = t.Account.BailAccount.Sub(delta);//划转保证金
TraderService.OperateAccount(t, delta, type, "system", o, t.Account.BailAccount.Total);
return(r);
}
}
}
public ActionResult Index()
{
Trader loggedInUser = GetLoggedTraderOrUser();
if (loggedInUser != null) // if not admin
{
int userType = loggedInUser.TypeFlag;
if (userType == 1)
{
var um = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(new ApplicationDbContext()));
var user = um.FindById(User.Identity.GetUserId());
if (user.MainUser)
{
return(EditSuperTraderProfile());
}
else
{
return(View("../Redirector/NoPermissionToEditProfile"));
}
}
else if (userType == 2)
{
return(EditTraderProfile());
}
else if (userType == 3)
{
return(EditUserProfile());
}
else
{
return(View());
}
}
else
{
return(View("../Redirector/NoPermissionToEditProfile"));
}
}
/// <summary>
/// call this to open a dialog to formulate a new trade
/// </summary>
/// <param name="gameData"></param>
/// <param name="client"></param>
/// <param name="ID"></param>
/// <param name="targetID"></param>
public TradeDialog(GameData gameData, WormholeClient client, int ID, int targetID)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this._gameData = gameData;
this._client = client;
this._thisPlayerID = ID;
this._targetPlayerID = targetID;
this.Text += _gameData.PlayerList[targetID].Name;
this._exMin = _gameData.PlayerList[ID].Fleet.ExMineral;
this._exOrg = _gameData.PlayerList[ID].Fleet.ExOrganic;
this._exEng = _gameData.PlayerList[ID].Fleet.ExEnergy;
this.surplusMineral.Text = _exMin.ToString();
this.surplusOrganic.Text = _exOrg.ToString();
this.surplusEnergy.Text = _exEng.ToString();
//this.offerMineral.Maximum = _exMin;
//this.offerOrganic.Maximum = _exOrg;
//this.offerEnergy.Maximum = _exEng;
this.AcceptButton = this.bnOffer;
this.bnAccept.Enabled = false;
this.bnReject.Enabled = false;
Fleet fleet = _gameData.PlayerList[ID].Fleet;
for (int i = 0; i < fleet.Count; i++)
{
if (fleet[i].Type == Ship.ShipType.Trader)
{
Trader trader = (Trader)fleet[i];
this.listBox1.Items.Add(trader.Trade);
}
}
}
public void RandomSignal()
{
var now = new DateTime(2013, 9, 10);
var history = new List <StockMessage>
{
new StockMessage {
Symbol = "PACQU", Ask = 24.0, Bid = 13.50, Time = now.AddMinutes(-5)
},
new StockMessage {
Symbol = "PACQU", Ask = 27.84, Bid = 13.50, Time = now.AddMinutes(-4)
},
new StockMessage {
Symbol = "PACQU", Ask = 22.50, Bid = 13.50, Time = now.AddMinutes(-3)
},
new StockMessage {
Symbol = "PACQU", Ask = 17.85, Bid = 13.50, Time = now.AddMinutes(-2)
},
new StockMessage {
Symbol = "PACQU", Ask = 13.79, Bid = 11.00, Time = now.AddMinutes(-1)
}
};
var random = new RandomSignal("PACQU");
var portfolio = new Portfolio();
var stockBroker = new StubStockbroker(history);
var trader = new Trader(stockBroker, portfolio);
trader.Register(random);
stockBroker.CurrentTime = now.AddMinutes(-5);
for (int i = 0; i < 5; i++)
{
stockBroker.CurrentTime = stockBroker.CurrentTime.AddMinutes(1);
trader.Trade();
}
//trader.Balance.Should().BeGreaterThan(0);
}
public void AddDeal_CorrectDeal_AreEqualData()
{
//Arrange
var seller = new Trader()
{
Name = "NameSeller",
Surname = "SurnameSeller",
PhoneNumber = "phoneNumberSeller",
Balance = 0,
};
var share = new Share()
{
Name = "TestSare",
Owner = seller,
Price = 100
};
seller.SharesCollection.Add(share);
var buyer = new Trader()
{
Name = "NameBuyer",
Surname = "SurnameBuyer",
PhoneNumber = "phoneNumberBuyer",
Balance = 80,
};
//Act
_businessService.AddDeal(buyer, seller, share);
//Assert
Assert.AreEqual(seller.SharesCollection.Contains(share), false);
Assert.AreEqual(buyer.SharesCollection.Contains(share), true);
Assert.AreEqual(TraderService.GetZone(seller), Zone.Green);
Assert.AreEqual(TraderService.GetZone(buyer), Zone.Black);
Assert.AreEqual(share.Owner, buyer);
Assert.AreEqual(buyer.Balance, -20);
Assert.AreEqual(seller.Balance, 100);
}
public void TestTraderIdConcurrency()
{
var threads = new List <Thread>();
var threadCount = 100;
for (var i = 0; i < threadCount; ++i)
{
var thread = new Thread(() =>
{
trader = Market.GetNewTrader().Second;
});
thread.Start();
threads.Add(thread);
}
foreach (var thread in threads)
{
thread.Join();
}
Trader currentMostTrader = Market.GetNewTrader().Second;
Assert.AreEqual("Trader" + threadCount, currentMostTrader.ID);
}
public void CallTradeShipTest(Furniture landingPad)
{
// Currently not using any logic to select a trader
TraderPrototype prototype = PrototypeManager.Trader.GetPrototype(Random.Range(0, PrototypeManager.Trader.Count - 1));
Trader trader = prototype.CreateTrader();
GameObject go = new GameObject(trader.Name);
go.transform.parent = transform;
TraderShipController controller = go.AddComponent <TraderShipController>();
controller.Trader = trader;
controller.Speed = 5f;
go.transform.position = new Vector3(-10, 50, 0);
controller.LandingCoordinates = new Vector3(landingPad.Tile.X + 1, landingPad.Tile.Y + 1, 0);
controller.LeavingCoordinates = new Vector3(100, 50, 0);
go.transform.localScale = new Vector3(1, 1, 1);
SpriteRenderer spriteRenderer = go.AddComponent <SpriteRenderer>();
spriteRenderer.sprite = SpriteManager.current.GetSprite("Trader", "BasicHaulShip");
spriteRenderer.sortingLayerName = "TradeShip";
}
private void OnItemMoved(Trader trader, TradeItem item, bool modified, int difference)
{
if (!modified && item.Stack > 0)
{
InventoryHandler.SendExchangeObjectAddedMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectAddedMessage(Receiver.Character.Client, Receiver != trader, item);
}
else if (item.Stack <= 0)
{
InventoryHandler.SendExchangeObjectRemovedMessage(Crafter.Character.Client, Crafter != trader, item.Guid);
InventoryHandler.SendExchangeObjectRemovedMessage(Receiver.Character.Client, Receiver != trader, item.Guid);
}
else
{
InventoryHandler.SendExchangeObjectModifiedMessage(Crafter.Character.Client, Crafter != trader, item);
InventoryHandler.SendExchangeObjectModifiedMessage(Receiver.Character.Client, Receiver != trader, item);
}
FirstTrader.ToggleReady(false);
SecondTrader.ToggleReady(false);
}
public void ShouldChangeShare()
{
// Arrange
ShareService transactionService = new ShareService(
this.provider,
this.shareRep,
this.traderRep,
this.logger);
Trader owner = new Trader()
{
name = "Evgeniy",
surname = "Nikulin",
};
Share oldShare = new Share()
{
name = "Ubisoft",
price = 50m,
quantity = 10,
ownerId = 1,
};
traderRep.GetTrader(Arg.Any <int>()).Returns(owner);
shareRep.GetShare(Arg.Any <int>()).Returns(oldShare);
// Act
string shareId = "1";
string newName = "Microsoft";
string newPrice = "100";
string ownerId = "1";
transactionService.ChangeShare(shareId, newName, newPrice, ownerId);
// Assert
shareRep.Received(1).Push(Arg.Any <Share>());
shareRep.Received(1).SaveChanges();
logger.Info($"Share {oldShare.name} changed to {newName} with {newPrice} price at {owner.name} {owner.surname} trader");
provider.Received(1).GetPhrase(Phrase.Success);
}
static async Task Main(string[] args)
{
try
{
var stocks = new[] { "qqq", "msft", "fb", "aapl" };
var task = new List <Task>();
var alpacaClient = TradingClientFactory.GetTradingClient(TradingClientType.Alpaca);
foreach (var stock in stocks)
{
var trader = new Trader(StockDataReaderFactory.GetStockDataReader(StockDataReaderType.Yahoo, stock),
alpacaClient, stock);
task.Add(Task.Run(() => trader.HandleOrders()));
}
await Task.WhenAll(task.ToArray());
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
/*var stocks = new[] {"qqq", "msft", "fb", "aapl"};
* var task = new List<Task>();
* foreach (var stock in stocks)
* {
* task.Add(Task.Run(() => ScrapperFactory.GetScrapper(ScrapperType.Yahoo, stock).ReadStocksValue()));
* }
*
* await Task.WhenAll(task.ToArray());*/
/*var watch = System.Diagnostics.Stopwatch.StartNew();
*
* Console.WriteLine($"Profit is {Test()}");
* watch.Stop();
* var elapsedMs = watch.ElapsedMilliseconds;
* Console.WriteLine($"time: { elapsedMs}");*/
}
private void OnItemMoved(Trader trader, TradeItem item, bool modified, int difference)
{
if (m_decrafting)
{
return;
}
if (!modified && item.Stack > 0)
{
InventoryHandler.SendExchangeObjectAddedMessage(Character.Client, false, item);
}
else if (item.Stack <= 0)
{
InventoryHandler.SendExchangeObjectRemovedMessage(Character.Client, false, item.Guid);
}
else
{
InventoryHandler.SendExchangeObjectModifiedMessage(Character.Client, false, item);
}
}
public static TradingHistory ToTradingHistory(
this TradingHistoryModel tradingHistory,
Auctioneer auctioneer,
Trader trader,
Lot lot)
{
if (tradingHistory == null)
{
throw new ArgumentNullException(nameof(tradingHistory));
}
if (auctioneer == null)
{
throw new ArgumentNullException(nameof(auctioneer));
}
if (trader == null)
{
throw new ArgumentNullException(nameof(trader));
}
if (lot == null)
{
throw new ArgumentNullException(nameof(lot));
}
return(new TradingHistory
{
AuctioneerId = auctioneer.Id,
LotId = lot.Id,
TraderId = trader.Id,
BidTime = tradingHistory.BidTime,
BidOrder = tradingHistory.BidOrder,
RecordedPrice = tradingHistory.RecordedPrice,
Auctioneer = auctioneer,
Lot = lot,
Trader = trader
});
}
public WtsWrapper(Construct wts_, Trader trdr_, TraderArgs args_)
{
Weights = wts_;
Trader = trdr_;
Args = args_;
}
public void AddToTraders(Trader trader)
{
base.AddObject("Traders", trader);
}
public void balanceAccessorModifierTest()
{
Trader t = new Trader();
t.setBalance(1050);
Assert.AreEqual(t.getBalance(), 1050);
}
internal void AddWts(Construct construct_, TraderArgs args_, Trader trader_)
{
checkedListBox2.Items.Add(new WtsWrapper(construct_,trader_,args_) , true);
}
public static Trader CreateTrader(int ID, int currentInvoiceCounter, string countryId, byte[] rowVersion)
{
Trader trader = new Trader();
trader.Id = ID;
trader.CurrentInvoiceCounter = currentInvoiceCounter;
trader.CountryId = countryId;
trader.RowVersion = rowVersion;
return trader;
}
private void initBehaviourModel(string prof)
{
switch(prof)
{
case "craftsman":
Behaviour = new Craftsman(this, ProfLevels[prof]);
break;
case "farmer":
Behaviour = new Farmer(this, ProfLevels[prof]);
break;
case "guardian":
Behaviour = new Guardian(this, ProfLevels[prof]);
break;
case "thief":
Behaviour = new Thief(this, ProfLevels[prof]);
break;
case "trader":
Behaviour = new Trader(this, ProfLevels[prof]);
break;
default: throw new Exception("Wrong proffession");
}
Log.Add("citizens:Human " + Name + " behaviour: " + prof);
}
public void receiveTest()
{
Trader t = new Trader("Player1", 1500);
t.receive(55);
Assert.AreEqual(t.getBalance(), 1555);
}
public void payTest()
{
Trader t = new Trader("Player1", 1500);
t.pay(111);
Assert.AreEqual(t.getBalance(), 1500 - 111);
}
public void propetyTest()
{
Trader t = new Trader();
Property p = new Property("Queen Street");
t.obtainProperty(ref p);
Assert.Contains(p, t.getPropertiesOwned());
}
public void nameAccessorModifierTest()
{
Trader t = new Trader();
t.setName("Banker");
Assert.AreEqual(t.getName(), "Banker");
}
public void SenderClosedEventHandle(object sender, Trader.Helper.Common.SenderClosedEventArgs e)
{
this.EnqueueDisconnectSession(e.Session);
}
public void outputToString()
{
Trader t = new Trader();
Console.Write(t);
}
public void BeforeAll()
{
_trader = new Trader();
}
