public ActionResult ConnectTwitterComplete()
{
// Denied authorization
var param = Request.QueryString["denied"];
if (!string.IsNullOrEmpty(param))
{
TempData.SetStatusMessage(ViewRes.User.LoginUsingAuthStrings.SignInCancelled);
return(RedirectToAction("MySettings"));
}
var response = new TwitterConsumer().ProcessUserAuthorization(Hostname);
if (response == null)
{
TempData.SetStatusMessage(ViewRes.User.LoginUsingAuthStrings.AuthError);
return(RedirectToAction("MySettings"));
}
int twitterId;
int.TryParse(response.ExtraData["user_id"], out twitterId);
var twitterName = response.ExtraData["screen_name"];
if (Service.ConnectTwitter(response.AccessToken, twitterId, twitterName, WebHelper.GetRealHost(Request)))
{
TempData.SetStatusMessage("Connected successfully");
}
else
{
ModelState.AddModelError("Authentication", ViewRes.User.LoginUsingAuthStrings.AuthError);
}
return(RedirectToAction("MySettings"));
}
public ActionResult LoginTwitterComplete()
{
// Denied authorization
var param = Request.QueryString["denied"];
if (!string.IsNullOrEmpty(param))
{
TempData.SetStatusMessage(ViewRes.User.LoginUsingAuthStrings.SignInCancelled);
return(View("Login", new LoginModel(string.Empty, !WebHelper.IsSSL(Request), true)));
}
var response = new TwitterConsumer().ProcessUserAuthorization(Hostname);
if (response == null)
{
ModelState.AddModelError("Authentication", ViewRes.User.LoginUsingAuthStrings.AuthError);
return(View("Login", new LoginModel(string.Empty, !WebHelper.IsSSL(Request), true)));
}
var user = Service.CheckTwitterAuthentication(response.AccessToken, Hostname);
if (user == null)
{
int twitterId;
int.TryParse(response.ExtraData["user_id"], out twitterId);
var twitterName = response.ExtraData["screen_name"];
return(View(new RegisterOpenAuthModel(response.AccessToken, twitterName, twitterId, twitterName)));
}
HandleCreate(user);
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// Gets tweets posted by specified user
/// </summary>
/// <param name="messageCount">Message count</param>
/// <returns>Message list</returns>
public List <Message> GetUserTweets(decimal?userID, string screenName, int messageCount)
{
int localUserId = 0;
if (userID.HasValue)
{
localUserId = (int)userID.Value;
}
var userTimeLine = TwitterConsumer.GetUserTimeLine(TwitterSignIn, _apiInfo.AccessToken, localUserId, screenName, true, messageCount);
if (userTimeLine == null)
{
return(new List <Message>());
}
return(userTimeLine.Select(x => (Message)(new TwitterMessage
{
UserName = x["user"].Value <String>("name"),
PostedOn = ParseTweetDateTime(x.Value <String>("created_at")),
Source = SocialNetworks.Twitter,
Text = ParseTweetTextIntoHtml(x.Value <String>("text")),
UserImageUrl = x["user"].Value <String>("profile_image_url")
})).Take(20).ToList());
}
public LoginProfile ProcessAuthoriztion(HttpContext context, IDictionary <string, string> @params)
{
var token = context.Request["oauth_token"];
if (string.IsNullOrEmpty(token))
{
var request = TwitterConsumer.StartSignInWithTwitter(TwitterSignIn, false);
request.Send();
}
else
{
string screenName;
int userId;
string accessToken;
if (TwitterConsumer.TryFinishSignInWithTwitter(TwitterSignIn, out screenName, out userId, out accessToken))
{
//Sucess. Get information
var info = TwitterConsumer.GetUserInfo(TwitterSignIn, userId, accessToken);
var profile = ProfileFromTwitter(info);
return(profile);
}
return(LoginProfile.FromError(new Exception("Login failed")));
}
return(null);
}
public ActionResult LoginTwitter(string returnUrl)
{
// Make sure session ID is initialized
// ReSharper disable UnusedVariable
var sessionId = Session.SessionID;
// ReSharper restore UnusedVariable
var twitterSignIn = new TwitterConsumer().TwitterSignIn;
var targetUrl = Url.Action("LoginTwitterComplete", new { returnUrl });
var uri = new Uri(new Uri(AppConfig.HostAddress), targetUrl);
UserAuthorizationRequest request;
try {
request = twitterSignIn.PrepareRequestUserAuthorization(uri, null, null);
} catch (ProtocolException x) {
log.Error(x, "Exception while attempting to send Twitter request");
TempData.SetErrorMessage("There was an error while connecting to Twitter - please try again later.");
return(RedirectToAction("Login"));
}
var response = twitterSignIn.Channel.PrepareResponse(request);
response.Send();
Response.End();
return(new EmptyResult());
}
protected void Page_Load(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
if (TwitterConsumer.IsTwitterConsumerConfigured)
{
this.MultiView1.ActiveViewIndex = 1;
if (!IsPostBack)
{
var tuple = await TwitterConsumer.TryFinishSignInWithTwitterAsync();
if (tuple != null)
{
string screenName = tuple.Item1;
int userId = tuple.Item2;
this.loggedInPanel.Visible = true;
this.loggedInName.Text = screenName;
// In a real app, the Twitter username would likely be used
// to log the user into the application.
////FormsAuthentication.RedirectFromLoginPage(screenName, false);
}
}
}
}));
}
public string GetTweets()
{
// Uppgift 6:
var twitter = new WebConsumer(TwitterConsumer.ServiceDescription, this.TokenManager);
XPathDocument updates = new XPathDocument(TwitterConsumer.GetUpdates(twitter, this.AccessToken).CreateReader());
XPathNavigator nav = updates.CreateNavigator();
var parsedUpdates = from status in nav.Select("/statuses/status").OfType <XPathNavigator>()
where !status.SelectSingleNode("user/protected").ValueAsBoolean
select new
{
User = status.SelectSingleNode("user/name").InnerXml,
Status = status.SelectSingleNode("text").InnerXml,
};
StringBuilder tableBuilder = new StringBuilder();
tableBuilder.Append("<table><tr><td>Name</td><td>Update</td></tr>");
foreach (var update in parsedUpdates)
{
tableBuilder.AppendFormat(
"<tr><td>{0}</td><td>{1}</td></tr>",
HttpUtility.HtmlEncode(update.User),
HttpUtility.HtmlEncode(update.Status));
}
tableBuilder.Append("</table>");
return(tableBuilder.ToString());
}
private void DoTwitterLogin(HttpContext context, string returnUrl)
{
if (TwitterConsumer.IsTwitterConsumerConfigured)
{
var token = context.Request["oauth_token"];
if (string.IsNullOrEmpty(token))
{
var request = TwitterConsumer.StartSignInWithTwitter(false);
request.Send();
}
else
{
string screenName;
int userId;
string accessToken;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId, out accessToken))
{
//Sucess. Get information
var info = TwitterConsumer.GetUserInfo(userId, accessToken);
var profile = UniversalProfile.ProfileFromTwitter(info);
RedirectToReturnUrl(context, returnUrl, profile);
}
else
{
RedirectToReturnUrl(context, returnUrl, UniversalProfile.FromError(new Exception("Login failed")));
}
}
}
}
protected void downloadUpdates_Click(object sender, EventArgs e)
{
var twitter = new WebConsumer(TwitterConsumer.ServiceDescription, this.TokenManager);
XPathDocument updates = new XPathDocument(TwitterConsumer.GetUpdates(twitter, this.AccessToken).CreateReader());
XPathNavigator nav = updates.CreateNavigator();
var parsedUpdates = from status in nav.Select("/statuses/status").OfType <XPathNavigator>()
where !status.SelectSingleNode("user/protected").ValueAsBoolean
select new {
User = status.SelectSingleNode("user/name").InnerXml,
Status = status.SelectSingleNode("text").InnerXml,
};
StringBuilder tableBuilder = new StringBuilder();
tableBuilder.Append("<table><tr><td>Name</td><td>Update</td></tr>");
foreach (var update in parsedUpdates)
{
tableBuilder.AppendFormat(
"<tr><td>{0}</td><td>{1}</td></tr>",
HttpUtility.HtmlEncode(update.User),
HttpUtility.HtmlEncode(update.Status));
}
tableBuilder.Append("</table>");
resultsPlaceholder.Controls.Add(new Literal {
Text = tableBuilder.ToString()
});
}
protected void downloadUpdates_Click(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
var twitter = new TwitterConsumer();
var statusesJson = await twitter.GetUpdatesAsync(this.AccessToken);
StringBuilder tableBuilder = new StringBuilder();
tableBuilder.Append("<table><tr><td>Name</td><td>Update</td></tr>");
foreach (dynamic update in statusesJson)
{
if ([email protected])
{
tableBuilder.AppendFormat(
"<tr><td>{0}</td><td>{1}</td></tr>",
HttpUtility.HtmlEncode(update.user.screen_name),
HttpUtility.HtmlEncode(update.text));
}
}
tableBuilder.Append("</table>");
this.resultsPlaceholder.Controls.Add(new Literal {
Text = tableBuilder.ToString()
});
}));
}
protected void Page_Load(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
var twitter = new TwitterConsumer();
if (twitter.ConsumerKey != null)
{
this.MultiView1.ActiveViewIndex = 1;
if (!IsPostBack)
{
// Is Twitter calling back with authorization?
var accessTokenResponse = await twitter.ProcessUserAuthorizationAsync(this.Request.Url);
if (accessTokenResponse != null)
{
this.AccessToken = accessTokenResponse.AccessToken;
}
else
{
// If we don't yet have access, immediately request it.
Uri redirectUri = await twitter.RequestUserAuthorizationAsync(MessagingUtilities.GetPublicFacingUrl());
this.Response.Redirect(redirectUri.AbsoluteUri);
}
}
}
}));
}
public TokensWrapper(TwitterConsumer consumer)
{
_tokens = new Tokens();
_tokens.ConsumerKey = consumer.ApiKey;
_tokens.ConsumerSecret = consumer.ApiSecret;
_tokens.AccessToken = consumer.AccessToken;
_tokens.AccessTokenSecret = consumer.AccessSecret;
}
private void HandleTwitterResponse()
{
string screenName;
int userId;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId))
{
AuthenticatedUser(screenName, "", screenName, userId.ToString(CultureInfo.CurrentCulture), "Twitter");
}
}
public string Tweet([FromBody] TwitterConsumer consumer)
{
var fact = GetFact();
var image = GetImage();
_twitter.Setup(new TokensWrapper(consumer));
_twitter.Tweet(fact, image);
return(fact);
}
public string PrepareAuthRequest(PrepareAuthenticationContext context)
{
var callback =
new Uri(Utils.GetUrlBase(context.Request) + context.RedirectPath);
var consumer = new TwitterConsumer(context.SessionStorage);
return(consumer
.StartSignInWithTwitter(callback)
.Headers["Location"]);
}
protected void signInButton_Click(object sender, ImageClickEventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
Uri redirectUri =
await
TwitterConsumer.StartSignInWithTwitterAsync(this.forceLoginCheckbox.Checked, Response.ClientDisconnectedToken);
this.Response.Redirect(redirectUri.AbsoluteUri);
}));
}
public void Setup()
{
twitter = new Twitter();
mTokens = new Mock <ITokensWrapper>();
consumer = new TwitterConsumer
{
ApiKey = "apikey",
ApiSecret = "apisecret",
AccessToken = "accesstoken",
AccessSecret = "accesssecrete"
};
}
public void LoginTwitter()
{
// Make sure session ID is initialized
// ReSharper disable UnusedVariable
var sessionId = Session.SessionID;
// ReSharper restore UnusedVariable
var twitterSignIn = new TwitterConsumer().TwitterSignIn;
var uri = new Uri(new Uri(AppConfig.HostAddress), Url.Action("LoginTwitterComplete"));
var request = twitterSignIn.PrepareRequestUserAuthorization(uri, null, null);
var response = twitterSignIn.Channel.PrepareResponse(request);
response.Send();
Response.End();
}
public ActionResult LoginTwitterComplete(string returnUrl)
{
// Denied authorization
var param = Request.QueryString["denied"];
if (!string.IsNullOrEmpty(param))
{
TempData.SetStatusMessage(ViewRes.User.LoginUsingAuthStrings.SignInCancelled);
return(View("Login", new LoginModel(string.Empty, !WebHelper.IsSSL(Request), true)));
}
var response = new TwitterConsumer().ProcessUserAuthorization(Hostname);
if (response == null)
{
ModelState.AddModelError("Authentication", ViewRes.User.LoginUsingAuthStrings.AuthError);
return(View("Login", new LoginModel(string.Empty, !WebHelper.IsSSL(Request), true)));
}
var culture = WebHelper.GetInterfaceCultureName(Request);
var user = Service.CheckTwitterAuthentication(response.AccessToken, Hostname, culture);
if (user == null)
{
int twitterId;
int.TryParse(response.ExtraData["user_id"], out twitterId);
var twitterName = response.ExtraData["screen_name"];
return(View(new RegisterOpenAuthModel(response.AccessToken, twitterName, twitterId, twitterName)));
}
HandleCreate(user);
string targetUrl;
if (!string.IsNullOrEmpty(returnUrl))
{
targetUrl = VocaUriBuilder.AbsoluteFromUnknown(returnUrl, preserveAbsolute: true, ssl: false);
}
else
{
targetUrl = Url.Action("Index", "Home");
}
return(Redirect(targetUrl));
}
protected void uploadProfilePhotoButton_Click(object sender, EventArgs e)
{
if (profilePhoto.PostedFile.ContentType == null)
{
photoUploadedLabel.Visible = true;
photoUploadedLabel.Text = "Select a file first.";
return;
}
var twitter = new WebConsumer(TwitterConsumer.ServiceDescription, this.TokenManager);
XDocument imageResult = TwitterConsumer.UpdateProfileImage(
twitter,
this.AccessToken,
profilePhoto.PostedFile.InputStream,
profilePhoto.PostedFile.ContentType);
photoUploadedLabel.Visible = true;
}
public string Tweet(string newstatus)
{
// Skapa tweets
var twitter = new WebConsumer(TwitterConsumer.ServiceDescription, this.TokenManager);
string resultString;
try
{
string updates = TwitterConsumer.Tweet(twitter, this.AccessToken, newstatus);
JToken token = JObject.Parse(updates);
resultString = string.Format("{0} - {1}", (string)token.SelectToken("user").SelectToken("screen_name"), (string)token.SelectToken("text"));
}
catch
{
resultString = "Error! Could not send new tweet.";
}
return(resultString);
}
/// <summary>
/// Gets last 20 users
/// </summary>
/// <param name="search">Search string</param>
/// <returns>TwitterUserInfo list</returns>
public List <TwitterUserInfo> FindUsers(string search)
{
var findedUsers = TwitterConsumer.SearchUsers(TwitterSignIn, search, _apiInfo.AccessToken);
if (findedUsers == null)
{
return(new List <TwitterUserInfo>());
}
return(findedUsers.Select(x => new TwitterUserInfo
{
UserID = x.Value <Decimal>("id"),
Description = x.Value <String>("description"),
ScreenName = x.Value <String>("screen_name"),
SmallImageUrl = x.Value <String>("profile_image_url"),
UserName = x.Value <String>("name")
}).Take(20).ToList());
}
/// <summary>
/// Loads specified user information
/// </summary>
/// <param name="userID">Twitter user ID</param>
/// <returns>TwitterUserInfo obect</returns>
public TwitterUserInfo LoadUserInfo(decimal userID)
{
var userInfo = TwitterConsumer.GetUserInfo(TwitterSignIn, (int)userID, String.Empty, _apiInfo.AccessToken);
if (userInfo == null)
{
return(new TwitterUserInfo());
}
return(new TwitterUserInfo
{
UserID = userInfo.Value <Decimal>("id"),
Description = userInfo.Value <String>("description"),
ScreenName = userInfo.Value <String>("screen_name"),
SmallImageUrl = userInfo.Value <String>("profile_image_url"),
UserName = userInfo.Value <String>("name")
});
}
/// <summary>
/// Gets current user (defined by access token) home timeline
/// </summary>
/// <param name="messageCount">Message count</param>
/// <returns>Message list</returns>
public List <Message> GetUserHomeTimeLine(int messageCount)
{
var homeTimeLine = TwitterConsumer.GetHomeTimeLine(TwitterSignIn, _apiInfo.AccessToken, true, messageCount);
if (homeTimeLine == null)
{
return(new List <Message>());
}
return(homeTimeLine.Select(x => (Message)(new TwitterMessage
{
UserName = x["user"].Value <String>("name"),
PostedOn = ParseTweetDateTime(x.Value <String>("created_at")),
Source = SocialNetworks.Twitter,
Text = ParseTweetTextIntoHtml(x.Value <String>("text")),
UserImageUrl = x["user"].Value <String>("profile_image_url")
})).Take(20).ToList());
}
public BasicUserData ProcessAuthRequest(ProcessAuthenticationContext context)
{
string screenName;
int userId;
var consumer = new TwitterConsumer(context.SessionStorage);
return
(consumer.TryFinishSignInWithTwitter(out screenName, out userId)
? new BasicUserData
{
UserId = userId.ToString(CultureInfo.InvariantCulture),
UserName = screenName,
PictureUrl =
string.Format("http://api.twitter.com/1/users/profile_image/{0}.png", screenName)
}
: null);
}
public ActionResult Index()
{
if (TwitterConsumer.IsTwitterConsumerConfigured)
{
string screenName;
int userId;
string accessToken;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId, out accessToken))
{
var user = Session.Query <User>().Search(x => x.TwitterId, userId.ToString()).SingleOrDefault();
if (user == null)
{
user = new User();
user.Id = Guid.NewGuid();
user.TwitterId = userId.ToString();
user.RegisteredOn = DateTime.UtcNow;
}
user.Name = screenName;
user.OAuthAccessToken = accessToken;
user.LastSignIn = DateTime.UtcNow;
Session.Store(user);
Session.SaveChanges();
FormsAuthentication.SetAuthCookie(screenName, false);
if (HttpContext.Request.UrlReferrer != null && string.IsNullOrWhiteSpace(HttpContext.Request.UrlReferrer.AbsoluteUri) == false)
{
return(Redirect(HttpContext.Request.UrlReferrer.AbsoluteUri));
}
return(RedirectToAction("Index", "Home"));
}
else
{
TwitterConsumer.StartSignInWithTwitter(false).Send();
}
}
return(RedirectToAction("Index", "Home"));
}
protected void uploadProfilePhotoButton_Click(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
if (this.profilePhoto.PostedFile.ContentType == null)
{
this.photoUploadedLabel.Visible = true;
this.photoUploadedLabel.Text = "Select a file first.";
return;
}
var twitter = new TwitterConsumer();
XDocument imageResult =
await
twitter.UpdateProfileImageAsync(
this.AccessToken, this.profilePhoto.PostedFile.InputStream, this.profilePhoto.PostedFile.ContentType);
this.photoUploadedLabel.Visible = true;
}));
}
/// <summary>
/// Gets url of User image
/// </summary>
/// <param name="userScreenName"></param>
/// <exception cref="TwitterDataProvider.Exceptions.ResourceNotFoundException">ResourceNotFoundException</exception>
/// <exception cref="TwitterDataProvider.Exceptions.InternalProviderException">InternalProviderException</exception>
/// <returns>Url of image or null if resource does not exist</returns>
public string GetUrlOfUserImage(string userScreenName, ImageSize imageSize)
{
var userInfo = TwitterConsumer.GetUserInfo(TwitterSignIn, 0, userScreenName, _apiInfo.AccessToken);
if (userInfo == null)
{
return(null);
}
var profileImageUrl = userInfo.Value <String>("profile_image_url");
var size = GetTwitterImageSizeText(imageSize);
if (size == "original")
{
profileImageUrl = profileImageUrl.Replace("_normal", String.Empty);
}
return(profileImageUrl);
}
protected void Page_Load(object sender, EventArgs e)
{
if (TwitterConsumer.IsTwitterConsumerConfigured)
{
this.MultiView1.ActiveViewIndex = 1;
if (!IsPostBack)
{
string screenName;
int userId;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId))
{
this.loggedInPanel.Visible = true;
this.loggedInName.Text = screenName;
// In a real app, the Twitter username would likely be used
// to log the user into the application.
////FormsAuthentication.RedirectFromLoginPage(screenName, false);
}
}
}
}
public ActionResult RsvpTwitterFinish(Guid id)
{
string screenName;
int userId;
if (TwitterConsumer.TryFinishSignInWithTwitter(out screenName, out userId))
{
var dinner = dinnerReadModel.GetDinnerById(id);
// NOTE: The alias we've generated for this user isn't guaranteed to be unique.
string alias = "@" + screenName;
if (!dinner.IsUserRegistered(alias))
{
var rsvpForDinnerCommand = new RsvpForDinnerCommand {
DinnerId = id, AttendeeName = alias
};
commandService.RsvpForDinner(rsvpForDinnerCommand);
}
}
return(RedirectToAction("Details", "Dinners", new { id }));
}
