public async Task <ActionResult> ViewTweets(TweetModel viewModel)
{
TweetModel modelAsync = await _IServiceTweets.GetTweetsAsync(viewModel);
// Sending data to View
return(View(modelAsync));
}
public async Task <TweetModel> GetRandomTweets(string searchQuery)
{
var accessToken = _config["AccessToken"];
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Authorization
= new AuthenticationHeaderValue("Bearer", accessToken);
var url = new Uri($"https://api.twitter.com/1.1/statuses/user_timeline.json?screen_name={searchQuery}&count=50&tweet_mode=extended&exclude_replies=true");
var response = await client.GetAsync(url);
string json;
using (var content = response.Content)
{
json = await content.ReadAsStringAsync();
}
var tweets = JsonConvert.DeserializeObject <List <TweetModel> >(json);
var random = new Random();
var randomNum = random.Next(0, 50);
TweetModel randomTweet = tweets[randomNum];
return(randomTweet);
}
}
public void UpdateStats(TweetStatisticsModel statsModel, TweetModel newTweet)
{
statsModel.CountTweetsReceived += 1;
var hashTags = GetHashtags(newTweet);
var emojis = GetEmojis(newTweet);
var urlsDictionary = GetDomainsDictionary(newTweet);
if (hashTags.Count > 0)
{
statsModel.UpdateHashtagsUsed(hashTags);
}
if (emojis.Count > 0)
{
statsModel.UpdateEmojisUsed(emojis);
statsModel.CountTweetsWithEmojis += 1;
}
if (urlsDictionary.Count > 0)
{
statsModel.CountTweetsWithUrls += 1;
if (newTweet.ContainsOneOrMorePhotoUrl)
{
statsModel.CountTweetsWithPhotoUrls += 1;
}
statsModel.UpdateDomainsUsed(urlsDictionary);
}
// will update end time for every tweet, and end with the time of the final one
statsModel.EndTime = DateTimeOffset.Now;
}
private TweetModel GetTweet(string userName, int tweetId)
{
TweetModel model = new TweetModel();
AppRepository repo = new AppRepository();
model.TweetMessage = new TweetMessage();
var Tweets = repo.GetAllTweets(userName);
var tweetDetails = repo.GetTweetMessageDetails(userName);
if (tweetId == 0)
{
model.TweetMessage.User_Id = userName;
}
else
{
model.TweetMessage = Tweets.Where(x => x.Tweet_Id == tweetId).FirstOrDefault();
}
model.lstTweetMessage = Tweets;
model.TotalTweets = tweetDetails.TotalTweets;
model.TotalFollowing = tweetDetails.TotalFollowing;
model.TotalFollowers = tweetDetails.TotalFollowers;
return(model);
}
public async Task IsGettingRetweetInfoInRepository()
{
AppUser userModel = new AppUser {
Nickname = "marcow"
};
_dbContext.Users.Add(userModel);
Assert.NotNull(userModel.Id);
TweetModel tweetModel = new TweetModel {
UserId = userModel.Id, Text = "Super tweet!"
};
_dbContext.Add <TweetModel>(tweetModel);
_dbContext.SaveChanges();
Retweet retweet = new Retweet {
UserId = userModel.Id, TweetId = tweetModel.Id
};
await _repository.Create(retweet);
retweet = await _repository.GetInfo(retweet);
Assert.AreEqual(userModel.Id, retweet.User.Id);
Assert.AreEqual(tweetModel.Text, retweet.Tweet.Text);
}
public static void ExtractHashtags(this TweetModel model)
{
var modelCopy = new TweetModel(model.TweetId, model.ProcessedText);
var extracted = ReplaceAndExtractTexts(modelCopy, "#", " ", ExtractionDelimiter, " ");
model.Hashtags = extracted;
}
public async Task <ActionResult <TweetModel> > PostTweet(string content)
{
if (string.IsNullOrWhiteSpace(content))
{
return(Problem(detail: "A tweet cannot have no content", statusCode: 400));
}
if (content.Length > 280)
{
return(Problem(detail: "A tweet cannot have more than 280 characters!.", statusCode: 400));
}
if (User == null)
{
return(Problem(detail: "User not found, are you signed in?", statusCode: 422));
}
//create a new tweet with the content supplied by the user
TweetModel tweet = new TweetModel();
tweet.Content = content;
tweet.Username = User.Identity.Name;
tweet.Timestamp = DateTime.Now;
_db.Tweets.Add(tweet); //add the tweet to the database
try
{
await _db.SaveChangesAsync();
}
catch (Exception e)
{
_logger.LogError($"An error occured while trying to save changes to database. Message: {e.Message}");
return(Problem(detail: "An error occured while trying to save changes to database.", statusCode: 500));
}
return(CreatedAtAction("PostTweet", new { id = tweet.Id }, tweet));
}
private static string GetTitleFrom(TweetModel t)
{
string firstHashtag = GetFirstHashTag(t.FullText);
//obligatory hipster hashtag
return($"#{firstHashtag}");
}
public void Save(TweetModel tweetModel)
{
var userId = _tweetContext.Users.Where(x => x.Username == tweetModel.Username).Select(x => x.UserId).FirstOrDefault();
var twittedBy = _tweetContext.Users.Where(x => x.Username == tweetModel.TwittedBy).Select(x => x.UserId).FirstOrDefault();
// TODO: User device should come from UI/Client once user logs in to the APP.
var userDeviceId = _tweetContext.UserDevices.Where(x => x.UserId == twittedBy).Select(x => x.UserDeviceId).FirstOrDefault();
// user tweets from new device
if (userDeviceId == 0)
{
UserDeviceEntity userDeviceEntity = new UserDeviceEntity()
{
UserId = userId,
DeviceName = "Test device", // TODO: Pass device name from UI/Client
DeviceTypeId = (int)UserDeviceType.Desktop, // TODO: Pass device type from UI/Client
};
_tweetContext.UserDevices.Add(userDeviceEntity);
_tweetContext.SaveChanges();
}
var tweetEntity = new TweetEntity()
{
TweetContent = tweetModel.TweetContent,
TwittedBy = twittedBy,
UserId = userId,
UserDeviceId = userDeviceId,
TweetTime = DateTime.Now
};
_tweetContext.Tweets.Add(tweetEntity);
_tweetContext.SaveChanges();
}
public IActionResult PostTweet(TweetModel tweet)
{
if (ModelState.IsValid)
{
bool isUnique = false;
if (Database.Instance.Tweets.Count == 0)
{
tweet.ID = Guid.NewGuid().ToString();
isUnique = true;
}
while (!isUnique)
{
tweet.ID = Guid.NewGuid().ToString();
//Check if the generated ID already exists
foreach (var _tweet in Database.Instance.Tweets)
{
if (_tweet.ID != tweet.ID)
{
isUnique = true;
}
}
}
tweet.Timestamp = DateTime.Now;
}
//Debug
System.Console.WriteLine("ID: " + tweet.ID);
System.Console.WriteLine("Poster: " + tweet.Poster);
System.Console.WriteLine("Content: " + tweet.Content);
System.Console.WriteLine("Date: " + tweet.Timestamp);
Database.Instance.Tweets.Add(tweet);
Database.Instance.SaveToFile();
Response.Cookies.Append("poster", tweet.Poster);
return(View("Index"));
}
/// <summary>
/// Authenticate with keys and start listening to twitter sample stream, add new tweets to DB
/// </summary>
public static void BeginTwitterStream()
{
// Get Authentication
Auth.SetUserCredentials("QLX3za3r0cdo4b11D3uoD9uqZ",
"WE8fLGr2oRkTJjpwJmwoN9xVZmXGPXYAS23NSdA1qP7jFVDE1m",
"1159076078369091584-T2hT14Q4NIZZUbMH2UVWyNPikwdNmS",
"T7gb0JAKj3yErHbSW9CCO8eLLdm0l6Ki4IwiF94DoFYRm");
// Create Stream
var stream = Stream.CreateSampleStream();
// sign into event
stream.TweetReceived += (sender, args) =>
{
if (!(args.Tweet.Coordinates is null))
{
// Add to DB
Console.WriteLine("Tweet received with location");
var tweetToInsertToDB = new TweetModel()
{
_id = args.Tweet.Id,
Text = args.Tweet.FullText,
UserName = args.Tweet.CreatedBy.Name,
Coordinates = new CoordinatesModel(args.Tweet.Coordinates.Latitude,
args.Tweet.Coordinates.Longitude)
};
DBManager.InsertObject(tweetToInsertToDB);
}
};
// Start steam
stream.StartStream();
}
public TweetModel GetTweetMessageDetails(string userName)
{
TweetModel tweetModel = new TweetModel();
try
{
using (_dbContext = new TwitterCloneEntities())
{
var tweets = _dbContext.Tweets.Where(x => x.User_Id.Trim().ToUpper() == userName.ToUpper().Trim());
var following = _dbContext.Followings.Where(x => x.User_Id.Trim().ToUpper() == userName.ToUpper().Trim());
var followers = _dbContext.Followings.Where(x => x.Following_id.Trim().ToUpper() == userName.ToUpper().Trim());
if (tweets != null)
{
tweetModel.TotalTweets = tweets.Count();
}
if (followers != null)
{
tweetModel.TotalFollowers = followers.Count();
}
if (following != null)
{
tweetModel.TotalFollowing = following.Count();
}
}
}
catch (Exception ex)
{
}
return(tweetModel);
}
private static string ReplaceAndExtractTexts(TweetModel model, string prefixString, string stopString, string extractionDelimiter, string replaceToken)
{
var text = model.ProcessedText;
var extracted = string.Empty;
var separators = new string[] { prefixString };
var splittedText = text.Split(separators, StringSplitOptions.RemoveEmptyEntries);
if (splittedText.Count() > 0)
{
foreach (var subText in splittedText)
{
var splittedSubText = subText.Split(new string[] { stopString }, StringSplitOptions.RemoveEmptyEntries);
if (splittedSubText.Count() > 0)
{
var replaceText = prefixString + splittedSubText[0];
if (text.IndexOf(replaceText) >= 0)
{
text = text.Replace(replaceText, replaceToken);
extracted += replaceText + extractionDelimiter;
}
}
}
}
model.ProcessedText = text.Trim();
if (extracted.Length > 0)
{
extracted = extracted.Remove(extracted.Length - extractionDelimiter.Length);
}
return(extracted.Trim());
}
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
Info info = new Info();
string header = txtHeader.Text;
string tweetSender = txtSender.Text.Replace(" ", String.Empty);
string message = txtMessage.Text;
bool headerOk = Message.HeaderOk(header);
if (!headerOk || !header.ToUpper().StartsWith("T"))
{
info.DisplayMessage("Incorrect Header", "SMS Header must begin with 'T', followed by 9 numbers");
}
else if (!tweetSender.StartsWith("@"))
{
info.DisplayMessage("Sender Incorrect", "Sender must be a valid Twitter handle beginning with @");
}
else if (message == "")
{
info.DisplayMessage("No Message", "Please enter a message");
}
else
{
txtMessage.Text = string.Join(" ", TSA.ReplaceWords(txtMessage.Text.Split(' ')));
TweetModel tweet = new TweetModel(header, message, tweetSender);
tweet.ParseTweet();
tweet.OutputJson();
info.DisplayMessage("Success", "Tweet submitted successfuly");
}
}
public static void ExtractFirstLetterCapitalizedWords(this TweetModel model, int minWordLength)
{
var extracted = string.Empty;
var modelCopy = new TweetModel(model.TweetId, model.ProcessedText);
modelCopy.ExtractAndReplacePunctuationMarks(" ");
var textSplit = modelCopy.ProcessedText.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in textSplit)
{
if (word.Length >= minWordLength &&
char.IsUpper(word[0])) //Is capitalized
{
extracted += word + ExtractionDelimiter;
}
}
if (extracted.Length > 0)
{
extracted = extracted.Remove(extracted.Length - ExtractionDelimiter.Length);
}
model.FirstLetterCapitalizedWords = extracted.Trim();
}
public ActionResult ViewTweets()
{
TweetModel viewModel = new TweetModel();
viewModel.TweetsData = Enumerable.Empty <TweetsData>();
return(View(viewModel));
}
public async Task IsRemovingUserTweetReactionInToggle()
{
this.populate();
List <UserTweetReactionModel> models = _dbContext.UserTweetReaction.ToList();
Assert.AreEqual(0, models.Count);
AppUser user = _dbContext.Users.FirstOrDefault(u => u.Nickname == "marcow");
TweetModel tweet = _dbContext.Tweet.FirstOrDefault(t => t.UserId == user.Id);
ReactionModel reaction = _dbContext.Reaction.FirstOrDefault(r => r.Name == "Star");
UserTweetReaction userTweetReaction = new UserTweetReaction
{
UserId = user.Id, TweetId = tweet.Id, ReactionId = reaction.Id
};
await _repository.Toggle(userTweetReaction);
models = _dbContext.UserTweetReaction.ToList();
Assert.AreEqual(1, models.Count);
userTweetReaction.Id = 0;
await _repository.Toggle(userTweetReaction);
models = _dbContext.UserTweetReaction.ToList();
Assert.AreEqual(0, models.Count);
}
public static TweetModel MapTweet(Tweet tweet)
{
TweetModel tweetModel = new TweetModel();
try
{
if (tweet != null)
{
tweetModel = new TweetModel()
{
Id = tweet.Id,
Text = tweet.Text,
FullText = tweet.FullText,
Url = !string.IsNullOrEmpty(tweet.Url) ? tweet.Url : string.Empty,
Urls = UrlMapper.MapUrls(tweet.Urls),
TweetMode = tweet.TweetMode,
Contributors = tweet.Contributors != null ? tweet.Contributors : null,
Retweeted = tweet.Retweeted,
RetweetCount = tweet.RetweetCount,
Hashtags = HashtagMapper.MapHashTags(tweet.Hashtags),
Media = MediaMapper.MapListOfMedia(tweet.Media)
};
}
}
catch
{
}
return(tweetModel);
}
private static string ExtractCharacterNgrams(this TweetModel model, string extractionDelimiter, int n)
{
var extracted = string.Empty;
var ngram = string.Empty;
var counter = 0;
for (int i = 0; i < model.ProcessedText.Length; i++)
{
var characterString = model.ProcessedText[i].ToString();
counter++;
ngram += characterString;
if (counter % n == 0)
{
extracted += ngram + extractionDelimiter;
ngram = string.Empty;
counter = 0;
i -= n - 1;
}
}
if (extracted.Length > 0)
{
extracted = extracted.Remove(extracted.Length - extractionDelimiter.Length);
}
return(extracted);
}
private static string ExtractWordNgrams(this TweetModel model, string extractionDelimiter, int n)
{
var extracted = string.Empty;
var ngram = string.Empty;
var splitted = model.ProcessedText.Split(' ');
var counter = 0;
for (int i = 0; i < splitted.Length; i++)
{
if (string.IsNullOrEmpty(splitted[i]))
{
continue;
}
counter++;
ngram += splitted[i] + " ";
if (counter % n == 0)
{
ngram = ngram.Remove(ngram.Length - 1);
extracted += ngram + extractionDelimiter;
ngram = string.Empty;
counter = 0;
i -= n - 1;
}
}
if (extracted.Length > 0)
{
extracted = extracted.Remove(extracted.Length - extractionDelimiter.Length);
}
return(extracted);
}
public TweetModel GetFavouriteRetweetCount(TweetModel tweet)
{
string tempUrl = string.Format("https://api.twitter.com/1.1/statuses/show/{0}.json", tweet.TweetID);
HttpWebRequest timeLineRequest = (HttpWebRequest)WebRequest.Create(tempUrl);
var timelineHeaderFormat = "{0} {1}";
timeLineRequest.Headers.Add("Authorization", string.Format(timelineHeaderFormat, TwitterSingleton.Instance.tokenType, TwitterSingleton.Instance.accessToken));
timeLineRequest.Method = "Get";
WebResponse timeLineResponse = timeLineRequest.GetResponse();
var timeLineJson = string.Empty;
using (timeLineResponse)
{
using (var reader = new StreamReader(timeLineResponse.GetResponseStream()))
{
timeLineJson = reader.ReadToEnd();
dynamic data = JObject.Parse(timeLineJson);
tweet.RetweetCount = data.retweet_count;
tweet.FavouriteCount = data.favorite_count;
tweet.SetScore();
}
}
return(tweet);
}
public TweetModel GetTweetById(string tweetId)
{
TweetModel tweetModel = new TweetModel();
tweetModel = _tweetRepository.FindByCondition(tweetId);
return(tweetModel);
}
public static void ReplaceCharacters(this TweetModel model, string replaceString, string replaceToken)
{
var result = string.Empty;
result = model.ProcessedText.Replace(replaceString, replaceToken).Trim();
model.ProcessedText = result;
}
/// <summary>
///
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
public async Task <TweetModel> GetTweetsAsync(TweetModel viewModel)
{
TweetModel resultModel = new TweetModel();
try
{
// HttpClient is used for sending HTTP requests and receiving HTTP responses from a resource identified by a URI
using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
{
// Building url by appending input parameters from viewmodel
string queryParams = ApiUrl + $"?startDate={viewModel.StartDate}&endDate={viewModel.EndDate}";
client.BaseAddress = new Uri(ApiUrl);
// Clearing Accept headers for the Http Request
client.DefaultRequestHeaders.Accept.Clear();
// Adding Header to Http Request Accept: 'application/json'
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
System.Net.Http.HttpResponseMessage response = await client.GetAsync(queryParams);
// When http respose StatusCode is 500
if (response.StatusCode == System.Net.HttpStatusCode.InternalServerError)
{
resultModel.StatusMessage = "Something went wrong!";
}
// When http respose StatusCode is 400
if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
{
resultModel.StatusMessage = "Invalid startDate and/or endDate";
}
if (response.IsSuccessStatusCode)
{
// Sets the collection to Empty.
resultModel.TweetsData = Enumerable.Empty <TweetsData>();
var twitterList = await response.Content.ReadAsAsync <IEnumerable <TweetsData> >();
resultModel.TotalCount = twitterList.Count();
// EqualityComparer used to remove duplicate enteries from collection.
resultModel.TweetsData = twitterList.Distinct(new EqualityComparer());
resultModel.CurrentCount = resultModel.TweetsData.Count();
}
}
}
catch (Exception ex)
{
throw ex;
}
return(resultModel);
}
public JsonResult AddTweet(TweetModel tweet)
{
Model.Tweet newTweet = new Model.Tweet();
newTweet.message = tweet.Message;
newTweet.tweet_id = tweet.Tweet_id;
newTweet.user_id = User.Identity.Name;
person.AddOrUpdateTweet(newTweet);
return(Json("Ok"));
}
public ActionResult Index(int EdittweetId = 0, string userName = null)
{
TweetModel model = new TweetModel();
userName = Convert.ToString(Session["UserName"]);
ViewBag.Users = GetUserList();
model = GetTweet(userName, EdittweetId);
return(View(model));
}
public async Task <IActionResult> PutTweet(Guid id, string content)
{
if (User == null)
{
return(Problem(detail: "User not found, are you signed in?", statusCode: 422));
}
if (string.IsNullOrWhiteSpace(content))
{
return(Problem(detail: "A tweet cannot have no content.", statusCode: 400));
}
if (content.Length > 280)
{
return(Problem(detail: "A tweet cannot have more than 280 characters!.", statusCode: 400));
}
//find the tweet referenced by the GUID
var Tweet = _db.Tweets.FirstOrDefault(tweet => tweet.Id == id);
if (Tweet == null)
{
return(Problem(detail: "Tweet not found.", statusCode: 404));
}
string Username = User.Identity.Name;
//make sure the tweet belongs to the user
if (Tweet.Username != Username)
{
return(Problem(detail: "You cannot update someone else's tweet!", statusCode: 400));
}
//create a new tweet object, and fill it in.
TweetModel EditedTweet = new TweetModel();
EditedTweet.Username = Username;
EditedTweet.Content = content;
EditedTweet.Id = id;
EditedTweet.Timestamp = DateTime.Now; //update the timestamp to reflect when it was edited.
var oldTweet = _db.Tweets.Find(id);
_db.Tweets.Remove(oldTweet); //remove the old tweet and add the new one.
_db.Tweets.Add(EditedTweet);
try
{
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TweetExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(CreatedAtAction("PutTweet", EditedTweet));
}
public ActionResult Index()
{
TweetModel tweetModel = new TweetModel();
foreach (Tweet tweet in StaticResourcesConfig.Tweets)
{
if (!tweetModel.UsersTweets.ContainsKey(tweet.TweetingUser))
{
List <Tweet> tweets = new List <Tweet>();
tweets.Add(tweet);
tweetModel.UsersTweets.Add(tweet.TweetingUser, tweets);
}
else
{
tweetModel.UsersTweets[tweet.TweetingUser].Add(tweet);
}
List <User> usersFollowers = tweet.TweetingUser.GetFollowers();
foreach (User follower in usersFollowers)
{
if (!tweetModel.UsersTweets.ContainsKey(follower))
{
List <Tweet> tweets = new List <Tweet>();
tweets.Add(tweet);
tweetModel.UsersTweets.Add(follower, tweets);
}
else
{
tweetModel.UsersTweets[follower].Add(tweet);
}
}
}
foreach (User user in StaticResourcesConfig.Users)
{
if (!tweetModel.UsersTweets.ContainsKey(user))
{
tweetModel.UsersTweets.Add(user, null);
}
}
Dictionary <User, List <Tweet> > outputModel = new Dictionary <User, List <Tweet> >();
var orderedModel = tweetModel.UsersTweets.OrderBy(o => o.Key.Name);
foreach (var userTweet in orderedModel)
{
outputModel.Add(userTweet.Key, userTweet.Value);
}
tweetModel.UsersTweets = outputModel;
return(View(tweetModel));
}
public static void EditTweet(TweetModel model)
{
using (var ctx = new EFMVCContext())
{
var tweet = ctx.Tweets.FirstOrDefault(a => a.tweet_id == model.TweetId);
tweet.message = model.Message;
ctx.Tweets.Remove(model.GetTweet());
ctx.SaveChanges();
}
}
public static Tweet GetTweet(this TweetModel model)
{
return(new Tweet
{
user_id = model.UserId,
created = model.Created,
message = model.Message,
tweet_id = model.TweetId
});
}
public ActionResult GetUserTimelinePartialView()
{
TweetInputModel tweetInputModel = new TweetInputModel();
TweetModel tweetModel = new TweetModel();
IEnumerable<TweetModel> foundTweets = tweetModel.GetUserTimeline(tweetInputModel);
// Transfer data from TweetModel to TweetViewModel
IList<TweetViewModel> groupOfTweets = new List<TweetViewModel>();
foreach (TweetModel tweet in foundTweets)
{
TweetViewModel tweetViewModel = new TweetViewModel();
tweetViewModel.Message = tweet.Message;
groupOfTweets.Add(tweetViewModel);
}
return PartialView("UserTimelinePartialView", groupOfTweets);
}
private void TwitterSearchCompleted(object sender, DownloadStringCompletedEventArgs e)
{
if(e.Error != null)
return;
JObject json = JObject.Parse(e.Result);
JArray results = (JArray)json["results"];
TweetModel tweetModel = null;
ObservableCollection<TweetModel> tweets = new ObservableCollection<TweetModel>();
foreach(JObject result in results) {
tweetModel = new TweetModel();
tweetModel.Content = HttpUtility.HtmlDecode((string)result["text"]);
tweetModel.Profile = (string)result["from_user"];
tweetModel.ProfileImage = (string)result["profile_image_url"];
tweetModel.TimeStamp = (string)result["created_at"];
tweets.Add(tweetModel);
}
this.Tweets = tweets;
}
