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); } }