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))); }
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 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)); }
/// <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 <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); }
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)); }
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)); }
/// <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))); }
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 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 <RoleBasicData> > GetUserRoles([FromRoute] Guid userId) { var userRoles = await userManager.GetRolesAsync(userId); return(IdentityUtilsResult <RoleBasicData> .SuccessResult(userRoles)); }
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)); }