コード例 #1
0
        protected internal virtual async Task <UserEntity> EnsureLoginUserAsync(UserLoginModel userLogin)
        {
            if (userLogin == null)
            {
                throw new ArgumentNullException(nameof(userLogin));
            }

            UserEntity loginUser = null;

            if (userLogin.Id != null)
            {
                loginUser = await this.DatabaseContext.Users.FindAsync(userLogin.Id);
            }

            if (loginUser == null)
            {
                loginUser = new UserEntity {
                    Id = userLogin.Id ?? Guid.NewGuid().ToString(), UserName = Guid.NewGuid().ToString()
                };
                loginUser.NormalizedUserName = loginUser.UserName.ToUpperInvariant();
                await this.DatabaseContext.Users.AddAsync(loginUser);
            }
            else
            {
                if (loginUser.PasswordHash != null)
                {
                    throw new InvalidOperationException($"The user with id {loginUser.Id.ToStringRepresentation()} already exists with a password and can not be associated with a login.");
                }

                loginUser.SecurityStamp = Guid.NewGuid().ToString();
            }

            return(loginUser);
        }
コード例 #2
0
        protected internal virtual async Task <UserLoginEntity> UserLoginModelToUserLoginEntityAsync(UserLoginModel userLogin)
        {
            UserLoginEntity userLoginEntity = null;

            if (userLogin != null)
            {
                userLoginEntity = new UserLoginEntity {
                    LoginProvider = userLogin.Provider, ProviderDisplayName = userLogin.Provider, ProviderKey = userLogin.UserIdentifier, UserId = userLogin.Id
                }
            }
            ;

            return(await Task.FromResult(userLoginEntity));
        }
コード例 #3
0
        public virtual async Task <IdentityResult> SaveUserLoginAsync(UserLoginModel userLogin, bool allowMultipleLoginsForUser = false)
        {
            if (userLogin == null)
            {
                throw new ArgumentNullException(nameof(userLogin));
            }

            if (userLogin.Provider == null)
            {
                throw new ArgumentException("The user-login-provider can not be null.", nameof(userLogin));
            }

            if (userLogin.UserIdentifier == null)
            {
                throw new ArgumentException("The user-login-user-identifier can not be null.", nameof(userLogin));
            }

            try
            {
                var existingUserLogin = await this.DatabaseContext.UserLogins.FirstOrDefaultAsync(item => item.LoginProvider == userLogin.Provider && item.ProviderKey == userLogin.UserIdentifier);

                if (existingUserLogin != null)
                {
                    if (userLogin.Id != null && !string.Equals(userLogin.Id, existingUserLogin.UserId, StringComparison.OrdinalIgnoreCase))
                    {
                        var oldLoginUserId = existingUserLogin.UserId;
                        var numberOfUserLoginsForOldLoginUserId = await this.DatabaseContext.UserLogins.CountAsync(item => item.UserId == oldLoginUserId);

                        var newLoginUser = await this.EnsureLoginUserAsync(userLogin);

                        existingUserLogin.UserId = newLoginUser.Id;

                        if (numberOfUserLoginsForOldLoginUserId < 2)
                        {
                            this.DatabaseContext.Users.Remove(await this.DatabaseContext.Users.FindAsync(oldLoginUserId));
                        }
                        else
                        {
                            this.DatabaseContext.UserClaims.RemoveRange(this.DatabaseContext.UserClaims.Where(item => item.UserId == oldLoginUserId));
                            (await this.DatabaseContext.Users.FindAsync(oldLoginUserId)).SecurityStamp = Guid.NewGuid().ToString();
                        }
                    }
                }
                else
                {
                    var loginUser = await this.EnsureLoginUserAsync(userLogin);

                    this.DatabaseContext.UserClaims.RemoveRange(this.DatabaseContext.UserClaims.Where(item => item.UserId == loginUser.Id));
                    this.DatabaseContext.UserLogins.RemoveRange(this.DatabaseContext.UserLogins.Where(item => item.UserId == loginUser.Id));

                    await this.DatabaseContext.UserLogins.AddAsync(new UserLoginEntity { LoginProvider = userLogin.Provider, ProviderDisplayName = userLogin.Provider, ProviderKey = userLogin.UserIdentifier, UserId = loginUser.Id });
                }

                if (!allowMultipleLoginsForUser && userLogin.Id != null)
                {
                    var userLoginsToDelete = this.DatabaseContext.UserLogins.Where(item => item.UserId == userLogin.Id && item.LoginProvider != userLogin.Provider && item.ProviderKey != userLogin.UserIdentifier);

                    if (userLoginsToDelete.Any())
                    {
                        this.DatabaseContext.UserLogins.RemoveRange(userLoginsToDelete);
                        this.DatabaseContext.UserClaims.RemoveRange(this.DatabaseContext.UserClaims.Where(item => item.UserId == userLogin.Id));
                        (await this.DatabaseContext.Users.FindAsync(userLogin.Id)).SecurityStamp = Guid.NewGuid().ToString();
                    }
                }

                return(IdentityResult.Success);
            }
            catch (Exception exception)
            {
                throw new InvalidOperationException($"Could not save user-login with id {userLogin.Id.ToStringRepresentation()}, provider {userLogin.Provider.ToStringRepresentation()} and user-identifier {userLogin.UserIdentifier.ToStringRepresentation()}.", exception);
            }
        }