public void ShouldOpenAccountForNewClient()
{
//Arrange
ClientsService clientsService = new ClientsService(clientsTableRepository, accountTableRepository, stockPriceTableRepository, stockOfClientTableRepository, logger);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "John";
args.Surname = "Jaymson";
args.PhoneNumber = "+78908901234";
AccountRegistrationInfo argsForAcc = new AccountRegistrationInfo();
argsForAcc.Balance = 10m;
argsForAcc.Stocks = new List <StockOfClientEntity>();
argsForAcc.Zone = "white";
//Act
argsForAcc.ClientId = clientsService.RegisterNewClient(args);
clientsService.CreateNewAccountForNewClient(argsForAcc);
//Assert
accountTableRepository.Received(1).Add(Arg.Is <AccountEntity>(
w => w.Balance == argsForAcc.Balance &&
w.ClientId == argsForAcc.ClientId &&
w.Stocks == argsForAcc.Stocks &&
w.Zone == argsForAcc.Zone));
accountTableRepository.Received(1).SaveChanges();
}
public void ShouldNotRegisterNewClientIfItExists()
{
// Arrange
this.clientTableRepository = Substitute.For <IClientTableRepository>();
ClientsService clientsService = new ClientsService(this.clientTableRepository);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.LastName = "Michael";
args.FirstName = "Lomonosov";
args.PhoneNumber = "+79521234567";
args.Status = true;
// Act
clientsService.RegisterNewClient(args);
this.clientTableRepository.Contains(Arg.Is <ClientEntity>(
c => c.LastName == args.LastName &&
c.FirstName == args.FirstName &&
c.PhoneNumber == args.PhoneNumber &&
c.Status == args.Status)).Returns(true);
clientsService.RegisterNewClient(args);
// Assert
}
private void AddNewClient()
{
Console.WriteLine();
Console.Write("Enter name for new client: ");
string name = Console.ReadLine();
Console.Write("Enter surname for new client: ");
string surname = Console.ReadLine();
Console.Write("Enter phone number for new client: ");
string phonenumber = Console.ReadLine();
Console.Write("Enter account balance for new client: ");
decimal accountbalance = GetNum();
ClientRegistrationInfo newClient = new ClientRegistrationInfo
{
Name = name,
Surname = surname,
PhoneNumber = phonenumber,
AccountBalance = accountbalance
};
string result = clientRequests.AddNewClient(newClient);
Console.WriteLine("ID of registered client is " + result);
}
internal static void Connect()
{
Client = new SimpleTcpClient();
Client.DataReceived += ClientOnDataReceived;
Client.DelimiterDataReceived += ClientOnDelimiterDataReceived;
//connection lost, let's try to reconnect
while (Client.TcpClient == null || !Client.TcpClient.Connected)
{
try
{
Client.Connect(Settings.ServerIP, Settings.Port);
var regInfo = new ClientRegistrationInfo {
ClientId = ClientId
};
var json = JsonConvert.SerializeObject(regInfo);
Client.WriteLine(json);
}
catch (Exception ex)
{
while (ex.InnerException != null)
{
ex = ex.InnerException;
}
Console.WriteLine($"Error in reconnect: {ex.Message}\n{ex.StackTrace}\n");
}
Thread.Sleep(100);
}
}
public HttpResponseMessage Post([FromBody] ClientRegistrationInfo clientInfo)
{
int id = clientService.AddClient(clientInfo);
var newClient = clientService.GetAllClients().Where(x => x.ClientID == id).FirstOrDefault();
return(Request.CreateResponse(HttpStatusCode.OK, newClient));
}
public void ShouldNotRegisterNewClientIfItExists()
{
//Arrange
var clientTableRepository = Substitute.For <IClientTableRepository>();
ClientService clientService = new ClientService(clientTableRepository);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "Alex";
args.Surname = "Swift";
args.PhoneNumber = "+7956159357";
args.AccountBalance = 9000;
//Act
clientService.RegisterNewClient(args);
clientTableRepository.Contains(Arg.Is <ClientEntity>(
c => c.Name == args.Name &&
c.Surname == args.Surname &&
c.PhoneNumber == args.PhoneNumber &&
c.AccountBalance == args.AccountBalance)).Returns(true);
clientService.RegisterNewClient(args);
//Assert
}
public void ShouldUpdateClient()
{
// Arrange
this.clientTableRepository = Substitute.For <IClientTableRepository>();
var clientId = 44;
this.clientTableRepository.ContainsById(Arg.Is(clientId)).Returns(true);
this.clientTableRepository.Get(Arg.Is(clientId)).Returns(new ClientEntity()
{
Id = clientId,
CreatedAt = DateTime.Now,
LastName = "Misha",
FirstName = "Lomonosow",
PhoneNumber = "+79211234567",
Status = true
});
ClientsService clientsService = new ClientsService(this.clientTableRepository);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.LastName = "Michael";
args.FirstName = "Lomonosov";
args.PhoneNumber = "+79521234567";
// Act
clientsService.UpdateClientData(clientId, args);
// Assert
this.clientTableRepository.Received(1).Update(Arg.Is <ClientEntity>(
c => c.LastName == args.LastName &&
c.FirstName == args.FirstName &&
c.PhoneNumber == args.PhoneNumber));
this.clientTableRepository.Received(1).SaveChanges();
}
public int AddClient(ClientRegistrationInfo clientInfo)
{
if (validator.ValidateClientInfo(clientInfo))
{
var clientToAdd = new ClientEntity()
{
ClientFirstName = clientInfo.FirstName,
ClientLastName = clientInfo.LastName,
PhoneNumber = clientInfo.PhoneNumber
};
clientsRepository.Add(clientToAdd);
clientsRepository.SaveChanges();
var balance = new BalanceEntity()
{
ClientID = clientToAdd.ClientID,
ClientBalance = 0
};
balanceRepository.Add(balance);
balanceRepository.SaveChanges();
return(clientToAdd.ClientID);
}
return(-1);
}
public int RegisterNewClient(ClientRegistrationInfo args)
{
if (args.LastName.Length < 2 ||
args.LastName.Length > 20 ||
args.FirstName.Length < 2 ||
args.FirstName.Length > 20 ||
args.PhoneNumber.Length < 2 ||
args.PhoneNumber.Length > 20)
{
throw new ArgumentException("Invalid ClientRegistrationInfo. Can't continue.");
}
var entityToAdd = new ClientEntity()
{
CreatedAt = DateTime.Now,
LastName = args.LastName,
FirstName = args.FirstName,
PhoneNumber = args.PhoneNumber,
Status = true
};
if (this.tableRepository.Contains(entityToAdd))
{
throw new ArgumentException("This client has been registered. Can't continue.");
}
this.tableRepository.Add(entityToAdd);
this.tableRepository.SaveChanges();
return(entityToAdd.Id);
}
public void ShouldNotOpenAccountForNewClientIfItExists()
{
//Arrange
ClientsService clientsService = new ClientsService(clientsTableRepository, accountTableRepository, stockPriceTableRepository, stockOfClientTableRepository, logger);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "John";
args.Surname = "Jaymson";
args.PhoneNumber = "+78908901234";
AccountRegistrationInfo argsForAcc = new AccountRegistrationInfo();
argsForAcc.Balance = 10m;
argsForAcc.Stocks = new List <StockOfClientEntity>();
argsForAcc.Zone = "white";
AccountEntity ShouldReturnAcc = new AccountEntity();
ShouldReturnAcc.Balance = 10m;
ShouldReturnAcc.Stocks = new List <StockOfClientEntity>();
ShouldReturnAcc.Zone = "white";
//Act
argsForAcc.ClientId = clientsService.RegisterNewClient(args);
ShouldReturnAcc.AccountId = clientsService.CreateNewAccountForNewClient(argsForAcc);
ShouldReturnAcc.ClientId = argsForAcc.ClientId;
accountTableRepository.GetAccountByClientId(Arg.Is <int>(w => w == argsForAcc.ClientId)).Returns(ShouldReturnAcc);
clientsService.CreateNewAccountForNewClient(argsForAcc);
}
public void ShouldNotRegisterNewClientIfItExists()
{
//Arrange
var clientsTableRepository = Substitute.For <IClientsTableRepository>();
ClientsService clientsService = new ClientsService(clientsTableRepository, accountTableRepository, stockPriceTableRepository, stockOfClientTableRepository, logger);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "John";
args.Surname = "Jaymson";
args.PhoneNumber = "+78908901234";
//Act
int clientId = clientsService.RegisterNewClient(args);
ClientEntity ShouldReturn = new ClientEntity()
{
Id = clientId,
Name = args.Name,
Surname = args.Surname,
PhoneNumber = args.PhoneNumber
};
clientsTableRepository.GetClientByNameAndSurname(Arg.Is <string>(
w => w == args.Name), Arg.Is <string>(
w => w == args.Surname)).Returns(ShouldReturn);
clientsService.RegisterNewClient(args);
}
internal string AddNewClient(ClientRegistrationInfo newClient)
{
string request = connectionString + "clients/add";
string jsonData = JsonConvert.SerializeObject(newClient, Formatting.Indented);
var result = Task.Run(() => Post(request, jsonData));
return(result.Result);
}
public void Validation(ClientRegistrationInfo args)
{
if (args.LastName.Length < 2 ||
args.LastName.Length > 20 ||
args.FirstName.Length < 2 ||
args.FirstName.Length > 20 ||
args.PhoneNumber.Length < 2 ||
args.PhoneNumber.Length > 20)
{
throw new ArgumentException("Invalid ClientRegistrationInfo. Can't continue.");
}
}
public ActionResult <string> Update(int clientId, [FromBody] ClientRegistrationInfo infoToUpdate)
{
try
{
clientsService.UpdateInfo(clientId, infoToUpdate);
return(Ok("Client Successfully Updated"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult <string> Add([FromBody] ClientRegistrationInfo client)
{
try
{
clientsService.RegisterNew(client);
return(Ok("Client Successfully Registered"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public bool ValidateClientInfo(ClientRegistrationInfo clientInfo)
{
if (!clientInfo.FirstName.All(char.IsLetter) || !clientInfo.LastName.All(char.IsLetter))
{
return(false);
}
if (!clientInfo.PhoneNumber.All(char.IsDigit))
{
return(false);
}
return(true);
}
public ActionResult <string> AddNewClient([FromBody] ClientRegistrationInfo registrationInfo)
{
try
{
//ClientRegistrationInfo clientToAdd = JsonConvert.DeserializeObject<ClientRegistrationInfo>(registrationInfo);
int registeredID = this.clientService.RegisterNewClient(registrationInfo);
return(Ok(registeredID));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public async Task <IHttpActionResult> Post(ClientEntity client)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ClientRegistrationInfo clientInfo = new ClientRegistrationInfo()
{
FirstName = client.ClientFirstName, LastName = client.ClientLastName, PhoneNumber = client.PhoneNumber
};
clientService.AddClient(clientInfo);
return(Created(client));
}
public int RegisterClient(ClientRegistrationInfo clientInfo)
{
var clientToAdd = new ClientEntity()
{
ClientFirstName = clientInfo.FirstName,
ClientLastName = clientInfo.LastName,
PhoneNumber = clientInfo.PhoneNumber
};
clientsRepository.Add(clientToAdd);
clientsRepository.SaveChanges();
return(clientToAdd.ClientID);
}
public void UpdateClientData(int clientId, ClientRegistrationInfo args)
{
Validation(args);
var client = GetClient(clientId);
client.LastName = args.LastName;
client.FirstName = args.FirstName;
client.PhoneNumber = args.PhoneNumber;
this.tableRepository.Update(client);
this.tableRepository.SaveChanges();
}
public void ShouldNotUpdateClientInfo()
{
//Arrange
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "Alex Grind";
args.Phone = "+3 893 212 11 21";
int clientId = 1;
clientTableRepository.ContainsById(Arg.Is <int>(clientId)).Returns(false);
//Act
clientsService.UpdateInfo(clientId, args);
//Assert
}
public bool ValidateClientInfo(ClientRegistrationInfo clientInfo, ILogger logger)
{
if (!clientInfo.FirstName.All(char.IsLetter) || !clientInfo.LastName.All(char.IsLetter))
{
logger.WriteWarn("Client's name contains forbidden symbols");
return(false);
}
if (!clientInfo.PhoneNumber.All(char.IsDigit))
{
logger.WriteWarn("Client's phone number contains forbidden symbols");
return(false);
}
return(true);
}
public void ShouldNotRegisterNewClientIfItExists()
{
//Arrange
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "Alex Grind";
args.Phone = "+3 893 212 11 21";
//Act
clientsService.RegisterNew(args);
clientTableRepository.Contains(Arg.Is <ClientEntity>(
s => s.Name == args.Name &&
s.Phone == args.Phone)).Returns(true);
//Assert
clientsService.RegisterNew(args);
}
public void ShouldRegisterNewClient()
{
//Arrange
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "Alex Grind";
args.Phone = "+3 893 212 11 21";
//Act
int clientId = clientsService.RegisterNew(args);
//Assert
clientTableRepository.Received(1).Add(Arg.Is <ClientEntity>(
s => s.Name == args.Name &&
s.Phone == args.Phone));
clientTableRepository.Received(1).SaveChanges();
}
public void ShouldNotValidateClientInfo()
{
//Arrange
TradeValidator tradeValidator = new TradeValidator(clientsRepository, shareRepository, clientsSharesRepository);
ClientRegistrationInfo clientInfo = new ClientRegistrationInfo()
{
FirstName = "566",
LastName = "*****@*****.**",
PhoneNumber = "Josh"
};
//Act
var isValid = tradeValidator.ValidateClientInfo(clientInfo, logger);
//Assert
Assert.AreEqual(false, isValid);
}
public void ShouldThrowExceptionIfValidationRegDataFailed()
{
// Arrange
this.clientTableRepository = Substitute.For <IClientTableRepository>();
ClientsService clientsService = new ClientsService(this.clientTableRepository);
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.LastName = "M";
args.FirstName = "LomonosovLomonosovLom";
args.PhoneNumber = "0";
// Act
clientsService.Validation(args);
// Assert
}
public string Run(string[] splittedUserInpit, RequestSender requestSender)
{
string answer = "";
if (splittedUserInpit.Length < 3)
{
return("Not enough parameters");
}
ClientRegistrationInfo clientInfo = new ClientRegistrationInfo
{
FirstName = splittedUserInpit[1],
LastName = splittedUserInpit[2],
PhoneNumber = splittedUserInpit[3]
};
requestSender.PostAddClient(clientInfo, out answer);
return(answer);
}
public void ShouldUpdateClientInfo()
{
//Arrange
ClientRegistrationInfo args = new ClientRegistrationInfo();
args.Name = "Alex Grind";
args.Phone = "+3 893 212 11 21";
int clientId = 1;
clientTableRepository.ContainsById(Arg.Is <int>(clientId)).Returns(true);
//Act
clientsService.UpdateInfo(clientId, args);
//Assert
clientTableRepository.Received(1).Change(Arg.Is <ClientEntity>(
s => s.Name == args.Name &&
s.Phone == args.Phone));
clientTableRepository.Received(1).SaveChanges();
}
public void UpdateInfo(int clientId, ClientRegistrationInfo infoToUpdate)
{
if (infoToUpdate.Name.Length < 2)
{
throw new ArgumentException("Wrong data");
}
if (!clientTableRepository.ContainsById(clientId))
{
throw new ArgumentException($"Client with Id {clientId} doesn't exist");
}
ClientEntity clientToChangeBalance = clientTableRepository.GetById(clientId);
clientToChangeBalance.Name = infoToUpdate.Name;
clientToChangeBalance.Phone = infoToUpdate.Phone;
clientTableRepository.Change(clientToChangeBalance);
clientTableRepository.SaveChanges();
}
public int RegisterNewClient(ClientRegistrationInfo args)
{
var entityToAdd = (new ClientEntity()
{
RegistationDateTime = DateTime.Now,
Name = args.Name,
Phone = args.Phone,
Balance = 0M
});
if (clientTableRepository.Contains(entityToAdd))
{
throw new ArgumentException("This client has been already registered");
}
clientTableRepository.Add(entityToAdd);
clientTableRepository.SaveChanges();
return(entityToAdd.Id);
}
internal static void Connect()
{
Client = new SimpleTcpClient();
Client.DataReceived += ClientOnDataReceived;
Client.DelimiterDataReceived += ClientOnDelimiterDataReceived;
//connection lost, let's try to reconnect
while (Client.TcpClient == null || !Client.TcpClient.Connected)
{
try
{
Client.Connect(Settings.ServerIP, Settings.Port);
var regInfo = new ClientRegistrationInfo { ClientId = ClientId };
var json = JsonConvert.SerializeObject(regInfo);
Client.WriteLine(json);
}
catch (Exception ex)
{
while (ex.InnerException != null)
ex = ex.InnerException;
Console.WriteLine($"Error in reconnect: {ex.Message}\n{ex.StackTrace}\n");
}
Thread.Sleep(100);
}
}
