public async Task <object> Create([FromBody] CreateClientDto createClientDto) { if (!ModelState.IsValid) { // Tälle tulee parempi vaihtoehto seuraavassa esimerkissä return(ModelState); } // Business ID on vakiona 1 tässä esimerkissä var businessId = 1; var newClient = new Client() { City = createClientDto.City, Address = createClientDto.Address, Name = createClientDto.Name, PostCode = createClientDto.PostCode, Email = createClientDto.Email, BusinessId = businessId, }; dbContext.Client.Add(newClient); await dbContext.SaveChangesAsync(); return(newClient); }
private async Task SynchronizeClientsAsync(AppModel model, SyncOptions options, ISession session) { var current = await session.Apps.GetClientsAsync(session.App); if (options.Delete) { foreach (var client in current.Items) { var generatedClientId = $"{session.App}:{client.Id}"; if (model.Clients.ContainsKey(client.Id) || session.ClientId.Equals(generatedClientId)) { continue; } await log.DoSafeAsync($"Client '{client.Id}' deleting", async() => { await session.Apps.DeleteClientAsync(session.App, client.Id); }); } } foreach (var(clientId, _) in model.Clients) { var existing = current.Items.FirstOrDefault(x => x.Id == clientId); if (existing != null) { continue; } await log.DoSafeAsync($"Client '{clientId}' creating", async() => { var request = new CreateClientDto { Id = clientId }; current = await session.Apps.PostClientAsync(session.App, request); }); } foreach (var(clientId, value) in model.Clients) { var existing = current.Items.FirstOrDefault(x => x.Id == clientId); if (existing == null || value.JsonEquals(existing)) { continue; } await log.DoSafeAsync($"Client '{clientId}' updating", async() => { var request = new UpdateClientDto { Role = value.Role }; await session.Apps.PutClientAsync(session.App, clientId, request); }); } }
public async Task RegisterClientAsync(CreateClientDto client) { if (await DbContext.Clients.FirstOrDefaultAsync(c => c.FirstName == client.FirstName && c.LastName == client.LastName && c.Patronymic == client.Patronymic && c.DateOfBirth == client.DateOfBirth) == null) { var mapped = new Client() { LastName = client.LastName, FirstName = client.FirstName, Patronymic = client.Patronymic, DateOfBirth = client.DateOfBirth, AccountBalance = client.AccountBalance }; await DbContext.Clients.AddAsync(mapped); await DbContext.SaveChangesAsync(); } else { throw new ArgumentException(); } }
public async Task Post_Should_Create_Client() { var toCreateClient = new CreateClientDto() { ClientType = _confidentialClientType.Wording, Description = "a new client for logged user !", Name = "logged user's client", ReturnUrls = new List <string>() { "http://return.com" }, ScopesIds = new List <int>() { _scope1.Id, _scope2.Id } }; var httpResponseMessage = await _client.PostAsJsonAsync("clients", toCreateClient); Assert.AreEqual(HttpStatusCode.Created, httpResponseMessage.StatusCode); Assert.IsTrue(httpResponseMessage.Headers.Contains("location")); var location = httpResponseMessage.Headers.GetValues("location").Single(); Assert.IsTrue(location.Length > 0); var clientId = Int32.Parse(location.Split('/', StringSplitOptions.RemoveEmptyEntries).Last()); Client myNewClient = null; ClientReturnUrl myClientReturnUrl = null; IList <ClientScope> myClientScopes = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myNewClient = context.Clients.Where(c => c.Id.Equals(clientId)).SingleOrDefault(); myClientReturnUrl = context.ClientReturnUrls.Where(c => c.ClientId.Equals(clientId)).SingleOrDefault(); myClientScopes = context.ClientsScopes.Where(c => c.ClientId.Equals(clientId)).ToList(); } Assert.IsNotNull(myNewClient); Assert.AreEqual(toCreateClient.Description, myNewClient.Description); Assert.AreEqual(toCreateClient.Name, myNewClient.Name); Assert.IsTrue(myNewClient.IsValid); Assert.IsTrue(myNewClient.PublicId.Length > 0); Assert.IsTrue(myNewClient.ClientSecret.Length > 0); Assert.AreEqual(DateTime.Now.Date, myNewClient.CreationDate.Date); Assert.IsNotNull(myClientReturnUrl); Assert.AreEqual(toCreateClient.ReturnUrls.First(), myClientReturnUrl.ReturnUrl); Assert.IsNotNull(myClientScopes); Assert.IsTrue(toCreateClient.ScopesIds.Count() > 0); Assert.AreEqual(toCreateClient.ScopesIds.Count(), myClientScopes.Count()); foreach (var scopeId in toCreateClient.ScopesIds) { Assert.IsTrue(myClientScopes.Select(cs => cs.ScopeId).Contains(scopeId)); } }
public IActionResult Post(CreateClientDto infos) { infos.UserName = User.Identity.Name; var createdId = _service.CreateClient(infos); var currentUrl = UriHelper.GetDisplayUrl(Request); return(Created($"{currentUrl}/{createdId}", null)); }
public async Task <IActionResult> PostClient(string app, [FromBody] CreateClientDto request) { var command = request.ToCommand(); var response = await InvokeCommandAsync(command); return(CreatedAtAction(nameof(GetClients), new { app }, response)); }
public async Task <IActionResult> Create(CreateClientDto input) { var newGuid = Guid.NewGuid(); await _mediatorService.Send(new AddClientCommand(newGuid, input.FirstName, input.LastName, input.ContactNumber, input.EmailAddress)); return(new OkObjectResult(new { newGuid })); }
public IActionResult Put(long id, [FromBody] CreateClientDto dto) { var client = _clientService.UpdateClient(id, dto); if (client == null) { return(BadRequest("The client you are trying to update doesn't exist or such phone already exists!")); } return(NoContent()); }
public async Task <IActionResult> AddClient([FromBody] CreateClientDto input) { if (!ModelState.IsValid) { return(BadRequest(ModelStateErrors)); } var result = await _clientAppService.AddClient(input); return(ResultResponse(result, "创建客户端成功")); }
public async Task <int> CreateNew(int serverId, CreateClientDto client) { var result = await _http.PostAsJsonAsync($"{_api.Url}/servers/{serverId}/clients", client); await result.EnsureSuccess(); var response = await result.Content.ReadFromJsonAsync <IdResponse>(); return(response.Id); }
public async Task Should_manage_clients() { var clientId = Guid.NewGuid().ToString(); var clientName = "My Client"; var clientRole1 = "Editor"; var clientRole2 = "Owner"; // STEP 1: Create client. var createRequest = new CreateClientDto { Id = clientId }; var clients_1 = await _.Apps.PostClientAsync(_.AppName, createRequest); var client_1 = clients_1.Items.FirstOrDefault(x => x.Id == clientId); // Should return client with correct name and id. Assert.Equal(clientRole1, client_1.Role); Assert.Equal(clientId, client_1.Name); // STEP 2: Update client name. var updateNameRequest = new UpdateClientDto { Name = clientName }; var clients_2 = await _.Apps.PutClientAsync(_.AppName, clientId, updateNameRequest); var client_2 = clients_2.Items.FirstOrDefault(x => x.Id == clientId); // Should update client name. Assert.Equal(clientName, client_2.Name); // STEP 3: Update client role. var updateRoleRequest = new UpdateClientDto { Role = clientRole2 }; var clients_3 = await _.Apps.PutClientAsync(_.AppName, clientId, updateRoleRequest); var client_3 = clients_3.Items.FirstOrDefault(x => x.Id == clientId); // Should update client role. Assert.Equal(clientRole2, client_3.Role); // STEP 4: Delete client var clients_4 = await _.Apps.DeleteClientAsync(_.AppName, clientId); var client_4 = clients_4.Items.FirstOrDefault(x => x.Id == clientId); // Should not return deleted client. Assert.Null(client_4); }
public IActionResult Post([FromBody] CreateClientDto dto) { var client = _clientService.AddNewClient(dto); if (client == null) { return(BadRequest("Client with such phone already exists!")); } return(CreatedAtAction(nameof(GetClient), new { id = client.Id }, client)); }
public async Task <IActionResult> PostAsync(CreateClientDto dto) { User user = _mapper.Map <CreateClientDto, User>(dto); Client client = _clientService.CreateClientObject(); client = await _clientService.AddClient(user, client); ReadClientDto readDto = _mapper.Map <ReadClientDto>(client); return(Created(nameof(GetAsync), new Response <ReadClientDto>(readDto))); }
public async Task <bool> AddClient(CreateClientDto client) { await IsExists(client.ClientId, 0); var entity = _mapper.Map <Client>(client); await _clientRepository.AddAsync(entity); var result = await _clientRepository.SaveChangesAsync() > 0; return(result); }
public async Task <IActionResult> PostClient([FromBody] CreateClientDto clientdto) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var clientObj = _mapper.Map <Client>(clientdto); await _clients.Add(clientObj); return(CreatedAtAction("GetClient", new { id = clientObj.Id }, clientObj)); }
public async Task <IActionResult> Post(int id, [FromBody] CreateClientDto client, CancellationToken cancellationToken) { var command = new CreateClientCommand { Client = client, ServerId = id }; var clientId = await Mediator.Send(command, cancellationToken); return(new JsonResult(new { id = clientId }) { StatusCode = 201 }); }
public async Task CreateClientAsync(CreateClientDto createClietnDto) { var addresses = new List <Address>(); var contacts = new List <Contact>(); var client = new Client { UniqueId = Guid.NewGuid(), FirstName = createClietnDto.FirstName, MiddleName = createClietnDto.MiddleName, LastName = createClietnDto.LastName, Gender = createClietnDto.Gender, }; var clientId = await _clientRepository.CreateClientAsync(client); if (createClietnDto.AddressesDto != null) { foreach (var address in createClietnDto.AddressesDto) { addresses.Add(new Address { UniqueId = Guid.NewGuid(), AddressType = address.AddressType, Line1 = address.Line1, Line2 = address.Line2, Line3 = address.Line3, AreaCode = address.AreaCode, City = address.City, StateProvince = address.StateProvince, Country = address.Country, ClientId = clientId }); } } if (createClietnDto.ContactsDto != null) { foreach (var contact in createClietnDto.ContactsDto) { contacts.Add(new Contact { UniqueId = Guid.NewGuid(), ContactType = contact.ContactType, Msisdn = contact.Msisdn, ClientId = clientId }); } } await _addressRepository.CreateAddressesAsync(addresses); await _contactRepository.CreateContactsAsync(contacts); }
private async Task <ClientDto> CreateAsync() { var createRequest = new CreateClientDto { Id = id }; var clients = await _.Apps.PostClientAsync(appName, createRequest); var client = clients.Items.Find(x => x.Id == id); return(client); }
public async Task <int> CreateClientAsync(CreateClientDto createClientDto, CancellationToken ct) { Client clientsEntity = _mapper.Mapper.Map <Client>(createClientDto); _uow.Clients.CreateClient(clientsEntity); if (await _uow.SaveChangesAsync(ct) > 0) { return(clientsEntity.Id); } else { return(0); } }
public ClientDto AddNewClient(CreateClientDto dto) { if (PhoneExists(dto.Phone)) { return(null); } var client = _mapper.Map <Client>(dto); _clientRepository.Add(client); _clientRepository.Save(); var result = _mapper.Map <ClientDto>(client); return(result); }
public ClientDto UpdateClient(long id, CreateClientDto dto) { var client = _clientRepository.Get(id); if (client == null || (dto.Phone != client.Phone && PhoneExists(dto.Phone))) { return(null); } _mapper.Map(dto, client); _clientRepository.Save(); var result = _mapper.Map <ClientDto>(client); return(result); }
public async Task <IActionResult> Post(CreateClientDto client) { if (client == null || !ModelState.IsValid) { return(BadRequest()); } try { await ClientService.RegisterClientAsync(client); return(Ok()); } catch { return(StatusCode(500, "Error appears during registration")); } }
public async Task CreateClientAsync(CreateClientDto clientDto, CancellationToken ct) { if (clientDto == null) { throw new NullReferenceException(); } Client clientEntity = _mapper.Map <Client>(clientDto); if (clientEntity == null) { throw new NullReferenceException(); } _uow.Clients.Add(clientEntity); await _uow.SaveChangesAsync(ct); }
public async Task <IActionResult> CreateClient(CreateClientDto createClientDto) { try { createClientDto.UserId = (int)AuthoticateUserId(); var result = await _clientCashedService.AddAsync(createClientDto); if (result.Errors.Any()) { return(Conflict()); } return(Ok(result.Data)); } catch (Exception ex) { _logging.WriteExption(ex); return(BadRequest()); } }
public async Task <ActionResult <ClientDto> > CreateClientAsync(CreateClientDto clientDto) { Client client = new() { Id = Guid.NewGuid(), Name = clientDto.Name, Telephone = clientDto.Telephone, Email = clientDto.Email, IsDeleted = clientDto.IsDeleted, Photo = clientDto.Photo, InsertedDate = DateTimeOffset.UtcNow, CNP = clientDto.CNP, Adress = clientDto.Adress, Barcode = random.Next(100000, 999999), Comment = clientDto.Comment }; await repository.CreateClientAsync(client); return(CreatedAtAction(nameof(CreateClientAsync), new { id = client.Id }, client.MapToDto())); }
public async Task Post_Succeeded( [Frozen] CreateClientDto createClientDto, [Frozen] Client client, [Frozen] Client createdClient, [Frozen] User user, [Frozen] ReadClientDto readClientDto ) { //Arrange _mapper.Setup(m => m.Map <CreateClientDto, User>(createClientDto)).Returns(user); _mapper.Setup(m => m.Map <ReadClientDto>(createdClient)).Returns(readClientDto); _clientService.Setup(c => c.CreateClientObject()).Returns(client); _clientService.Setup(c => c.AddClient(user, client)).ReturnsAsync(createdClient); //Action var result = await _clientsController.PostAsync(createClientDto); //Assert var resultChecked = Assert.IsType <CreatedResult>(result); Assert.True(result is CreatedResult); Assert.Equal(readClientDto, ((Response <ReadClientDto>)resultChecked.Value).Data); }
public async Task <IActionResult> CreateAsync([FromBody] CreateClientDto dto) { if (await _dbContext.Clients.AnyAsync(u => u.ClientId == dto.ClientId)) { return(new ApiResult(ApiResultType.Error, "资源名已经存在")); } var redirectUris = dto.RedirectUris.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries) .Where(cors => !string.IsNullOrWhiteSpace(cors) && cors.IsUrl()).ToList(); if (redirectUris.Count == 0) { return(new ApiResult(ApiResultType.Error, "回调地址不能为空")); } var allowedCorsOrigins = dto.AllowedCorsOrigins.Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries) .Where(cors => !string.IsNullOrWhiteSpace(cors) && cors.IsUrl()).ToList(); if (allowedCorsOrigins.Count == 0) { return(new ApiResult(ApiResultType.Error, "授权范围不能为空")); } var client = new IdentityServer4.Models.Client(); switch (dto.AllowedGrantTypes) { case GrantTypes.Code: { client.AllowedGrantTypes = Models.GrantTypes.Code; break; } case GrantTypes.Hybrid: { client.AllowedGrantTypes = Models.GrantTypes.Hybrid; break; } case GrantTypes.Implicit: { client.AllowedGrantTypes = Models.GrantTypes.Implicit; break; } case GrantTypes.ClientCredentials: { client.AllowedGrantTypes = Models.GrantTypes.ClientCredentials; break; } case GrantTypes.DeviceFlow: { client.AllowedGrantTypes = Models.GrantTypes.DeviceFlow; break; } case GrantTypes.ResourceOwnerPassword: { client.AllowedGrantTypes = Models.GrantTypes.ResourceOwnerPassword; break; } case GrantTypes.CodeAndClientCredentials: { client.AllowedGrantTypes = Models.GrantTypes.CodeAndClientCredentials; break; } case GrantTypes.HybridAndClientCredentials: { client.AllowedGrantTypes = Models.GrantTypes.HybridAndClientCredentials; break; } case GrantTypes.ImplicitAndClientCredentials: { client.AllowedGrantTypes = Models.GrantTypes.ImplicitAndClientCredentials; break; } case GrantTypes.ResourceOwnerPasswordAndClientCredentials: { client.AllowedGrantTypes = Models.GrantTypes.ResourceOwnerPasswordAndClientCredentials; break; } } client.Description = dto.Description; client.Properties = dto.Properties; client.AllowedScopes = dto.AllowedScopes.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries) .Where(cors => !string.IsNullOrWhiteSpace(cors)).ToList(); client.ClientId = dto.ClientId; client.ClientName = dto.ClientName; client.ClientUri = dto.ClientUri; client.ConsentLifetime = dto.ConsentLifetime; client.LogoUri = dto.LogoUri; client.ProtocolType = dto.ProtocolType; client.RedirectUris = redirectUris; client.RequireConsent = dto.RequireConsent; client.RequirePkce = dto.RequirePkce; client.AccessTokenLifetime = dto.AccessTokenLifetime; client.AccessTokenType = dto.AccessTokenType; client.AllowedCorsOrigins = allowedCorsOrigins; client.AllowOfflineAccess = dto.AllowOfflineAccess; client.AllowRememberConsent = dto.AllowRememberConsent; client.AuthorizationCodeLifetime = dto.AuthorizationCodeLifetime; client.ClientClaimsPrefix = dto.ClientClaimsPrefix; client.DeviceCodeLifetime = dto.DeviceCodeLifetime; client.EnableLocalLogin = dto.EnableLocalLogin; client.IdentityProviderRestrictions = dto.IdentityProviderRestrictions; client.IdentityTokenLifetime = dto.IdentityTokenLifetime; client.IncludeJwtId = dto.IncludeJwtId; client.RefreshTokenExpiration = dto.RefreshTokenExpiration; client.RefreshTokenUsage = dto.RefreshTokenUsage; client.RequireClientSecret = dto.RequireClientSecret; client.UserCodeType = dto.UserCodeType; client.UserSsoLifetime = dto.UserSsoLifetime; client.AbsoluteRefreshTokenLifetime = dto.AbsoluteRefreshTokenLifetime; client.AllowPlainTextPkce = dto.AllowPlainTextPkce; client.AlwaysSendClientClaims = dto.AlwaysSendClientClaims; client.BackChannelLogoutUri = dto.BackChannelLogoutUri; client.FrontChannelLogoutUri = dto.FrontChannelLogoutUri; client.PairWiseSubjectSalt = dto.PairWiseSubjectSalt; client.PostLogoutRedirectUris = dto.PostLogoutRedirectUris .Split(new[] { ";" }, StringSplitOptions.RemoveEmptyEntries) .Where(cors => !string.IsNullOrWhiteSpace(cors) && cors.IsUrl()).ToList(); client.SlidingRefreshTokenLifetime = dto.SlidingRefreshTokenLifetime; client.AllowAccessTokensViaBrowser = dto.AllowAccessTokensViaBrowser; client.BackChannelLogoutSessionRequired = dto.BackChannelLogoutSessionRequired; client.FrontChannelLogoutSessionRequired = dto.FrontChannelLogoutSessionRequired; client.UpdateAccessTokenClaimsOnRefresh = dto.UpdateAccessTokenClaimsOnRefresh; client.AlwaysIncludeUserClaimsInIdToken = dto.AlwaysIncludeUserClaimsInIdToken; await _dbContext.Clients.AddAsync(client.ToEntity()); await _dbContext.SaveChangesAsync(); return(ApiResult.Ok); }
public Task <bool> CreateClientAsync(CreateClientDto ClientDto) { throw new System.NotImplementedException(); }
public async Task <IActionResult> Create([FromBody] CreateClientDto createClientDto) { await _clientService.CreateClientAsync(createClientDto); return(Ok()); }
private async Task SynchronizeClientsAsync(AppModel model, SyncOptions options, ISession session) { var current = await session.Apps.GetClientsAsync(session.App); if (options.Delete) { foreach (var client in current.Items) { var generatedClientId = $"{session.App}:{client.Id}"; if (model.Clients.ContainsKey(client.Id) || session.ClientId.Equals(generatedClientId, StringComparison.Ordinal)) { continue; } await log.DoSafeAsync($"Client '{client.Id}' deleting", async() => { await session.Apps.DeleteClientAsync(session.App, client.Id); }); } } foreach (var(clientId, _) in model.Clients) { var existing = current.Items.Find(x => x.Id == clientId); if (existing != null) { continue; } await log.DoSafeAsync($"Client '{clientId}' creating", async() => { var request = new CreateClientDto { Id = clientId }; current = await session.Apps.PostClientAsync(session.App, request); }); } foreach (var(clientId, client) in model.Clients) { var existing = current.Items.Find(x => x.Id == clientId); if (existing == null || client.JsonEquals(existing)) { continue; } if (!options.UpdateCurrentClient && session.ClientId.Equals(clientId, StringComparison.Ordinal)) { continue; } await log.DoSafeAsync($"Client '{clientId}' updating", async() => { var request = client.ToUpdate(); await session.Apps.PutClientAsync(session.App, clientId, request); }); } }