public ActionResult PostToTwitter(string url, string text)
{
if (string.IsNullOrEmpty(url) || string.IsNullOrEmpty(text))
return Json(new { Success = false, Message = "You must enter some text to tweet" });
IOAuthCredentials credentials = new SessionStateCredentials();
credentials.ConsumerKey = _config.TwitterConsumerKey;
credentials.ConsumerSecret = _config.TwitterConsumerSecret;
credentials.AccessToken = _config.TwitterAccessTokenSecret;
credentials.OAuthToken = _config.TwitterAccessToken;
MvcAuthorizer auth = new MvcAuthorizer { Credentials = credentials };
TwitterContext twitter = new TwitterContext(auth);
try
{
twitter.UpdateStatus(text + " " + url);
return Json(new { Success = true });
}
catch (Exception e)
{
return Json(new { Success = false, Message = e.Message });
}
}
//
// GET: /Account/LogOn
public ActionResult LogOn()
{
//return View();
if (!Request.IsAuthenticated)
{
var credentials = new InMemoryCredentials();
credentials.ConsumerKey = ConfigurationManager.AppSettings["TwitterCustomerKey"];
credentials.ConsumerSecret = ConfigurationManager.AppSettings["TwitterCustomerSecret"];
var auth = new MvcAuthorizer { Credentials = credentials };
auth.CompleteAuthorization(Request.Url);
if (!auth.IsAuthorized)
return auth.BeginAuthorization(Request.Url);
else
{
FormsAuthentication.SetAuthCookie(auth.ScreenName, true);
PostworthyUser pm = UsersCollection.Single(auth.ScreenName, addIfNotFound: true);
if (string.IsNullOrEmpty(pm.AccessToken) && string.IsNullOrEmpty(pm.OAuthToken))
{
pm.AccessToken = auth.Credentials.AccessToken;
pm.OAuthToken = auth.Credentials.OAuthToken;
UsersCollection.Save();
}
return RedirectToAction("Index", new { controller = "Home", action = "Index", id = UrlParameter.Optional });
}
}
else
return RedirectToAction("Index", new { controller = "Home", action = "Index", id = UrlParameter.Optional });
}
protected string GetImageInfo(string twitterName, string defaultURL)
{
if (twitterName == null)
return defaultURL;
string twitterURL = defaultURL;
var auth = new MvcAuthorizer();
SessionStateCredentials s = new SessionStateCredentials();
s.ConsumerKey = "fUpi8KuU3hMWsCHueZIww";
s.ConsumerSecret = "4gCFXwi5zW5CYIoGSNgydL9dmqVM9T9BUS9ElrMI";
auth.Credentials = s;
var twitterCtx = new TwitterContext(auth);
try
{
var userResponse =
(from user in twitterCtx.User
where user.Type == UserType.Lookup &&
user.ScreenName == twitterName.Replace("@", "")
select user).ToList();
if (userResponse == null)
{
return defaultURL;
}
twitterURL = userResponse.FirstOrDefault().ProfileImageUrl;
}
catch
{
return defaultURL;
}
return twitterURL;
}
public async Task<ActionResult> CompleteAsync()
{
if (Request.QueryString["serviceInterval"] != null)
{
ServiceInterval = Convert.ToInt32(Request.QueryString["serviceInterval"]);
}
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["ConsumerKey"].ToString(),
ConsumerSecret = ConfigurationManager.AppSettings["ConsumerSecret"].ToString()
}
};
await auth.CompleteAuthorizeAsync(Request.Url);
//
Profile model = new Data.Models.Profile();
var credentials = auth.CredentialStore;
model.AccessToken = credentials.OAuthToken;
model.TokenSecret = credentials.OAuthTokenSecret;
model.Username = credentials.ScreenName;
model.UserId = credentials.UserID.ToString();
model.ProfileTypeID = 3;
model.Interval = ServiceInterval;
SaveTwitterInfo(model);
return RedirectToAction("Index", "Profile");
}
protected string GetImageInfo(string twitterName, string defaultURL)
{
if (twitterName == null)
return defaultURL;
var twitterUrl = defaultURL;
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = "fUpi8KuU3hMWsCHueZIww",
ConsumerSecret = "4gCFXwi5zW5CYIoGSNgydL9dmqVM9T9BUS9ElrMI"
}
};
var twitterCtx = new TwitterContext(auth) {ReadWriteTimeout = 300};
try
{
var userResponse =
(from user in twitterCtx.User
where user.Type == UserType.Show &&
user.ScreenName == twitterName.Replace("@", "")
select user).ToArray();
var firstOrDefault = userResponse.FirstOrDefault();
if (firstOrDefault != null) twitterUrl = firstOrDefault.ProfileImageUrl;
}
catch(Exception)
{
return defaultURL;
}
return twitterUrl;
}
public async Task<ActionResult> CompleteAsync()
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
await auth.CompleteAuthorizeAsync(Request.Url);
// This is how you access credentials after authorization.
// The oauthToken and oauthTokenSecret do not expire.
// You can use the userID to associate the credentials with the user.
// You can save credentials any way you want - database,
// isolated storage, etc. - it's up to you.
// You can retrieve and load all 4 credentials on subsequent
// queries to avoid the need to re-authorize.
// When you've loaded all 4 credentials, LINQ to Twitter will let
// you make queries without re-authorizing.
//
//var credentials = auth.CredentialStore;
//string oauthToken = credentials.OAuthToken;
//string oauthTokenSecret = credentials.OAuthTokenSecret;
//string screenName = credentials.ScreenName;
//ulong userID = credentials.UserID;
//
return RedirectToAction("Index", "Home");
}
public void BeginAuthorization_Sets_Callback()
{
var auth = new MvcAuthorizer();
Uri linqToTwitterUri = new Uri("http://linqtotwitter.codeplex.com");
auth.BeginAuthorization(linqToTwitterUri);
Assert.Equal(linqToTwitterUri, auth.Callback);
}
public static async void SendTweet(MvcAuthorizer auth, string message)
{
var ctx = new TwitterContext(auth);
var context = new TwitterContext(auth);
await context.TweetAsync(
message
);
}
public static async void ReTweet(MvcAuthorizer auth, int ID)
{
var ctx = new TwitterContext(auth);
var context = new TwitterContext(auth);
await context.TweetAsync(
ID.ToString()
);
}
public async Task<ActionResult> BeginAsync()
{
//var auth = new MvcSignInAuthorizer
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["consumerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["consumerSecret"]
}
};
string twitterCallbackUrl = Request.Url.ToString().Replace("Begin", "Complete");
return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
public async Task<ActionResult> BeginAsync(int? serviceInterval)
{
// ServiceInterval = serviceInterval??10;
//var auth = new MvcSignInAuthorizer
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["ConsumerKey"].ToString(),// "0vbuhbtd8Zz7M121MtxtrA",
ConsumerSecret = ConfigurationManager.AppSettings["ConsumerSecret"].ToString()// "5aj5te5ygcpPCBOMrwvGcjI8GAoAfAZFMlpLhyt2U"
}
};
string twitterCallbackUrl = Request.Url.ToString().Replace("Begin", "Complete");
return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
public async Task<ActionResult> CompleteAsync(string returnUrl)
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
await auth.CompleteAuthorizeAsync(Request.Url);
//save credentials in cookie
var credentials = auth.CredentialStore;
Cookies.Write(Response, "TwitterOAuthToken", credentials.OAuthToken);
Cookies.Write(Response, "TwitterOAuthTokenSecret", credentials.OAuthTokenSecret);
Cookies.Write(Response, "TwitterScreenName", credentials.ScreenName);
Cookies.Write(Response, "TwitterUserID", credentials.UserID.ToString());
return Redirect(returnUrl);
}
public ActionResult Index()
{
if (credentials.ConsumerKey == null || credentials.ConsumerSecret == null)
{
credentials.ConsumerKey = ConfigurationManager.AppSettings["twitterConsumerKey"];
credentials.ConsumerSecret = ConfigurationManager.AppSettings["twitterConsumerSecret"];
}
auth = new MvcAuthorizer
{
Credentials = credentials
};
// internally, this doesn't execute if BeginAuthorization hasn't been called yet
// but it will execute after the user authorizes your application
auth.CompleteAuthorization(Request.Url);
// this will only execute if we don't have all 4 keys, which is what IsAuthorized checks
if (!auth.IsAuthorized)
{
Uri specialUri = new Uri(Request.Url.ToString());
// url param is optional, it lets you specify the page Twitter redirects to.
// You can use it to complete the OAuth process on another action/controller - in which
// case you would move auth.CompleteAuthorization to that action/controller.
return auth.BeginAuthorization(specialUri);
}
twitterCtx = new TwitterContext(auth);
List<TweetViewModel> friendTweets =
(from tweet in twitterCtx.Status
where tweet.Type == StatusType.User &&
tweet.ScreenName == "JoeMayo"
select new TweetViewModel
{
ImageUrl = tweet.User.ProfileImageUrl,
ScreenName = tweet.User.Identifier.ScreenName,
Tweet = tweet.Text
})
.ToList();
return View(friendTweets);
}
public async Task<ActionResult> TweetAsync(SendTweetViewModel tweet)
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
var ctx = new TwitterContext(auth);
Status responseTweet = await ctx.TweetAsync(tweet.Text);
var responseTweetVM = new SendTweetViewModel
{
Text = "Testing async LINQ to Twitter in MVC - " + DateTime.Now.ToString(),
Response = "Tweet successful! Response from Twitter: " + responseTweet.Text
};
return View(responseTweetVM);
}
public async Task<ActionResult> BeginAsync()
{
//var auth = new MvcSignInAuthorizer
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"]
}
};
UrlHelper uHelp = new UrlHelper(Request.RequestContext);
Uri url = Request.Url;
string newUrl = new UriBuilder(url.Scheme, url.Host, url.Port, uHelp.Action("CompleteAsync", "Oauth")).ToString();
Uri callbackUri = new Uri(newUrl);
return await auth.BeginAuthorizationAsync(callbackUri);
}
//
// GET: /Account/LogOn
public async Task<ActionResult> LogOn(bool complete = false)
{
//return View();
if (!Request.IsAuthenticated)
{
if (complete)
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
await auth.CompleteAuthorizeAsync(Request.Url);
FormsAuthentication.SetAuthCookie(auth.CredentialStore.ScreenName, true);
PostworthyUser pm = UsersCollection.Single(auth.CredentialStore.ScreenName, force: true, addIfNotFound: true);
if (string.IsNullOrEmpty(pm.AccessToken) && string.IsNullOrEmpty(pm.OAuthToken))
{
pm.AccessToken = auth.CredentialStore.OAuthTokenSecret;
pm.OAuthToken = auth.CredentialStore.OAuthToken;
UsersCollection.Save();
}
return RedirectToAction("Index", new { controller = "Dashboard", action = "Index", id = UrlParameter.Optional });
}
else
{
//var auth = new MvcSignInAuthorizer
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["TwitterCustomerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["TwitterCustomerSecret"]
}
};
string twitterCallbackUrl = Request.Url.ToString() + "?complete=true";
return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
}
else
return RedirectToAction("Index", new { controller = "Dashboard", action = "Index", id = UrlParameter.Optional });
}
public async Task<ActionResult> SearchTweets(string query = "")
{
MvcAuthorizer auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
// do OAuth if the token is null
if (auth.CredentialStore.OAuthToken == null)
{
return RedirectToAction("BeginAsync", "OAuth", new { returnUrl = Request.Url });
}
List<Status> statuses;
if (!string.IsNullOrEmpty(query))
{
var twitterCtx = new TwitterContext(auth);
var searchResponse =
await
(from search in twitterCtx.Search
where search.Type == SearchType.Search &&
search.Query == "\"" +query + "\""
select search)
.SingleOrDefaultAsync();
statuses = searchResponse.Statuses.ToList();
}
else
{
statuses = new List<Status>();
}
var viewModel = new SearchTweetsViewModel()
{
Query = query,
Statuses = statuses
};
return View(viewModel);
}
public ActionResult Index()
{
IOAuthCredentials credentials = new SessionStateCredentials();
MvcAuthorizer auth;
TwitterContext twitterCtx;
if (credentials.ConsumerKey == null || credentials.ConsumerSecret == null)
{
credentials.ConsumerKey = ConfigurationManager.AppSettings[CommonConstants.ConsumerKey];
credentials.ConsumerSecret = ConfigurationManager.AppSettings[CommonConstants.ConsumerSecret];
credentials.AccessToken = ConfigurationManager.AppSettings[CommonConstants.AccessToken];
credentials.OAuthToken = ConfigurationManager.AppSettings[CommonConstants.OAuthToken];
credentials.ScreenName = ConfigurationManager.AppSettings[CommonConstants.ScreenName];
}
auth = new MvcAuthorizer
{
Credentials = credentials
};
auth.CompleteAuthorization(Request.Url);
if (!auth.IsAuthorized)
{
Uri specialUri = new Uri(Request.Url.ToString());
return auth.BeginAuthorization(specialUri);
}
twitterCtx = new TwitterContext(auth);
var friendTweets =
(from tweet in twitterCtx.Status
where tweet.Type == StatusType.Home
select new TwitterEntity
{
ScreenName = tweet.User.Name,
Tweet = tweet.Text
})
.ToList();
return View(friendTweets);
}
public async Task<ActionResult> BeginAsync()
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["consumerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["consumerSecret"],
OAuthToken = ConfigurationManager.AppSettings["oauthToken"],
OAuthTokenSecret = ConfigurationManager.AppSettings["oauthTokenSecret"]
}
};
await Task.Delay(0).ConfigureAwait(false);
return RedirectToAction("Index", "Home");
// These strings were used with deprecated method below (CompleteAsync)
//string twitterCallbackUrl = "http://twittercollage.apphb.com/OAuth/Complete";
//string twitterCallbackUrl = Url.Action("Complete", "OAuth", null, Request.Url.Scheme);
//return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
public async Task<ActionResult> BeginAsync(string returnUrl = "/")
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore
{
ConsumerKey = ConfigurationManager.AppSettings["consumerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["consumerSecret"]
}
};
//check if we already have auth in a cookie
if (Cookies.Read(Request, Server, "TwitterOAuthToken") != null)
{
//load credentials from cookie. if oauthToken is not null, assume all of them are not null
try
{
auth.CredentialStore.OAuthToken = Cookies.Read(Request, Server, "TwitterOAuthToken");
auth.CredentialStore.OAuthTokenSecret = Cookies.Read(Request, Server, "TwitterOAuthTokenSecret");
auth.CredentialStore.ScreenName = Cookies.Read(Request, Server, "TwitterScreenName");
auth.CredentialStore.UserID = Convert.ToUInt64(Cookies.Read(Request, Server, "TwitterUserID"));
}
catch
{
//if an exception occurs, do OAuth consent
string twitterCallbackUrl = Request.Url.ToString().Replace("Begin", "Complete") + "?returnUrl=" + returnUrl;
return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
//return to calling url
return Redirect(returnUrl);
}
else
{
string twitterCallbackUrl = Request.Url.ToString().Replace("Begin", "Complete") +"?returnUrl=" +returnUrl;
return await auth.BeginAuthorizationAsync(new Uri(twitterCallbackUrl));
}
}
private ActionResult Authorize()
{
if (credentials.ConsumerKey == null || credentials.ConsumerSecret == null)
{
credentials.ConsumerKey = ConfigurationManager.AppSettings["twitterConsumerKey"];
credentials.ConsumerSecret = ConfigurationManager.AppSettings["twitterConsumerSecret"];
}
auth = new MvcAuthorizer
{
Credentials = credentials
};
auth.CompleteAuthorization(Request.Url);
if (!auth.IsAuthorized)
{
Uri specialUri = new Uri(Request.Url.ToString());
return auth.BeginAuthorization(specialUri);
}
ViewBag.User = auth.Credentials.ScreenName;
return null;
}
public async Task<ActionResult> HomeTimelineAsync()
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
var ctx = new TwitterContext(auth);
var tweets =
await
(from tweet in ctx.Status
where tweet.Type == StatusType.Home
select new TweetViewModel
{
ImageUrl = tweet.User.ProfileImageUrl,
ScreenName = tweet.User.ScreenNameResponse,
Text = tweet.Text
})
.ToListAsync();
return View(tweets);
}
public ActionResult Index()
{
if (credentials.ConsumerKey == null || credentials.ConsumerSecret == null)
{
credentials.ConsumerKey = ConfigurationManager.AppSettings["twitterConsumerKey"];
credentials.ConsumerSecret = ConfigurationManager.AppSettings["twitterConsumerSecret"];
}
auth = new MvcAuthorizer
{
Credentials = credentials
};
auth.CompleteAuthorization(Request.Url);
if (!auth.IsAuthorized)
{
Uri specialUri = new Uri(Request.Url.ToString());
return auth.BeginAuthorization(specialUri);
}
twitterCtx = new TwitterContext(auth);
var friendTweets =
(from tweet in twitterCtx.Status
where tweet.Type == StatusType.User &&
tweet.ScreenName == "AndreMayo1"
select new TweetViewModel
{
ImageUrl = tweet.User.ProfileImageUrl,
ScreenName = tweet.User.Identifier.ScreenName,
Tweet = tweet.Text
})
.ToList();
return View(friendTweets);
}
public async Task<ActionResult> PostTweet(string tweetText = "")
{
MvcAuthorizer auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
// do OAuth if the token is null
if (auth.CredentialStore.OAuthToken == null)
{
return RedirectToAction("BeginAsync", "OAuth", new { returnUrl = Request.Url });
}
Status postedTweet;
ulong postedTweetStatusId = 0;
if (!string.IsNullOrEmpty(tweetText))
{
var twitterCtx = new TwitterContext(auth);
postedTweet = await twitterCtx.TweetAsync(tweetText);
postedTweetStatusId = postedTweet.StatusID;
}
else
{
postedTweet = null;
}
var viewModel = new PostTweetViewModel()
{
TweetText = tweetText,
PostedTweet = postedTweet,
PostedTweetStatusId = postedTweetStatusId
};
return View(viewModel);
}
/// <summary>
///
/// </summary>
/// <param name="actionState"></param>
/// <returns></returns>
public List<TwitterEntity> GetTwitter(ActionState actionState)
{
List<TwitterEntity> list = new List<TwitterEntity>();
try
{
var mvcAuthorizer = new MvcAuthorizer
{
Credentials = new InMemoryCredentials
{
ConsumerKey = ConfigurationManager.AppSettings[CommonConstants.ConsumerKey],
ConsumerSecret = ConfigurationManager.AppSettings[CommonConstants.ConsumerSecret],
AccessToken = ConfigurationManager.AppSettings[CommonConstants.AccessToken],
OAuthToken = ConfigurationManager.AppSettings[CommonConstants.OAuthToken],
ScreenName = ConfigurationManager.AppSettings[CommonConstants.ScreenName]
}
};
var twitterCtx = new TwitterContext(mvcAuthorizer);
var friendTweets =
(from tweet in twitterCtx.Status
where tweet.Type == StatusType.Home && tweet.Count == Convert.ToInt32(ConfigurationManager.AppSettings[CommonConstants.TwittegGetFieldCount])
select new TwitterEntity
{
Name = tweet.User.Name,
Tweet = tweet.Text,
UserID = tweet.User.Identifier.ID,
ScreenName = tweet.User.Identifier.ScreenName,
CreatedDate = tweet.CreatedAt
});
list = friendTweets.ToList<TwitterEntity>();
actionState.SetSuccess();
}
catch (Exception ex)
{
actionState.SetFail(Enums.ActionStateEnum.Exception, ex.Message);
}
return list;
}
public async Task<ActionResult> TweetAsync(LoadUserViewModel user)
{
if (!ModelState.IsValid)
{
return View(user);
}
//load OAuth credentials
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
var ctx = new TwitterContext(auth);
Friendship friendship;
long cursor = -1;
List<string> urls = new List<string>();
List<int> counts = new List<int>();
// load profile picture urls and tweets count using linq2twitter
try
{
if (user.size < 24 || user.size > 2000)
throw new Exception("Size out of bounds. Min size: 24, Max size: 2000");
do
{
friendship =
await
(from friend in ctx.Friendship
where friend.Type == FriendshipType.FriendsList &&
friend.ScreenName == user.Text.Trim() &&
friend.Cursor == cursor
select friend).SingleOrDefaultAsync();
if (friendship != null &&
friendship.Users != null &&
friendship.CursorMovement != null)
{
cursor = friendship.CursorMovement.Next;
friendship.Users.ForEach(friend =>
{
urls.Add(friend.ProfileImageUrl.Replace("normal","bigger"));
counts.Add(friend.StatusesCount);
}
);
}
} while (cursor != 0);
// generate image collage from urls
ViewBag.ImageData = ImageProcessing(urls, user.size, counts, user.Resize);
// genrate status response
var responseTweetVM = new LoadUserViewModel
{
Text = user.Text,
size = user.size,
Response = "Collage loaded"
};
return View(responseTweetVM);
}
catch (Exception ex)
{
ViewBag.errors = ex.Message.Replace("page", "user");
}
return View();
}
public ActionResult LogOut()
{
var auth = new MvcAuthorizer
{
CredentialStore = null
};
Cookies.Write(Response, "TwitterOAuthToken", string.Empty);
Cookies.Write(Response, "TwitterOAuthTokenSecret", string.Empty);
Cookies.Write(Response, "TwitterScreenName", string.Empty);
Cookies.Write(Response, "TwitterUserID", string.Empty);
return RedirectToAction("AuthStatus");
}
public async Task<ActionResult> GetTimeLine()
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore()
};
var ctx = new TwitterContext(auth);
var tweets =
await
(from tweet in ctx.Status
where tweet.Type == StatusType.User &&
tweet.ScreenName == "riadosaband"
select new TweetViewModel
{
ImageUrl = tweet.User.ProfileImageUrl,
ScreenName = tweet.User.ScreenNameResponse,
Text = tweet.Text,
Id = tweet.ID.ToString()
})
.ToListAsync();
return Json(tweets, JsonRequestBehavior.AllowGet);
}
public ActionResult TweetRetweet()
{
IncidentAddRequest model = new IncidentAddRequest();
model.categoryId = Convert.ToInt16(Request.QueryString["CategoryId"]);
model.UserId = Convert.ToInt16(Request.QueryString["UserId"]);
model.Lat = Convert.ToDouble(Request.QueryString["Lat"]);
model.Lng = Convert.ToDouble(Request.QueryString["Lng"]);
//HttpResponseMessage resp = null;
try
{
//ComplaintStatusType status = ComplaintStatusType.NotSet;
//Check location and category of tweet to see if complaint already exists
WehackDataService service = new WehackDataService();
IncidentResponse incident = service.CreateComplaint(model);
if (incident == null || incident.TweetId == null)
{
//get auth context
//create tweet
//assign tweetId back to database
//template: @riadosaband Issue #93 Pothole! 33.940109, -118.133159 #lahasissues
var categoryString = model.categoryId == 1 ? "Pothole" : "Streetlight";
var tweet = "@riadosaband " + "#" + categoryString + incident.IncidentId.ToString() + " " + model.Lat + ", " + model.Lng + " #lahasissues";
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore(System.Web.HttpContext.Current.Session)
};
try
{
Task.Run(() => wehack.Services.TwitterService.SendTweet(auth, tweet));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
else
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore(System.Web.HttpContext.Current.Session)
};
try
{
Task.Run(() => wehack.Services.TwitterService.ReTweet(auth, Convert.ToInt16(incident.TweetId)));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
catch (Exception ex)
{
throw ex;//resp = Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
}
return RedirectToAction("IssueFeed", "Home"); //RedirectToRoute("IssueFeed", "Home");
}
public ActionResult Send(string message)
{
var auth = new MvcAuthorizer
{
CredentialStore = new SessionStateCredentialStore(System.Web.HttpContext.Current.Session)
};
try
{
Task.Run(() => wehack.Services.TwitterService.SendTweet(auth, message));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return RedirectToRoute("Home", "IssueFeed");
}
