private async Task <IExternalUser> GetExternalUserAsync(ExternalAuthenticationCommand command)
            {
                IExternalUser externalUser = null;

                try
                {
                    var externalProviderAuthenticator = this.externalProviderAuthenticatorFactory.GetAuthenticator(command.ExternalProvider);

                    if (command.ClaimsPrincipal != null)
                    {
                        externalUser = await externalProviderAuthenticator.GetExternalUserAsync(command.ClaimsPrincipal);
                    }

                    if (command.ExternalAuthenticationData != null)
                    {
                        externalUser = await externalProviderAuthenticator.GetExternalUserAsync(
                            command.ExternalAuthenticationData.Provider,
                            command.ExternalAuthenticationData.AccessToken);
                    }
                }
                catch (Exception ex)
                {
                    await this.logger.LogErrorAsync(ex);
                }

                return(externalUser);
            }
Example #2
0
        internal ExternalAccountPreview(IExternalUser externalUser, IOAuthProvider provider)
        {
            var pid = externalUser.ProviderId;

            this.Id       = externalUser.Id;
            this.Username = externalUser.Username;
            this.Provider = new LoginProviderPreview(pid, provider.GetName(pid), provider.GetColour(pid));
        }
            private async Task AddExternalProviderToUserAsync(Guid userId, IExternalUser externalUser)
            {
                try
                {
                    var userLoginInfo = new UserLoginInfo(externalUser.Provider, externalUser.Id, externalUser.Provider);
                    var user          = await this.userManager.FindUserByIdAsync(userId);

                    await this.userManager.AddLoginAsync(user, userLoginInfo);
                }
                catch (Exception ex)
                {
                    await this.logger.LogErrorAsync(ex);
                }
            }
            private async Task <IUser> RegisterUserViaExternalProviderUserAsync(IExternalUser externalUser)
            {
                try
                {
                    var user = this.userManager.CreateUserObject(externalUser.EmailAddress, externalUser.Name, true);

                    var registerResult = await this.userManager.CreateAsync(user);

                    if (registerResult.Succeeded)
                    {
                        await this.AddExternalProviderToUserAsync(user.Id, externalUser);

                        await this.userManager.AddToRoleAsync(user, ApplicationRoles.User);

                        // apply avatar
                        var avatarUrl = await this.userAvatarService.CreateAvatarFromUrlAsync(externalUser.PictureUrl);

                        await this.userAvatarService.ApplyAvatarToUserAsync(user.Id, avatarUrl);

                        return(user);
                    }

                    return(default);
Example #5
0
        /// <inheritdoc/>
        public async Task <BearerAuthenticationResult> BuildJwtTokenForExternalUserAsync(IExternalUser externalUser)
        {
            try
            {
                var user = await this.userManager.FindByLoginAsync(externalUser.Provider, externalUser.Id);

                return(await this.BuildJwtTokenForUserAsync(user.Id));
            }
            catch (Exception ex)
            {
                await this.logger.LogErrorAsync(ex);

                return(null);
            }
        }