public async Task GivenTheFollowingClientsExist(Table table) { foreach (TableRow tableRow in table.Rows) { String clientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId"); String clientName = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientName"); String secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret"); String allowedScopes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedScopes"); String allowedGrantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedGrantTypes"); List <String> splitAllowedScopes = allowedScopes.Split(",").ToList(); List <String> splitAllowedGrantTypes = allowedGrantTypes.Split(",").ToList(); CreateClientRequest createClientRequest = new CreateClientRequest { Secret = secret, AllowedGrantTypes = new List <String>(), AllowedScopes = new List <String>(), ClientDescription = String.Empty, ClientId = clientId, ClientName = clientName }; splitAllowedScopes.ForEach(a => { createClientRequest.AllowedScopes.Add(a.Trim()); }); splitAllowedGrantTypes.ForEach(a => { createClientRequest.AllowedGrantTypes.Add(a.Trim()); }); CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient .CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false); createClientResponse.ClientId.ShouldBe(clientId); this.TestingContext.AddClientDetails(clientId, secret, allowedGrantTypes); } }
static void ExecuteSoap() { var client = new SoapServiceClient("NeliburSoapService"); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; ClientResponse response = client.Post <ClientResponse>(createRequest); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); var getClientRequest = new GetClientRequest { Id = response.Id }; response = client.Get <ClientResponse>(getClientRequest); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); }
public async Task <CreateClientResponse> Execute(CreateClientRequest request) { try { if (request != null) { var result = _clientRepository.Exist(request.ClientDto).Result; if (result != null) { throw new Exception($"Cpf/Cnpj or Email already exist: {JsonConvert.SerializeObject(result)}"); } if (await _clientRepository.Create(request.ClientDto)) { return new CreateClientResponse { Created = true } } ; throw new Exception(message: $"It was not possible to create client: {JsonConvert.SerializeObject(request)}"); } return(new CreateClientResponse { Created = false }); } catch (Exception ex) { throw new Exception(ex.Message); } }
/// <summary> /// Creates the client. /// </summary> /// <param name="createClientRequest">The create client request.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public async Task <CreateClientResponse> CreateClient(CreateClientRequest createClientRequest, CancellationToken cancellationToken) { CreateClientResponse response = null; String requestUri = this.BuildRequestUrl("/api/clients"); try { String requestSerialised = JsonConvert.SerializeObject(createClientRequest); StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json"); // Add the access token to the client headers //this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); // Make the Http Call here HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken); // Process the response String content = await this.HandleResponse(httpResponse, cancellationToken); // call was successful so now deserialise the body to the response object response = JsonConvert.DeserializeObject <CreateClientResponse>(content); } catch (Exception ex) { // An exception has occurred, add some additional information to the message Exception exception = new Exception($"Error creating client {createClientRequest.ClientId}.", ex); throw exception; } return(response); }
public CreateClientResponse CreateClient(CreateClientRequest clientRequest) { CreateClientResponse rtn = new CreateClientResponse(); _client = new RestClient($"{_settings.Url}{XeroUrl.Contacts}"); _client.Timeout = -1; var request = new RestRequest(Method.POST); request.AddHeader("xero-tenant-id", _settings.TenandId); request.AddHeader("Authorization", "Bearer " + _settings.AccessToken); request.AddHeader("Accept", "application/json"); request.AddHeader("Content-Type", "application/json"); request.AddHeader("Content-Type", "application/json"); request.AddParameter("application/json,application/json", JsonConvert.SerializeObject(clientRequest), ParameterType.RequestBody); var response = _client.Execute <XeroCreateContactResponse>(request); rtn.HttpStatusCode = response.StatusCode; if (rtn.HttpStatusCode == System.Net.HttpStatusCode.OK) { rtn.HttpStatusCode = System.Net.HttpStatusCode.Created; } rtn.Status = response.StatusCode == System.Net.HttpStatusCode.Created ? PSC.Common.Enums.ResponseStatus.Success : PSC.Common.Enums.ResponseStatus.Failed; if (response.StatusCode == System.Net.HttpStatusCode.OK) { rtn.Contacts = response.Data.Contacts; } else { rtn.Message = response.Content; } return(rtn); }
private async Task <CreateClientResponse> CreateClient(CreateClientRequest createClientRequest, CancellationToken cancellationToken) { CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient.CreateClient(createClientRequest, cancellationToken).ConfigureAwait(false); return(createClientResponse); }
public async Task CreateClient(Boolean mediatorResult) { Random random = new Random(); Guid id = random.NextGuid(); var request = new CreateClientRequest { }; var mediatorMock = new Mock <IMediator>(MockBehavior.Strict); mediatorMock.Setup(x => x.Send(It.Is <CreateClientCommand>(y => y.Request == request), It.IsAny <CancellationToken>())).ReturnsAsync(mediatorResult == false ? new Guid?() : id).Verifiable(); var controller = new ClientController( mediatorMock.Object, Mock.Of <IClientRepository>(MockBehavior.Strict), Mock.Of <ILogger <ClientController> >() ); var actionResult = await controller.CreateClient(request); if (mediatorResult == true) { var actual = actionResult.EnsureOkObjectResult <Guid>(true); Assert.Equal(id, actual); } else { actionResult.EnsureBadRequestObjectResult("unable to complete service operation"); } mediatorMock.Verify(); }
public override Task <CreateClientReply> CreateClient(CreateClientRequest request, ServerCallContext context) { return(Task.FromResult(new CreateClientReply { Status = $"{request.Name} was successfully cretead" })); }
static void ExecuteJson() { var client = new JsonServiceClient("http://*****:*****@email.com" }; ClientResponse response = client.Post <ClientResponse>(createRequest); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); var getClientRequest = new GetClientRequest { Id = response.Id }; response = client.Get <ClientResponse>(getClientRequest); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); }
private async Task SaveClick() { if (ToSave.ClientId == 0) { var toCreate = new CreateClientRequest() { FullName = ToSave.FullName, EmailAddress = ToSave.EmailAddress, Salutation = ToSave.Salutation, PreferredDoctorId = ToSave.PreferredDoctorId, PreferredName = ToSave.PreferredName, }; await ClientService.CreateAsync(toCreate); } else { var toUpdate = new UpdateClientRequest() { ClientId = ToSave.ClientId, FullName = ToSave.FullName, EmailAddress = ToSave.EmailAddress, Salutation = ToSave.Salutation, PreferredDoctorId = ToSave.PreferredDoctorId, PreferredName = ToSave.PreferredName, }; await ClientService.EditAsync(toUpdate); } CancelClick(); await ReloadData(); }
public async Task GivenICreateTheFollowingClients(Table table) { foreach (TableRow tableRow in table.Rows) { // Get the scopes String scopes = SpecflowTableHelper.GetStringRowValue(tableRow, "Scopes"); // Get the grant types String grantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "GrantTypes"); // Get the redirect uris String redirectUris = SpecflowTableHelper.GetStringRowValue(tableRow, "RedirectUris"); // Get the post logout redirect uris String postLogoutRedirectUris = SpecflowTableHelper.GetStringRowValue(tableRow, "PostLogoutRedirectUris"); CreateClientRequest createClientRequest = new CreateClientRequest { ClientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId"), Secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret"), ClientName = SpecflowTableHelper.GetStringRowValue(tableRow, "Name"), AllowedScopes = string.IsNullOrEmpty(scopes) ? null : scopes.Split(",").ToList(), AllowedGrantTypes = string.IsNullOrEmpty(grantTypes) ? null : grantTypes.Split(",").ToList(), ClientRedirectUris = string.IsNullOrEmpty(redirectUris) ? null : redirectUris.Split(",").ToList(), ClientPostLogoutRedirectUris = string.IsNullOrEmpty(postLogoutRedirectUris) ? null : postLogoutRedirectUris.Split(",").ToList(), ClientDescription = SpecflowTableHelper.GetStringRowValue(tableRow, "Description"), RequireConsent = SpecflowTableHelper.GetBooleanValue(tableRow, "RequireConsent") }; CreateClientResponse createClientResponse = await this.CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false); createClientResponse.ShouldNotBeNull(); createClientResponse.ClientId.ShouldNotBeNullOrEmpty(); this.TestingContext.Clients.Add(createClientResponse.ClientId); } }
public async Task <IActionResult> Create([FromBody] CreateClientRequest request) { var clientId = (request.UserId + "client_id_" + request.ApplicationName).Sha256(); int i = 0; Console.WriteLine("clientId = " + clientId); while (true) { Console.WriteLine("IndexOf + = " + (clientId.IndexOf('+') >= 0).ToString()); if (clientId.IndexOf('+') >= 0) { clientId = (request.UserId + "client_id_" + request.ApplicationName + "_" + i).Sha256(); Console.WriteLine("clientId = " + clientId); i++; } else { break; } } var clientSecret = ("client_secret_" + request.ApplicationName).Sha256(); request.RedirectUris.Add("http://localhost:7030/Auth/AuthorizationGrantCode"); IdentityServer4.Models.Client client = new IdentityServer4.Models.Client { ClientName = request.ApplicationName, ClientId = clientId, ClientSecrets = { new IdentityServer4.Models.Secret(clientSecret.Sha256()) }, AllowedGrantTypes = { GrantType.AuthorizationCode, GrantType.ClientCredentials }, RedirectUris = request.RedirectUris, AllowedScopes = request.Scopes, RequireConsent = true, AlwaysSendClientClaims = true }; var entry = await _configurationDbContext.Clients.AddAsync(client.ToEntity()); if (await _configurationDbContext.SaveChangesAsync() > 0) { List <string> scopes = new List <string>(); foreach (var item in entry.Entity.AllowedScopes) { scopes.Add(item.Scope); } var response = new CreateClientResponse { ClientId = entry.Entity.ClientId, ClientSecret = clientSecret, RedirectUris = entry.Entity.RedirectUris.Select(x => x.RedirectUri).ToList(), ApplicationName = request.ApplicationName, Scopes = entry.Entity.AllowedScopes.Select(x => x.Scope).Join(",") }; return(await Task.FromResult(Ok(response))); } return(BadRequest()); }
public override Task <CreateClientResponse> CreateClient(CreateClientRequest request, ServerCallContext context) { bool success = RequestsDispatcher.CreateClientProcess(GetClientArguments(request)); if (!success) { throw new RpcException(new Status(StatusCode.Internal, "Couldn't create client process.")); } return(Task.FromResult(new CreateClientResponse())); }
public IActionResult CreateClient([FromServices] IClientDal _dbService, CreateClientRequest client) { var response = _dbService.CreateClient(client); if (response != null) { return(StatusCode(201, response)); } return(StatusCode(400, "error")); }
public IActionResult CreateClient([FromBody] CreateClientRequest data) { var isCreate = _userService.CreateClient(data); if (!isCreate) { return(BadRequest("UserName invalid")); } return(Ok()); }
public async Task Handle(Boolean repoResult) { Random random = new Random(); Guid clientSystemId = random.NextGuid(); var request = new CreateClientRequest { ClientId = random.GetAlphanumericString(), AllowedCorsOrigins = new[] { "https://myapp.com" }, AllowedScopes = new[] { "test", "testus" }, DisplayName = random.GetAlphanumericString(), FrontChannelLogoutUri = "http://mylogout.com/logout", Password = "******", PostLogoutRedirectUris = new[] { "https://myapp2.com/logout-callback" }, RedirectUris = new[] { "https://myapp2.com/login-callback" }, RequirePkce = true, }; BeerClient clientCreated = null; var repoMock = new Mock <IClientRepository>(MockBehavior.Strict); repoMock.Setup(x => x.CheckIfClientIdExists(request.ClientId)).ReturnsAsync(false).Verifiable(); repoMock.Setup(x => x.AddClient(It.Is <BeerClient>(y => y.DisplayName == request.DisplayName ))).ReturnsAsync(repoResult).Callback <BeerClient>(x => { clientCreated = x; x.Id = clientSystemId; }).Verifiable(); var handler = new CreateClientCommandHandler(repoMock.Object, Mock.Of <ILogger <CreateClientCommandHandler> >()); Guid?result = await handler.Handle(new CreateClientCommand(request), CancellationToken.None); if (repoResult == true) { Assert.True(result.HasValue); Assert.Equal(clientSystemId, result.Value); } else { Assert.False(result.HasValue); } Assert.Equal(request.ClientId, clientCreated.ClientId); Assert.Equal(request.AllowedCorsOrigins, clientCreated.AllowedCorsOrigins); Assert.Equal(request.AllowedScopes, clientCreated.AllowedScopes); Assert.Equal(request.DisplayName, clientCreated.DisplayName); Assert.Equal(request.FrontChannelLogoutUri, clientCreated.FrontChannelLogoutUri); Assert.Equal("mypassword".Sha256(), clientCreated.HashedPassword); Assert.Equal(request.PostLogoutRedirectUris, clientCreated.PostLogoutRedirectUris); Assert.Equal(request.RedirectUris, clientCreated.RedirectUris); Assert.True(clientCreated.RequirePkce); repoMock.Verify(); }
public CreateClientArguments GetClientArguments(CreateClientRequest request) { return(new CreateClientArguments { Username = request.Username, Host = request.Host, Port = request.Port, Script = request.Script, NameServersUrls = request.NamingServersUrls.ToList(), Version = request.Version }); }
private static void Main() { AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler; // PerformanceTest(); var client = new JsonServiceClient(Settings.Default.ServiceAddress); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; var response = client.Post <ClientResponse>(createRequest); Console.WriteLine("POST Response: {0}\n", response); var updateRequest = new UpdateClientRequest { Email = "*****@*****.**", Id = response.Id }; response = client.Put <ClientResponse>(updateRequest); Console.WriteLine("PUT Response: {0}\n", response); var getClientRequest = new GetClientRequest { Id = response.Id, Date = DateTime.Now.Date }; response = client.Get <ClientResponse>(getClientRequest); Console.WriteLine("GET Response: {0}\n", response); var deleteRequest = new DeleteClientRequest { Id = response.Id }; client.Delete(deleteRequest); var certificate = new MemoryStream(File.ReadAllBytes("Certificate.cer")); var uploadRequest = new UploadRequest { FileContents = certificate.ToArray(), OriginalFileName = "MyFileName.cert", UploaderId = Guid.NewGuid().ToString() }; client.Post(uploadRequest); Console.ReadKey(); }
public async Task <CreateEntityResponse> Create(CreateClientRequest client) { var newClient = new Client { Name = client.Name, Description = client.Description, EmployerId = client.EmployerId }; var result = await _clientsRepo.Create(newClient); return(result); }
public override async Task <ClientModel> CreateClient(CreateClientRequest request, ServerCallContext context) { Tourist client = _mapper.Map <Tourist>(request.Client); client.Id = default; _touristRepository.Add(client); await _touristRepository.SaveChangesAsync(); var clientModel = request.Client; return(clientModel); }
/// <summary> /// Clients / Create Client /// </summary> public async Task <CreateClientResponse> CreateClientAsync(CreateClientRequest request) { if (request == null) { throw new ArgumentNullException("Value cannot be null.", nameof(request)); } if (string.IsNullOrEmpty(request.Name)) { throw new ArgumentException("Value cannot be null or empty.", nameof(request.Name)); } return(await ExecuteAsync <CreateClientResponse>(CreateRequest <CreateClientRequest>(CLIENTS_PATH, request)).ConfigureAwait(false)); }
public async Task <IActionResult> CreateClient([FromBody] CreateClientRequest request) { Guid?systemid = await _mediator.Send(new CreateClientCommand(request)); if (systemid.HasValue == true) { return(base.Ok(systemid.Value)); } else { return(BadRequest("unable to complete service operation")); } }
private async void CreateNewClient() { CreateClientRequest createClientRequest = new CreateClientRequest { FirstName = tbIme.Text, LastName = tbPrezime.Text, Email = tbEmail.Text, Password = tbPassword.Text, Address = tbAdresa.Text, PhoneNumber = tbTelefon.Text }; await _apiService.Create <Client>(createClientRequest); }
public bool CreateClient(CreateClientRequest clientRequest) { var client = _clientRepository.GetByUserName(clientRequest.UserName); if (client != null) { return(false); } _clientRepository.Add(_mapper.Map <ClientEntity>(clientRequest)); Console.WriteLine($"New User Create! Name: { clientRequest.UserName }, Email: { clientRequest.EmailAddress }, Password: { clientRequest.Password }."); return(true); }
public Models.Clients.Client Create(CreateClientRequest createClientRequest) { Database.AppUser appUser = _mapper.Map <Database.AppUser>(createClientRequest); appUser.HashedPassword = HashUtil.ComputeSha256Hash(createClientRequest.Password); appUser.CreatedAt = DateTime.UtcNow; appUser.Status = Database.UserStatus.INACTIVE; // add client specific data Database.Client client = new Database.Client(); appUser.Client = client; _context.AppUsers.Add(appUser); _context.SaveChanges(); return(_mapper.Map <Models.Clients.Client>(appUser)); }
private static void PerformanceTest() { var client = new JsonServiceClient(Settings.Default.ServiceAddress); var createRequest = new CreateClientRequest { Email = "*****@*****.**" }; Stopwatch stopwatch = Stopwatch.StartNew(); 1000.Times() .Iter(x => client.Post <ClientResponse>(createRequest)); Console.WriteLine("Total: {0} ms", stopwatch.Elapsed.TotalMilliseconds); }
// POST api/values public CreateClientResponse Post(CreateClientRequest model) { if (model != null) { return(new CreateClientResponse { Token = "SuperSecretData", Status = ResponseStatus.Success }); } return(new CreateClientResponse { Status = ResponseStatus.Failed }); }
public void CreateClient_ServiceReturnTask_ReturnOk() { ClientService.Invocations.Clear(); var name = "Ivan Ivanov"; var email = "*****@*****.**"; var password = "******"; var clientId = Guid.NewGuid(); var requestedName = string.Empty; var requestedEmail = string.Empty; var requestedPassword = string.Empty; var taskId = Guid.NewGuid(); var request = new CreateClientRequest { Name = name, Email = email, Password = password }; ClientService.Setup(x => x.CreateClient(It.IsAny <Client>())) .Callback <Client>((clientParam) => { requestedName = clientParam.Name; requestedEmail = clientParam.Email; requestedPassword = clientParam.Password; }) .Returns(new BusinessLogic.Models.CreateClientResult { TaskId = taskId }); var controller = new ClientsController(ClientService.Object) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() } }; var actionResult = controller.Post(request); var result = actionResult as OkObjectResult; var createResult = result.Value as TimeOutResult; ClientService.Verify(x => x.CreateClient(It.IsAny <Client>()), Times.Once); Assert.AreEqual(requestedName, name); Assert.AreEqual(requestedEmail, email); Assert.AreEqual(requestedPassword, password); Assert.AreEqual(createResult.TaskId, taskId); Assert.AreEqual(result.StatusCode, 200); }
public async Task GivenTheFollowingClientsExist(Table table) { foreach (TableRow tableRow in table.Rows) { String clientId = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientId"); String clientName = SpecflowTableHelper.GetStringRowValue(tableRow, "ClientName"); String secret = SpecflowTableHelper.GetStringRowValue(tableRow, "Secret"); String allowedScopes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedScopes"); String allowedGrantTypes = SpecflowTableHelper.GetStringRowValue(tableRow, "AllowedGrantTypes"); List <String> splitAllowedScopes = allowedScopes.Split(',').ToList(); List <String> splitAllowedGrantTypes = allowedGrantTypes.Split(',').ToList(); CreateClientRequest createClientRequest = new CreateClientRequest { Secret = secret, AllowedGrantTypes = new List <String>(), AllowedScopes = new List <String>(), ClientDescription = String.Empty, ClientId = clientId, ClientName = clientName }; splitAllowedScopes.ForEach(a => { createClientRequest.AllowedScopes.Add(a.Trim()); }); splitAllowedGrantTypes.ForEach(a => { createClientRequest.AllowedGrantTypes.Add(a.Trim()); }); CreateClientResponse createClientResponse = await this.TestingContext.DockerHelper.SecurityServiceClient .CreateClient(createClientRequest, CancellationToken.None).ConfigureAwait(false); createClientResponse.ClientId.ShouldBe(clientId); this.TestingContext.AddClientDetails(clientId, secret, allowedGrantTypes); } var merchantClient = this.TestingContext.GetClientDetails("merchantClient"); // TODO: Handle local test running String securityService = this.TestingContext.DockerHelper.SecurityServiceBaseAddress; String transactionProcessorAcl = this.TestingContext.DockerHelper.TransactionProcessorACLBaseAddress; Console.WriteLine($"securityService [{securityService}]"); Console.WriteLine($"transactionProcessorAcl [{transactionProcessorAcl}]"); AppManager.SetConfiguration(merchantClient.ClientId, merchantClient.ClientSecret, securityService, transactionProcessorAcl); }
public void CreateClient_ServiceReturnException_ReturnInternalServiceError() { ClientService.Invocations.Clear(); var name = "Ivan Ivanov"; var email = "*****@*****.**"; var password = "******"; var requestedName = string.Empty; var requestedEmail = string.Empty; var requestedPassword = string.Empty; var exceptionMessage = "some exception message"; var request = new CreateClientRequest { Name = name, Email = email, Password = password }; ClientService.Setup(x => x.CreateClient(It.IsAny <Client>())) .Callback <Client>((clientParam) => { requestedName = clientParam.Name; requestedEmail = clientParam.Email; requestedPassword = clientParam.Password; }) .Throws(new Exception(exceptionMessage)); var controller = new ClientsController(ClientService.Object) { ControllerContext = new ControllerContext { HttpContext = new DefaultHttpContext() } }; var actionResult = controller.Post(request); var result = actionResult as OkObjectResult; var result1 = actionResult as ObjectResult; ClientService.Verify(x => x.CreateClient(It.IsAny <Client>()), Times.Once); Assert.AreEqual(requestedName, name); Assert.AreEqual(requestedEmail, email); Assert.AreEqual(requestedPassword, password); Assert.IsTrue(result == null); Assert.IsTrue(result1 != null); Assert.AreEqual(result1.StatusCode, 500); Assert.AreEqual(result1.Value, exceptionMessage); }