public void Execute()
        {
            ITwitterUserProfile profile = twitterClient.GetUser(OAuthToken, OAuthVerifier);

            OAuthUser user = service.GetById(currentUserDetails.UserId);

            if (user == null)
                return;

            if (!user.HasLinkedExternalProvider(ExternalAuthenticationType.Twitter))
            {
                var linkCommand = linkExistingUserToExternalProviderPreCommandAccessor();

                linkCommand.Identifier = Identifier = user.Id;
                linkCommand.Username = Username = profile.Username;
                linkCommand.Email = Email = "*****@*****.**";
                linkCommand.ExternalIdentifier = ExternalIdentifier = profile.Identifier;
                linkCommand.ExternalProvider = ExternalProvider = ExternalAuthenticationType.Twitter;
                linkCommand.Token = profile.Token;
                linkCommand.TokenSecret = profile.TokenSecret;

                Roles = user.RolesAsString;

                linkCommand.Execute();
            }

            Success = true;
            executed = true;
        }
        public void Execute()
        {
            if (facebookClient.HasLoginBeenSuccessful(Url.ToString()))
            {
                IFacebookUserProfile profile = facebookClient.GetUserFromCode(Code);

                OAuthUser user = service.GetByEmail(profile.Email, configuration.ApplicationName);

                if (user == null)
                {
                    var registerCommand = registerExternalUserPreCommandAccessor();

                    registerCommand.Identifier = Identifier = Guid.NewGuid();
                    registerCommand.Username = Username = profile.Username;
                    registerCommand.Email = Email = profile.Email;
                    registerCommand.ExternalIdentifier = ExternalIdentifier = profile.Identifier;
                    registerCommand.ExternalProvider = ExternalProvider = ExternalAuthenticationType.Facebook;
                    registerCommand.Token = profile.Token;

                    registerCommand.Execute();
                }
                else if (!user.HasLinkedExternalProvider(ExternalAuthenticationType.Facebook))
                {
                    var linkCommand = linkExistingUserToExternalProviderPreCommandAccessor();

                    linkCommand.Identifier = Identifier = user.Id;
                    linkCommand.Username = Username = profile.Username;
                    linkCommand.Email = Email = profile.Email;
                    linkCommand.ExternalIdentifier = ExternalIdentifier = profile.Identifier;
                    linkCommand.ExternalProvider = ExternalProvider = ExternalAuthenticationType.Facebook;
                    linkCommand.Token = profile.Token;

                    Roles = user.RolesAsString;

                    linkCommand.Execute();
                }
                else
                {
                    Identifier = user.Id;
                    Username = user.Username;
                    Email = profile.Email;
                    ExternalIdentifier = profile.Identifier;
                    ExternalProvider = ExternalAuthenticationType.Facebook;
                    Roles = user.RolesAsString;
                }

                Bus.Send<ILoggedUserInUsingOAuthProviderCommandMessage>(x =>
                {
                    x.UserId = Identifier;
                    x.Username = Username;
                    x.ApplicationName = configuration.ApplicationName;
                    x.LoginDate = DateTime.Now;
                });

                Success = true;
            }

            executed = true;
        }
Пример #3
0
        public ExternalAuthenticationValidation Create(ExternalAuthenticationType type)
        {
            switch (type)
            {
            case ExternalAuthenticationType.Google:
                return(new GoogleApiTokenValidation(_extensionSetting));

            default:
                return(new GoogleApiTokenValidation(_extensionSetting));
            }
        }
        public void Execute()
        {
            IFoursquareUserProfile profile = foursquareClient.GetUserFromCode(Code, new UriBuilder(string.Format("http://{0}", Url.Authority)) { Path = Path }.Uri.ToString());

            OAuthUser user = service.GetByEmail(profile.Email, configuration.ApplicationName);

            if (user == null && !string.IsNullOrEmpty(profile.FacebookIdentifier))
            {
                string facebookIdentifier = profile.FacebookIdentifier;

                if (!string.IsNullOrEmpty(facebookIdentifier))
                    user = service.GetByExternalAuthenticatorIdentifier(facebookIdentifier, ExternalAuthenticationType.Facebook, configuration.ApplicationName);
            }

            if (user == null)
            {
                var registerCommand = registerExternalUserPreCommandAccessor();

                registerCommand.Identifier = Identifier = Guid.NewGuid();
                registerCommand.Username = Username = profile.Username;
                registerCommand.Email = Email = profile.Email;
                registerCommand.ExternalIdentifier = ExternalIdentifier = profile.Identifier;
                registerCommand.ExternalProvider = ExternalProvider = ExternalAuthenticationType.Foursquare;
                registerCommand.Token = profile.Token;

                registerCommand.Execute();
            }
            else if (!user.HasLinkedExternalProvider(ExternalAuthenticationType.Foursquare))
            {
                var linkCommand = linkExistingUserToExternalProviderPreCommandAccessor();

                linkCommand.Identifier = Identifier = user.Id;
                linkCommand.Username = Username = profile.Username;
                linkCommand.Email = Email = profile.Email;
                linkCommand.ExternalIdentifier = ExternalIdentifier = profile.Identifier;
                linkCommand.ExternalProvider = ExternalProvider = ExternalAuthenticationType.Foursquare;
                linkCommand.Token = profile.Token;

                Roles = user.RolesAsString;

                linkCommand.Execute();
            }
            else
            {
                Identifier = user.Id;
                Username = user.Username;
                Email = profile.Email;
                ExternalIdentifier = profile.Identifier;
                ExternalProvider = ExternalAuthenticationType.Foursquare;
                Roles = user.RolesAsString;
            }

            Bus.Send<ILoggedUserInUsingOAuthProviderCommandMessage>(x =>
            {
                x.UserId = Identifier;
                x.Username = Username;
                x.ApplicationName = configuration.ApplicationName;
                x.LoginDate = DateTime.Now;
            });

            Success = true;
            executed = true;
        }