C# TwitterService.GetUserProfile方法代码示例

        public Account ProcessAuthentication(string pin)
        {
            TwitterService service = new TwitterService(_consumerKey, _consumerSecret);

            OAuthAccessToken access = service.GetAccessToken(_requestToken, pin);

            service.AuthenticateWith(access.Token, access.TokenSecret);

            var profile = service.GetUserProfile();

            Account account = AccountManager.Instance.GetCurrentAccounts().Where(acc => acc.Username == profile.ScreenName).FirstOrDefault();
            if (account != null)
            {
                throw new AuthFailureException("User " +account.Username +  " already has an account with TweetOBox.");
            }
            if (profile != null && account == null)
            {
                account = new Account();
                account.Username = profile.ScreenName;
               // account.Password = profile.p
                account.AccountType = (int)AccountTypeEnum.Twitter;
                account.AccessToken = access.Token;
                account.AccessTokenSecret = access.TokenSecret;
                account.IsOAuth = true;
                AccountManager.Instance.AddAccount(account,false);
            }
            else
            {
                throw new AuthFailureException(service.Response.StatusDescription);
            }

            return account;
        }

        public void Configuration(IAppBuilder app)
        {
            app.MapSignalR();

            // Disable keep alive, no need
            GlobalHost.Configuration.DisconnectTimeout = TimeSpan.FromMinutes(3);

            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = "ShootR",
                Provider = new ShootRAuthenticationProvider()
            });

            app.UseTwitterAuthentication(new TwitterAuthenticationOptions
            {
                Provider = new TwitterAuthenticationProvider
                {
                    OnAuthenticated = async context =>
                    {
                        var service = new TwitterService(ConfigurationManager.AppSettings["twitterConsumerKey"], ConfigurationManager.AppSettings["twitterConsumerSecret"]);
                        service.AuthenticateWith(context.AccessToken, context.AccessTokenSecret);

                        var profile = service.GetUserProfile(new GetUserProfileOptions
                        {
                            IncludeEntities = true
                        });

                        context.Identity.AddClaim(new Claim("profilePicture", profile.ProfileImageUrl));
                    }
                },
                SignInAsAuthenticationType = "ShootR",
                ConsumerKey = ConfigurationManager.AppSettings["twitterConsumerKey"],
                ConsumerSecret = ConfigurationManager.AppSettings["twitterConsumerSecret"]
            });

            app.UseGoogleAuthentication(new GoogleAuthenticationOptions
            {
                SignInAsAuthenticationType = "ShootR"
            });

            app.UseFacebookAuthentication(new FacebookAuthenticationOptions
            {
                Provider = new FacebookAuthenticationProvider
                {
                    OnAuthenticated = async context =>
                    {
                        context.Identity.AddClaim(new Claim("profilePicture", "https://graph.facebook.com/" + context.Identity.FindFirst(ClaimTypes.NameIdentifier).Value + "/picture?type=large"));
                    }
                },
                SignInAsAuthenticationType = "ShootR",
                AppId = ConfigurationManager.AppSettings["facebookAppId"],
                AppSecret = ConfigurationManager.AppSettings["facebookAppSecret"]
            });
        }

        public TokenData Get(IpData data)
        {
            // Pass your credentials to the service
            string consumerKey = _settings.TwitterConsumerKey;
            string consumerSecret = _settings.TwitterConsumerSecret;

            // Try to validate token
            var service = new TwitterService(consumerKey, consumerSecret);
            service.AuthenticateWith(data.Token, data.TokenSecret);

            TwitterUser user = service.GetUserProfile(new GetUserProfileOptions());
            if (user != null)
            {
                return new TokenData
                {
                    IdentityProvider = ProviderType.Twitter,
                    Name = user.Name,
                    UserIdentifier = string.Format(TwitterAccountPage, user.Id),
                    Token = data.Token,
                    TokenSecret = data.TokenSecret
                };
            }

            // Check response status code
            switch (service.Response.StatusCode)
            {
                case HttpStatusCode.Unauthorized:
                case HttpStatusCode.BadRequest:
                    throw new BadRequestException();

                case (HttpStatusCode)429:
                    throw new TooManyRequestsException();
            }

            // Twitter internal errors
            if ((int)service.Response.StatusCode >= 500)
            {
                throw new BadGatewayException(service.Response.Response);
            }

            string message = string.Format("Unable to receive twitter profile. Status code {0}: {1}", service.Response.StatusCode, service.Response.InnerException);
            throw new InternalServerErrorException(message);
        }

        public string GetResponseHtml(IDictionary<string, string> parameters, Uri signinUri)
        {
            var requestToken = new OAuthRequestToken { Token = parameters["oauth_token"] };

            // Exchange the Request Token for an Access Token
            string consumerKey = _settings.TwitterConsumerKey;
            string consumerSecret = _settings.TwitterConsumerSecret;

            var service = new TwitterService(consumerKey, consumerSecret);

            OAuthAccessToken accessToken = service.GetAccessToken(requestToken, parameters["oauth_verifier"]);
            service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);

            TwitterUser user = service.GetUserProfile(new GetUserProfileOptions());

            // Claims
            string name = user != null ? user.Name : accessToken.ScreenName;
            string nameIdentifier = string.Format(TwitterAccountPage, accessToken.UserId);
            string token = accessToken.Token;
            string tokenSecret = accessToken.TokenSecret;

            string acsNamespace = _settings.AcsNamespace;

            string wtRealm = string.Format(WtRealm, acsNamespace);
            string wReply = string.Format(WReply, acsNamespace);

            var requestMessage = new SignInRequestMessage(signinUri, wtRealm, wReply);

            // Add extracted claims
            var identity = new ClaimsIdentity(AuthenticationTypes.Federation);
            identity.AddClaim(new Claim(ClaimTypes.Name, name));
            identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, nameIdentifier));
            identity.AddClaim(new Claim(TwitterClaims.TwitterToken, token));
            identity.AddClaim(new Claim(TwitterClaims.TwitterTokenSecret, tokenSecret));

            var principal = new ClaimsPrincipal(identity);

            SignInResponseMessage responseMessage = FederatedPassiveSecurityTokenServiceOperations.ProcessSignInRequest(requestMessage, principal, this);
            responseMessage.Context = parameters["context"];

            return responseMessage.WriteFormPost();
        }

        public Account Authenticate(string userName, string password)
        {
            if (String.IsNullOrEmpty(userName) || String.IsNullOrEmpty(password))
            {
                throw new ArgumentNullException("userName");
            }

            TwitterService service = new TwitterService(ConfigurationManager.AppSettings["ConsumerKey"],
                ConfigurationManager.AppSettings["ConsumerSecret"]);

            OAuthAccessToken access = service.GetAccessTokenWithXAuth(userName, password);

            service.AuthenticateWith(access.Token, access.TokenSecret);

            var profile = service.GetUserProfile();

            Account account = AccountManager.Instance.GetCurrentAccounts().Where(acc => acc.Username == profile.ScreenName).FirstOrDefault();
            if (account != null)
            {
                throw new AuthFailureException("User " + account.Username + " already has an account with TweetOBox.");
            }
            if (profile != null && account == null)
            {
                account = new Account();
                account.Username = profile.ScreenName;
                // account.Password = profile.p
                account.AccountType = (int)AccountTypeEnum.Twitter;
                account.AccessToken = access.Token;
                account.AccessTokenSecret = access.TokenSecret;
                account.IsOAuth = true;
                AccountManager.Instance.AddAccount(account, false);
            }
            else
            {
                throw new AuthFailureException(service.Response.StatusDescription);
            }

            return account;
        }

        static void Main(string[] args)
        {
            //This app's unique Consumer Key (first argument) and Consumer Secret (second argument)
            TwitterService t_serv = new TwitterService("agvQyQIx2FFciJSpgCSwQ", "vdmcbG4EHveIQPA65WWzW1KYRFFFZY2B7MWFf2BHXqc");

            // Use this app's consumer info (consumer key and consumer secret) to get request token
            OAuthRequestToken r_token = t_serv.GetRequestToken();
            
            // Use request token and send user to Twitter to get a PIN
            Uri uri_1 = t_serv.GetAuthorizationUri(r_token); // get authorization URI using request token
            Process.Start(uri_1.ToString()); // 

            // Take in PIN and generate an access token and secret
            Console.WriteLine("Please enter the PIN number you received from Twitter: ");
            string ver_num = Console.ReadLine();
            OAuthAccessToken a_token = t_serv.GetAccessToken(r_token, ver_num);

            // Console.WriteLine("The PIN you entered was " + ver_num + ".");
            
            // authenticate using the access token and secret
            t_serv.AuthenticateWith(a_token.Token, a_token.TokenSecret);

            // get the tweets on the user's public timeline
            string user_sn = t_serv.GetUserProfile().ScreenName;

            Console.WriteLine("user id: " + user_sn);
            /*
            foreach (var tweet in lastTweets)
            {
                Console.WriteLine("{0} says {1}", tweet.User.ScreenName, tweet.Text);
            }
            */
           
            // step 4: save user data in a database

            // step 5: display database info in a webpage

            Console.ReadKey(true);
        }

        /// <summary>
        ///     Gets an user profile information.
        /// </summary>
        /// <param name="request">Request message.</param>
        /// <returns>User profile.</returns>
        public TwitterProfile GetProfile(TwitterRequest request)
        {
            // Pass your credentials to the service
            string consumerKey = _settings.TwitterConsumerKey;
            string consumerSecret = _settings.TwitterConsumerSecret;

            // Authorize
            var service = new TwitterService(consumerKey, consumerSecret);
            service.AuthenticateWith(request.Token, request.TokenSecret);

            // Get user info
            TwitterUser user = service.GetUserProfile(new GetUserProfileOptions());
            if (user != null)
            {
                return new TwitterProfile
                {
                    Id = user.Id,
                    ImageUrl = user.ProfileImageUrl,
                    Name = user.Name,
                    ScreenName = user.ScreenName
                };
            }

            // Check response status code
            switch (service.Response.StatusCode)
            {
                case HttpStatusCode.Unauthorized:
                case HttpStatusCode.BadRequest:
                    // Invalid credentials or request data
                    throw new BadRequestException(service.Response.Response);

                case (HttpStatusCode)429:
                    throw new TooManyRequestsException(service.Response.Response);
            }

            // Twitter internal errors
            if ((int)service.Response.StatusCode >= 500)
            {
                throw new BadGatewayException(service.Response.Response);
            }

            string message = string.Format("Unable to receive twitter profile. Status code {0}: {1}", service.Response.StatusCode, service.Response);
            throw new InternalServerErrorException(message);
        }

        private async Task DownloadTwitterProfileImage(IEnumerable<Claim> claims, string userId)
        {
            // Retrieve the twitter access token and claim
            var accessTokenClaim = claims.FirstOrDefault(x => x.Type == Startup.TwitterAccessTokenClaimType);
            var accessTokenSecretClaim = claims.FirstOrDefault(x => x.Type == Startup.TwitterAccessTokenSecretClaimType);

            if (accessTokenClaim != null && accessTokenSecretClaim != null)
            {
                // Initialize the Twitter client
                var service = new TwitterService(
                    Startup.TwitterConsumerKey,
                    Startup.TwitterConsumerSecret,
                    accessTokenClaim.Value,
                    accessTokenSecretClaim.Value
                    );

                var profile = service.GetUserProfile(new GetUserProfileOptions());
                if (profile != null && !String.IsNullOrWhiteSpace(profile.ProfileImageUrlHttps))
                {
                    string filename = Server.MapPath(string.Format("~/ProfileImages/{0}.jpeg", userId));

                    await DownloadProfileImage(new Uri(profile.ProfileImageUrlHttps), filename);
                }
            }
        }

        /// <summary>
        /// Retreive the url of the Connected Twitter Users's profile picture
        /// </summary>
        /// <param name="accessToken">Twitter user's Access Token</param>
        /// <param name="accessTokenSecret">Twitter user's Access Token Secret</param>
        /// <returns>Url of the Twitter Users's profile picture</returns>
        private string GetTwitterProfileImage(string accessToken, string accessTokenSecret)
        {
            if (accessToken != null && accessTokenSecret != null)
            {
                // Initialize the Twitter client
                var service = new TwitterService(
                    ConfigurationManager.AppSettings["TwitterConsumerKey"],
                    ConfigurationManager.AppSettings["TwitterConsumerSecret"],
                    accessToken,
                    accessTokenSecret
                    );
                var profile = service.GetUserProfile(new GetUserProfileOptions());

                if (profile != null && !String.IsNullOrWhiteSpace(profile.ProfileImageUrlHttps))
                {
                    return profile.ProfileImageUrlHttps;
                }
                return "";
            }
            return null;
        }

        public ChannelSocialProfile GetProfile()
        {
            var service = new TwitterService(ChannelHelper.ConsumerKey, ChannelHelper.ConsumerSecret, ChannelHelper.Token, ChannelHelper.TokenSecret);
            var result = service.GetUserProfile();

            return new ChannelSocialProfile
                {
                    Id = result.Id.ToString(),
                    FullName = result.Name,
                    AvatarUrl = result.ProfileImageUrl
                };
        }

 public async Task<ActionResult> TwitterLoginCallBack(string object_id, string access_token, string access_token_secret, string tw_key)
 {
     bool success = false;
     var twLoginInfo = new UserLoginInfo("Twitter", tw_key);
     MyUser my_user = await UserManager.FindByIdAsync(object_id);
     if (my_user != null)
     {
         success = SetCurrentUser(AuthType.Twitter, my_user, access_token, access_token_secret);
         return Json(new { OK = success });  
     }
     var tw_service = new TwitterService
     (
         consumerKey: ExternalAuthManaher.TwitterService.AppID,
         consumerSecret: ExternalAuthManaher.TwitterService.AppSecret,
         token: access_token,
         tokenSecret: access_token_secret
     );
     var userInfo =  tw_service.GetUserProfile(new GetUserProfileOptions());
     if(userInfo != null)
     {
         
         success = await RegisterUser(
              new RegisterUserModel
              {
                  RegisterType = AuthType.Twitter,
                  LoginProvider = twLoginInfo,
                  UserClaims = new List<Claim> 
                     {
                         new Claim("TwitterAccessToken", access_token),
                         new Claim("TwitterAccessTokenSecret", access_token_secret),
                         new Claim("TwitterPageLink", ("https://twitter.com/" + userInfo.ScreenName)),
                         new Claim("TwitterId", userInfo.Id.ToString()),
                         new Claim("Photo", userInfo.ProfileImageUrl)
                     },
                  Name = userInfo.ScreenName,
                  Login = "TwitterUser",
                  Object_id = object_id
              });
         return Json(new { OK = success }); 
     }
     return Json(new { OK = false });  
 }

        /// <summary>
        /// Returns the current user (fails if there is no status yet)
        /// Missing method in TweetSharp
        /// </summary>
        /// <returns>the current Twitter User</returns>
        internal TwitterUser GetStats()
        {
            var service = new TwitterService(ClientInfo);
            service.AuthenticateWith(Token, TokenSecret);

            LastResponse = service.Response;
            return service.GetUserProfile();
        }

 public Task<TwitterUser> GetWebData(string consumerKey, string consumerSecret, string accessToken, string accessTokenSecret)
 {
     var service = new TwitterService(consumerKey, consumerSecret);
     service.AuthenticateWith(accessToken, accessTokenSecret);
     return Task.FromResult(service.GetUserProfile(new GetUserProfileOptions()));
 }

        /// <summary>
        /// Source: http://www.jerriepelser.com/blog/get-the-twitter-profile-image-using-the-asp-net-identity
        /// https://github.com/jerriep/AspNetIdentitySocialProfileImage/blob/master/Controllers/AccountController.cs
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        private async Task DownloadTwitterProfileImage(string userId)
        {
            var identity = (ClaimsIdentity)User.Identity;
            IEnumerable<Claim> claims = identity.Claims;

            if (claims != null)
            {
                // Retrieve the twitter access token and claim
                var accessTokenClaim = claims.FirstOrDefault(x => x.Type == TwitterSettings.AccessTokenClaimType);
                var accessTokenSecretClaim = claims.FirstOrDefault(x => x.Type == TwitterSettings.AccessTokenSecretClaimType);

                if (accessTokenClaim != null && accessTokenSecretClaim != null)
                {
                    // Initialize the Twitter client
                    var service = new TwitterService(
                        TwitterSettings.ConsumerKey,
                        TwitterSettings.ConsumerSecret,
                        accessTokenClaim.Value,
                        accessTokenSecretClaim.Value
                    );

                    var profile = service.GetUserProfile(new GetUserProfileOptions());
                    // Try to download user image.
                    if (profile != null && !String.IsNullOrWhiteSpace(profile.ProfileImageUrlHttps))
                    {
                        string filename = Server.MapPath(string.Format("~/ProfileImages/{0}.jpeg", userId));
                        await DownloadProfileImage(new Uri(profile.ProfileImageUrlHttps), filename);
                    }
                }
            }
        }