public virtual async Task <IdentityUtilsResult <PasswordForgottenResponse> > GetPasswordResetToken([FromBody] PasswordForgottenRequest passwordForgottenRequest) { var userResult = await userManager.FindByNameAsync(passwordForgottenRequest.Username); if (!userResult.Success) { return(userResult.ToTypedResult <PasswordForgottenResponse>()); } var resetTokenResult = await userManager.GeneratePasswordResetTokenAsync(passwordForgottenRequest.Username); if (!resetTokenResult.Success) { return(resetTokenResult.ToTypedResult <PasswordForgottenResponse>()); } var userData = userResult.Data.First(); var passwordResponse = new PasswordForgottenResponse { Username = userData.UserName, Email = userData.Email, Token = resetTokenResult.Data.First() }; return(IdentityUtilsResult <PasswordForgottenResponse> .SuccessResult(passwordResponse)); }
public async Task <IdentityUtilsResult <TRoleDto> > AddRole(TRoleDto roleDto) { roleDto.Name = roleDto.Name.Trim(); var role = mapper.Map <TRole>(roleDto); var result = ModelValidator.ValidateDataAnnotations(role).ToIdentityUtilsResult(); if (!result.Success) { return(result.ToTypedResult <TRoleDto>()); } var managerValidationResult = await new RoleValidator <TRole>().ValidateAsync(roleManager, role); if (!managerValidationResult.Succeeded) { return(managerValidationResult.ToIdentityUtilsResult().ToTypedResult <TRoleDto>()); } var roleResult = await roleManager.CreateAsync(role); if (!roleResult.Succeeded) { return(roleResult.ToIdentityUtilsResult().ToTypedResult <TRoleDto>()); } mapper.Map(role, roleDto); return(IdentityUtilsResult <TRoleDto> .SuccessResult(roleDto)); }
public async Task <IdentityUtilsResult <TTenantDto> > AddTenant(TTenantDto tenantDto) { tenantDto.Hostnames ??= new List <string>(); var hostsAlreadyExist = await dbContext.TenantHosts .Where(x => tenantDto.Hostnames.Contains(x.Hostname)) .AnyAsync(); if (hostsAlreadyExist) { return(IdentityUtilsResult <TTenantDto> .ErrorResult("Hostname already assigned to different tenant")); } var tenant = mapper.Map <TTenant>(tenantDto); tenant.Hosts = tenantDto.Hostnames .Select(x => new IdentityManagerTenantHost { Hostname = x.Trim() }) .ToList(); var result = ModelValidator.ValidateDataAnnotations(tenant); if (!result.isValid) { return(IdentityUtilsResult <TTenantDto> .ErrorResult(result.ToIdentityUtilsResult().ErrorMessages)); } dbContext.Tenants.Add(tenant); await dbContext.SaveChangesAsync(); return(IdentityUtilsResult <TTenantDto> .SuccessResult(ToDto(tenant))); }
/// <summary> /// Uses AutoMapper to map retrieved user to speciefied type /// </summary> /// <typeparam name="TDto"></typeparam> /// <param name="id"></param> /// <returns></returns> public async Task <IdentityUtilsResult <TDto> > FindByIdAsync <TDto>(Guid id) where TDto : class { var user = await FindByIdAsync(id); return(user.Success ? IdentityUtilsResult <TDto> .SuccessResult(mapper.Map <TDto>(user.Data.Single())) : IdentityUtilsResult <TDto> .ErrorResult(user.ErrorMessages)); }
public virtual async Task <IdentityUtilsResult <TTenantDto> > UpdateTenant([FromRoute] Guid tenantId, [FromBody] TTenantDto tenant) { if (tenantId != tenant.TenantId) { return(IdentityUtilsResult <TTenantDto> .ErrorResult("Id specified in route and payload are not the same!")); } return(await tenantService.UpdateTenant(tenant)); }
public virtual async Task <IdentityUtilsResult <T> > ProfileInit() { var profile = new T { Claims = User.Claims.Select(x => new Claim(x.Type, x.Value)) }; return(IdentityUtilsResult <T> .SuccessResult(profile)); }
public async Task <IdentityUtilsResult <TTenantDto> > GetTenant(Guid id) { var tenantResult = await GetTenantDb(id); var result = tenantResult.Success ? IdentityUtilsResult <TTenantDto> .SuccessResult(ToDto(tenantResult.Data)) : IdentityUtilsResult <TTenantDto> .ErrorResult(tenantResult.ErrorMessages); return(result); }
private async Task <IdentityUtilsResult <TRole> > GetRoleById(Guid roleId) { var role = await roleManager.FindByIdAsync(roleId.ToString()); if (role == null) { return(IdentityUtilsResult <TRole> .ErrorResult("Role with specified ID not found")); } return(IdentityUtilsResult <TRole> .SuccessResult(role)); }
internal async static Task <IdentityUtilsResult> ParseRestResultTask(this Task <RestResult <IdentityUtilsResult> > restResultTask) { var restResult = await restResultTask; if (!restResult.Success) { return(IdentityUtilsResult.ErrorResult(restResult.ErrorMessages)); } return(restResult.ResponseData); }
public async Task <IdentityUtilsResult <TUserDto> > FindByNameAsync <TUserDto>(string name) where TUserDto : class { var userResult = await FindByNameAsync(name); if (!userResult.Success) { return(IdentityUtilsResult <TUserDto> .ErrorResult(userResult.ErrorMessages)); } return(IdentityUtilsResult <TUserDto> .SuccessResult(mapper.Map <TUserDto>(userResult.Data.First()))); }
public async Task <IdentityUtilsResult <TUser> > FindByNameAsync(string name) { var user = await userManager.FindByNameAsync(name); if (user == null) { return(IdentityUtilsResult <TUser> .ErrorResult("User with specified name not found")); } return(IdentityUtilsResult <TUser> .SuccessResult(user)); }
/// <summary> /// Retrieves user by ID /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <IdentityUtilsResult <TUser> > FindByIdAsync(Guid id) { var user = await userManager.FindByIdAsync(id.ToString()); if (user == null) { return(IdentityUtilsResult <TUser> .ErrorResult("User with specified ID not found")); } else { return(IdentityUtilsResult <TUser> .SuccessResult(user)); } }
public async Task <IdentityUtilsResult <TTenantDto> > UpdateTenant(TTenantDto tenantDto) { using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled); var hostsAlreadyExist = await dbContext.TenantHosts .Where(x => x.TenantId != tenantDto.TenantId) .Where(x => tenantDto.Hostnames.Contains(x.Hostname)) .AnyAsync(); if (hostsAlreadyExist) { return(IdentityUtilsResult <TTenantDto> .ErrorResult("Hostname already assigned to different tenant")); } var currentHosts = dbContext.TenantHosts.Where(x => x.TenantId == tenantDto.TenantId); dbContext.TenantHosts.RemoveRange(currentHosts); await dbContext.SaveChangesAsync(); var tenantDbResult = await GetTenantDb(tenantDto.TenantId, false); if (!tenantDbResult.Success) { return(IdentityUtilsResult <TTenantDto> .ErrorResult(tenantDbResult.ErrorMessages)); } var tenant = tenantDbResult.Data.First(); mapper.Map(tenantDto, tenant); var hosts = tenantDto.Hostnames .Select(x => new IdentityManagerTenantHost { TenantId = tenantDto.TenantId, Hostname = x }); var result = ModelValidator.ValidateDataAnnotations(tenant); if (!result.isValid) { return(IdentityUtilsResult <TTenantDto> .ErrorResult(result.ToIdentityUtilsResult().ErrorMessages)); } dbContext.Tenants.Update(tenant); dbContext.TenantHosts.AddRange(hosts); await dbContext.SaveChangesAsync(); scope.Complete(); return(IdentityUtilsResult <TTenantDto> .SuccessResult(ToDto(tenant))); }
public async Task <IdentityUtilsResult> DeleteTenant(Guid id) { var tenantDbResult = await GetTenantDb(id); if (!tenantDbResult.Success) { return(IdentityUtilsResult.ErrorResult(tenantDbResult.ErrorMessages)); } var hostsToDelete = dbContext.TenantHosts.Where(x => x.TenantId == id); dbContext.TenantHosts.RemoveRange(hostsToDelete); dbContext.Tenants.RemoveRange(tenantDbResult.Data); await dbContext.SaveChangesAsync(); return(IdentityUtilsResult.SuccessResult); }
private async Task <IdentityUtilsResult <TTenant> > GetTenantDb(Guid id, bool includeHosts = true) { var tenantQuery = dbContext.Tenants.Where(x => x.TenantId == id); TTenant tenant = null; if (includeHosts) { tenant = await tenantQuery.Include(x => x.Hosts).FirstOrDefaultAsync(); } else { tenant = await tenantQuery.FirstOrDefaultAsync(); } var result = tenant == null ? IdentityUtilsResult <TTenant> .ErrorResult("Tenant with specified ID does not exist") : IdentityUtilsResult <TTenant> .SuccessResult(tenant); return(result); }
public async Task <IdentityUtilsResult> UpdateUser(TUserDto user) { var userDbResult = await FindByIdAsync(user.Id); if (!userDbResult.Success) { return(IdentityUtilsResult.ErrorResult(userDbResult.ErrorMessages)); } var userDb = userDbResult.Data.First(); mapper.Map(user, userDb); var result = ModelValidator.ValidateDataAnnotations(userDb).ToIdentityUtilsResult(); if (!result.Success) { return(result.ToTypedResult <TUserDto>()); } var managerValidationResult = await new UserValidator <TUser>().ValidateAsync(userManager, userDb); if (!managerValidationResult.Succeeded) { return(managerValidationResult.ToIdentityUtilsResult().ToTypedResult <TUserDto>()); } var identityResult = await userManager.UpdateAsync(userDb); if (!identityResult.Succeeded) { return(identityResult.ToIdentityUtilsResult()); } mapper.Map(userDbResult.Data.Single(), user); return(IdentityUtilsResult.SuccessResult); }
public virtual async Task <IdentityUtilsResult <RoleBasicData> > GetUserRoles([FromRoute] Guid userId) { var userRoles = await userManager.GetRolesAsync(userId); return(IdentityUtilsResult <RoleBasicData> .SuccessResult(userRoles)); }
private static async Task LoadUsers(IServiceScope scope) { var userMgr = scope.ServiceProvider.GetRequiredService <UserManager <IdentityManagerUser> >(); var userService = scope.ServiceProvider.GetRequiredService <IIdentityManagerUserService <IdentityManagerUser, UserDto> >(); var roleMgr = scope.ServiceProvider.GetRequiredService <RoleManager <IdentityManagerRole> >(); var roleAdmin = await roleMgr.FindByNameAsync("ADMIN"); var roleReader = await roleMgr.FindByNameAsync("READER"); var roleGodmode = await roleMgr.FindByNameAsync("GODMODE"); var aliceExists = (await userMgr.FindByNameAsync("alice")) != null; if (!aliceExists) { var alice = new UserDto { Id = guidValueGenerator.Next(null), Username = "******", Password = "******" }; IdentityUtilsResult result = await userService.CreateUser(alice); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } var roles = new Guid[] { roleAdmin.Id, roleReader.Id, roleGodmode.Id }; result = await userService.AddToRolesAsync(alice.Id, roles); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } result = await userService.AddClaimsAsync(alice.Id, new Claim[] { new Claim(JwtClaimTypes.Id, Guid.NewGuid().ToString()), new Claim(JwtClaimTypes.Name, "Alice Smith"), new Claim(JwtClaimTypes.GivenName, "Alice"), new Claim(JwtClaimTypes.FamilyName, "Smith"), new Claim(JwtClaimTypes.Email, "*****@*****.**"), new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean), new Claim(JwtClaimTypes.WebSite, "http://alice.com"), new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json) }); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } } var bobExists = (await userMgr.FindByNameAsync("bob")) != null; if (!bobExists) { var bob = new UserDto { Id = guidValueGenerator.Next(null), Username = "******", Password = "******" }; IdentityUtilsResult result = await userService.CreateUser(bob); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } var roles = new Guid[] { roleAdmin.Id, roleReader.Id }; result = await userService.AddToRolesAsync(bob.Id, roles); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } result = await userService.AddClaimsAsync(bob.Id, new Claim[] { new Claim(JwtClaimTypes.Id, Guid.NewGuid().ToString()), new Claim(JwtClaimTypes.Name, "Bob Smith"), new Claim(JwtClaimTypes.GivenName, "Bob"), new Claim(JwtClaimTypes.FamilyName, "Smith"), new Claim(JwtClaimTypes.Email, "*****@*****.**"), new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean), new Claim(JwtClaimTypes.WebSite, "http://bob.com"), new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json), new Claim("location", "somewhere") }); if (!result.Success) { throw new Exception(result.ErrorMessages.First()); } } }
public virtual async Task <IdentityUtilsResult <TTenantDto> > Search([FromBody] TenantSearch tenantSearchRequest) { return(IdentityUtilsResult <TTenantDto> .SuccessResult(await tenantService.Search(tenantSearchRequest))); }
public virtual async Task <IdentityUtilsResult <TUserDto> > Search([FromBody] UsersSearch search) => IdentityUtilsResult <TUserDto> .SuccessResult(await userManager.Search(search));
public virtual async Task <IdentityUtilsResult <TokenResponse> > GetToken(TokenRequest request) { var config = HttpContext.RequestServices.GetService(typeof(IIdentityUtilsAuthenticationConfig)) as IIdentityUtilsAuthenticationConfig; request.ClientId = config?.ClientId ?? request.ClientId; HttpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues> { { "client_id", request.ClientId }, { "grant_type", request.GrantType }, { "username", request.Username }, { "password", request.Password }, { "refresh_token", request.RefreshToken }, }); // validate client var client = await clientStore.FindEnabledClientByIdAsync(request.ClientId); var invalidClient = !client.AllowedGrantTypes.Intersect(GrantTypes.ResourceOwnerPassword).Any() && !(request.GrantType == AuthenticationConstants.GrantTypeRefreshToken); if (client == null || invalidClient) { return(IdentityUtilsResult <TokenResponse> .ErrorResult($"Client id not found or invalid grant type")); } var clientResult = new ClientSecretValidationResult { IsError = false, Client = client }; var form = new NameValueCollection { { "client_id", request.ClientId }, { "grant_type", request.GrantType }, { "refresh_token", request.RefreshToken }, { "username", request.Username }, { "password", request.Password }, }; // validate request var requestResult = await requestValidator.ValidateRequestAsync(form, clientResult); if (requestResult.IsError) { await events.RaiseAsync(new TokenIssuedFailureEvent(requestResult)); return(IdentityUtilsResult <TokenResponse> .ErrorResult($"{requestResult.Error} - {requestResult.ErrorDescription}")); } // create response var response = await responseGenerator.ProcessAsync(requestResult); await events.RaiseAsync(new TokenIssuedSuccessEvent(response, requestResult)); // return result var tokenResponse = new TokenResponse { AccessToken = response.AccessToken, RefreshToken = response.RefreshToken, Lifetime = response.AccessTokenLifetime, Scopes = response.Scope.Split(' ') }; return(IdentityUtilsResult <TokenResponse> .SuccessResult(tokenResponse)); }