public async Task <IHttpActionResult> PostTraderInfo(TraderInfo traderInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TraderInfoes.Add(traderInfo);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (TraderInfoExists(traderInfo.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = traderInfo.Id }, traderInfo));
}
public bool TraderInfoValidate(TraderInfo traderInfo)
{
bool validFirstName = traderInfo.Name.All(c => char.IsLetter(c));
if (!validFirstName)
{
Console.WriteLine("Wrong first name. Operation cancel.");
return(false);
}
bool validLastName = traderInfo.Surname.All(c => char.IsLetter(c));
if (!validLastName)
{
Console.WriteLine("Wrong last name. Operation cancel.");
return(false);
}
bool validPhone = traderInfo.PhoneNumber.All(c => char.IsDigit(c)) && traderInfo.PhoneNumber.Length < 9;
if (!validPhone)
{
Console.WriteLine("Wrong phone. Operation cancel.");
return(false);
}
return(true);
}
public ActionResult AddClient(string name, string surname, string phone)
{
var newTrader = new TraderInfo()
{
Name = name,
Surname = surname,
PhoneNumber = phone,
Balance = 1000M
};
if (!validator.TraderInfoValidate(newTrader))
{
return(StatusCode(400, "Bad values for registration new trader"));
}
try
{
tradersService.RegisterNewTrader(newTrader);
}
catch (ArgumentException)
{
return(StatusCode(400, "This trader has been registered)"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok("New trader added succesfully"));
}
public async Task <IHttpActionResult> PutTraderInfo(int id, TraderInfo traderInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != traderInfo.Id)
{
return(BadRequest());
}
db.Entry(traderInfo).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TraderInfoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public DeliverGoods(Actor self)
{
trader = self.Trait<Trader>();
traderInfo = self.Info.Traits.Get<TraderInfo>();
move = self.Trait<IMove>();
pathFinder = self.World.WorldActor.Trait<IPathFinder>();
}
private void ModificationTradersStock()
{
logger.Info("Adding stock to trader");
Console.WriteLine("Please input traders name:");
string traderName = Console.ReadLine();
Console.WriteLine("Please input stock name:");
string stockName = Console.ReadLine();
if (!validator.StockToTraderValidate(traderName, stockName))
{
Console.WriteLine($"Can`t add stock {stockName} to trader {traderName}");
logger.Info($"Can`t add stock {stockName} to trader {traderName}");
return;
}
var trader = traders.GetTraderByName(traderName);
var stock = stockService.GetStockByName(stockName);
Console.WriteLine("Please input count of stocks:");
string countStock = Console.ReadLine();
bool validCount = Int32.TryParse(countStock, out int count);
if (!validCount)
{
Console.WriteLine("Wrong count of stock. Operation cancel.");
return;
}
logger.Info($"Try to add stock = {stock.Name} to trader {trader.Name}");
try
{
TraderInfo traderInfo = new TraderInfo
{
Id = trader.Id,
Name = trader.Name,
};
StockInfo stockInfo = new StockInfo
{
Id = stock.Id,
Name = stock.Name,
Count = count,
PricePerItem = stock.PricePerItem
};
var id = traderStocks.AddNewStockToTrader(traderInfo, stockInfo);
Console.WriteLine("Stock added to trader succesfully");
logger.Info($"Stock {stockInfo.Name} added to trader {traderInfo.Name} succesfully");
}
catch (ArgumentException e)
{
Console.WriteLine($"{e.Message} Operation cancel.");
logger.Info("Stock has not been added");
logger.Error(e);
}
}
public async Task <IHttpActionResult> GetTraderInfo(int id)
{
TraderInfo traderInfo = await db.TraderInfoes.FindAsync(id);
if (traderInfo == null)
{
return(NotFound());
}
return(Ok(traderInfo));
}
public string RegisterTrader(TraderInfo traderInfo)
{
var content = new StringContent(JsonConvert.SerializeObject(traderInfo), Encoding.UTF8, "application/json");
var response = this.httpClient.PostAsync(this.baseAddress + "clients/add", content).Result;
var responseBody = response.Content.ReadAsStringAsync().Result;
if (response.IsSuccessStatusCode)
{
return(responseBody);
}
throw new Exception(responseBody);
}
public IActionResult RegisterUser([FromBody] TraderInfo traderInfo)
{
try
{
this.service.RegisterNewUser(traderInfo);
return(Ok("User successfully added"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult Remove([FromBody] TraderInfo traderInfo)
{
try
{
this.service.RemoveUser(traderInfo);
return(Ok("Successfully removed user from database"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IHttpActionResult> PostTraderInfo(TraderInfo traderInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TraderInfoes.Add(traderInfo);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = traderInfo.Id }, traderInfo));
}
public override void RemoveUser(TraderInfo info)
{
try
{
base.RemoveUser(info);
Logger.FileLogger.Info($"Removed user {info.FirstName} {info.LastName}");
}
catch (Exception ex)
{
Logger.FileLogger.Error(ex);
throw ex;
}
}
public async Task <IHttpActionResult> DeleteTraderInfo(int id)
{
TraderInfo traderInfo = await db.TraderInfoes.FindAsync(id);
if (traderInfo == null)
{
return(NotFound());
}
db.TraderInfoes.Remove(traderInfo);
await db.SaveChangesAsync();
return(Ok(traderInfo));
}
public override int RegisterNewUser(TraderInfo info)
{
try
{
var traderId = base.RegisterNewUser(info);
Logger.FileLogger.Info("Registered new user");
return(traderId);
}
catch (Exception ex)
{
Logger.FileLogger.Error(ex);
throw ex;
}
}
public void ShouldNotRegisterNewTraderWithEmptySurname()
{
// Arrange
TraderService tradersService = new TraderService(this.repository);
TraderInfo info = new TraderInfo
{
FirstName = "Artem",
LastName = string.Empty,
PhoneNumber = "79998887766",
Balance = 100
};
// Act
tradersService.RegisterNewUser(info);
}
public void ShouldNotRegisterNewTraderWithIncorrectPhoneNumber()
{
// Arrange
TraderService tradersService = new TraderService(this.repository);
TraderInfo info = new TraderInfo
{
FirstName = "Artem",
LastName = "Lozhechkin",
PhoneNumber = "999asd9213",
Balance = 100
};
// Act
tradersService.RegisterNewUser(info);
}
private void TraderInfoHandler(TraderInfo traderInfo)
{
if (!traderInfo.Symbol.Equals(Smbl))
{
return;
}
if (Smbl.IsSpot)
{
Console.WriteLine($"Base currency balance: {traderInfo.TraderBalance2}");
Console.WriteLine($"Quote currency balance: {traderInfo.TraderBalance}");
}
else
{
Console.WriteLine($"Trader balance: {traderInfo.TraderBalance}");
}
}
public void ShouldNotRegisterNewTraderIfExists()
{
//Arrange
TraderInfo trader = new TraderInfo();
trader.Name = "Monica";
trader.Surname = "Belucci";
trader.PhoneNumber = "+79110000000";
trader.Balance = 143000.0M;
//Act
tradersService.RegisterNewTrader(trader);
traderTableRepository.Contains(Arg.Is <TraderEntityDB>(
w => w.Name == trader.Name &&
w.Surname == trader.Surname &&
w.PhoneNumber == trader.PhoneNumber &&
w.Balance == trader.Balance)).Returns(true);
tradersService.RegisterNewTrader(trader);
}
public ActionResult AddStock(string traderName, string stockName, string count)
{
if (!validator.StockToTraderValidate(traderName, stockName))
{
return(StatusCode(400, $"Can`t add stock {stockName} to trader {traderName}"));
}
var trader = tradersService.GetTraderByName(traderName);
var stock = stockService.GetStockByName(stockName);
bool validCount = Int32.TryParse(count, out int countStock);
if (!validCount)
{
return(StatusCode(400, "Bad count value. Operation cancel"));
}
TraderInfo traderInfo = new TraderInfo
{
Id = trader.Id,
Name = trader.Name,
};
StockInfo stockInfo = new StockInfo
{
Id = stock.Id,
Name = stock.Name,
Count = countStock,
PricePerItem = stock.PricePerItem
};
try
{
traderStocksService.AddNewStockToTrader(traderInfo, stockInfo);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok("Stock to trader added succesfully"));
}
public void ShouldAddStockToTrader()
{
//Arrange
TraderInfo trader = new TraderInfo();
StockInfo stock = new StockInfo();
trader.Id = 2;
stock.Id = 3;
stock.Count = 2;
//Act
var traderStockID = traderStockService.AddNewStockToTrader(trader, stock);
//Assert
traderStocksTableRepository.Received(1).Add(Arg.Is <StockToTraderEntityDB>(
w => w.TraderId == trader.Id &&
w.StockId == stock.Id &&
w.StockCount == stock.Count));
traderStocksTableRepository.Received(1).SaveChanges();
}
public int AddNewStockToTrader(TraderInfo trader, StockInfo stock)
{
var entityToAdd = new StockToTraderEntityDB()
{
TraderId = trader.Id,
StockId = stock.Id,
StockCount = stock.Count,
PricePerItem = stock.PricePerItem
};
if (this.traderStockTableRepository.Contains(entityToAdd))
{
throw new ArgumentException($"This stock {stock.Name} has been added for trader {trader.Name} {trader.Surname}.");
}
this.traderStockTableRepository.Add(entityToAdd);
this.traderStockTableRepository.SaveChanges();
return(entityToAdd.Id);
}
public int RegisterNewTrader(TraderInfo trader)
{
var entityToAdd = new TraderEntityDB()
{
CreatedAt = DateTime.Now,
Name = trader.Name,
Surname = trader.Surname,
PhoneNumber = trader.PhoneNumber,
Balance = trader.Balance
};
if (traderTableRepository.Contains(entityToAdd))
{
throw new ArgumentException($"This trader {entityToAdd.Name} {entityToAdd.Surname} has been registered.");
}
traderTableRepository.Add(entityToAdd);
traderTableRepository.SaveChanges();
return(entityToAdd.Id);
}
private void TraderRegistartion()
{
logger.Info("Try to registration new trader");
Console.WriteLine("Please input first name:");
string firstName = Console.ReadLine();
Console.WriteLine("Please input last name:");
string lastName = Console.ReadLine();
Console.WriteLine("Please input phone:");
string phone = Console.ReadLine();
var newTrader = new TraderInfo()
{
Name = firstName,
Surname = lastName,
PhoneNumber = phone,
Balance = 1000M
};
if (!validator.TraderInfoValidate(newTrader))
{
logger.Info($"Registration trader name = {newTrader.Name} surname = {newTrader.Surname} phone = {newTrader.PhoneNumber} cancel");
return;
}
try
{
traders.RegisterNewTrader(newTrader);
logger.Info("Registration new trader was succesfully");
logger.Info($"New trader name = {firstName}, surname = {lastName}");
Console.WriteLine("Registration was succesfully");
}
catch (ArgumentException e)
{
Console.WriteLine($"{e.Message} Operation cancel.");
logger.Info($"New trader name = {firstName}, surname = {lastName} wasnt registration");
logger.Error(e);
}
}
public void ShouldRegisterNewTrader()
{
//Arrange
TraderInfo trader = new TraderInfo();
trader.Name = "Monica";
trader.Surname = "Belucci";
trader.PhoneNumber = "+79110000000";
trader.Balance = 143000.0M;
//Act
var traderID = tradersService.RegisterNewTrader(trader);
//Assert
traderTableRepository.Received(1).Add(Arg.Is <TraderEntityDB>(
w => w.Name == trader.Name &&
w.Surname == trader.Surname &&
w.PhoneNumber == trader.PhoneNumber &&
w.Balance == trader.Balance));
traderTableRepository.Received(1).SaveChanges();
}
public void ShouldNotAddNewStockToTraderIfExists()
{
//Arrange
TraderInfo trader = new TraderInfo();
StockInfo stock = new StockInfo();
trader.Id = 2;
trader.Name = "Monica";
trader.Surname = "Belucci";
trader.PhoneNumber = "+79110000000";
stock.Id = 3;
stock.Name = "Intel";
stock.Count = 2;
//Act
var traderStockID = traderStockService.AddNewStockToTrader(trader, stock);
traderStocksTableRepository.Contains(Arg.Is <StockToTraderEntityDB>(
w => w.TraderId == trader.Id &&
w.StockId == stock.Id)).Returns(true);
traderStockService.AddNewStockToTrader(trader, stock);
}
public void ShouldNotRegisterTraderIfExists()
{
// Arrange
TraderService tradersService = new TraderService(this.repository);
TraderInfo info = new TraderInfo
{
FirstName = "Vasiliy",
LastName = "Vasiliev",
PhoneNumber = "1234557",
Balance = -100
};
// Act
tradersService.RegisterNewUser(info);
this.repository.Contains(Arg.Is<TraderEntity>(
t => t.FirstName == info.FirstName
&& t.LastName == info.LastName
&& t.PhoneNumber == info.PhoneNumber
&& t.Balance == info.Balance)).Returns(true);
tradersService.RegisterNewUser(info);
}
static void Main(string[] args)
{
TraderInfo traderInfo = new TraderInfo();
traderInfo.BrokerID = "88888";
traderInfo.UserID = "";
traderInfo.InvestorID = "";
traderInfo.Password = "";
traderInfo.FrontID = "tcp://114.80.55.115:42205";
traderInfo.FlowPath = "./trader/";
traderInfo.PrivateTopicResumeType = (int)THOST_TE_RESUME_TYPE.THOST_TERT_RESTART;
traderInfo.PublicTopicResumeType = (int)THOST_TE_RESUME_TYPE.THOST_TERT_RESTART;
traderInfo.AppID = "";
traderInfo.AuthCode = "";
traderInfo.AuthKind = 1;
trader = new TraderWrapper(traderInfo);
trader.OnFrontConnected += Trader_OnFrontConnected;;
trader.OnRspUserLogin += Trader_OnRspUserLogin;
trader.OnRspSettlementInfoConfirm += Trader_OnRspSettlementInfoConfirm;
trader.Connect();
Console.Read();
}
public void ShouldRegisterNewTrader()
{
// Arrange
TraderService tradersService = new TraderService(this.repository);
TraderInfo info = new TraderInfo
{
FirstName = "Artem",
LastName = "Lozhechkin",
PhoneNumber = "79998887766",
Balance = 100
};
// Act
tradersService.RegisterNewUser(info);
// Assert
this.repository.Received(1).Add(Arg.Is<TraderEntity>
(w => w.FirstName == info.FirstName
&& w.LastName == info.LastName
&& w.PhoneNumber == info.PhoneNumber
&& w.Balance == info.Balance));
this.repository.Received(1).SaveChanges();
}
/// <summary>
/// 新增
/// </summary>
public int Add(TraderInfo model, IDbTransaction transaction = null)
{
return(_traderRepository.Insert(model, transaction));
}
/// <summary>
/// 更新一条数据
/// </summary>
public bool Update(TraderInfo model, IDbTransaction transaction = null)
{
return(_traderRepository.Update(model, transaction));
}
