public bool PublishTweet(ITweet tweet, IPublishTweetOptionalParameters optionalParameters = null)
{
if (tweet == null)
{
throw new ArgumentException("Tweet cannot be null!");
}
var parameters = new PublishTweetParameters(tweet.Text, optionalParameters);
var tweetDTO = InternalPublishTweet(parameters);
UpdateTweetIfTweetSuccessfullyBeenPublished(tweet, tweetDTO);
return tweet.IsTweetPublished;
}
public void GettingIsMention_WhenTheUserIsNotMentioned_ReturnsFalse()
{
_tweet = A.Tweet.Build();
TweetRating test = BuildDefaultTestSubject();
test.IsMention.Should().Be.False();
}
public void GettingIsMention_WhenTheUserIsMentioned_ReturnsTrue()
{
_tweet = A.Tweet.Mentioning(_user.ScreenName).Build();
TweetRating test = BuildDefaultTestSubject();
test.IsMention.Should().Be.True();
}
public static AnalyzeTweet Map(ITweet tweet, string track)
{
return new AnalyzeTweet
{
Tweet = MapTweet(tweet, track)
};
}
public MarkTweetAsReadCommand(ITweet tweet, ITweetSink tweetSink)
{
_tweet = tweet;
_tweetSink = tweetSink;
_observer = new PropertyObserver<ITweet>(_tweet).
RegisterHandler(x => x.IsRead,
x => CanExecuteChanged(this, EventArgs.Empty));
}
public static TweetReceived Map(ITweet tweet, string track, string endpointName, Guid sessionId)
{
return new TweetReceived
{
EndpointName = endpointName,
SessionId = sessionId,
Tweet = Map(tweet, track)
};
}
// Favorite Tweet
public bool FavoriteTweet(ITweet tweet)
{
if (tweet == null)
{
throw new ArgumentException("Tweet cannot be null!");
}
return FavoriteTweet(tweet.TweetDTO);
}
public SerializableTweet(ITweet tweet)
{
this.Creator = tweet.Creator.Name;
this.CreatedAt = tweet.CreatedAt;
this.IsRetweet = tweet.IsRetweet;
this.Language = tweet.Language.ToString();
this.Retweeted = tweet.Retweeted;
this.Text = tweet.Text;
}
public void Add(ITweet tweet)
{
lock (_mutex)
using (IDocumentSession session = _documentStore.OpenSession())
{
session.Store(tweet);
session.SaveChanges();
}
}
// Publish Tweet
public string PublishTweet(ITweet tweet)
{
if (tweet == null)
{
throw new ArgumentException("Tweet cannot be null");
}
return PublishTweet(tweet.TweetDTO);
}
public IEnumerable<ITweet> SearchRepliesTo(ITweet tweet, bool recursiveReplies)
{
if (tweet == null)
{
throw new ArgumentException("Tweet cannot be null");
}
var repliesDTO = _searchQueryExecutor.SearchRepliesTo(tweet.TweetDTO, recursiveReplies);
return _tweetFactory.GenerateTweetsFromDTO(repliesDTO);
}
static string FormatTweet(ITweet tweet)
{
var builder = new StringBuilder();
builder.AppendLine(string.Format("{0} (@{1}) - {2}",
tweet.CreatedBy.Name,
tweet.CreatedBy.ScreenName,
tweet.CreatedAt.ToLocalTime().ToString("MM/dd/yy h:mm:ss tt")));
builder.AppendLine(tweet.Text);
return builder.ToString();
}
public TweetRating(IAuthorizer client, ITweet tweet)
{
_client = client;
_tweet = tweet;
_observer = new PropertyObserver<IAuthorizer>(_client).
RegisterHandler(x => x.AuthenticatedUser,
x => UpdateIsMention());
UpdateIsMention();
}
// Publish Tweet InReplyTo
public bool PublishTweetInReplyTo(ITweet tweetToPublish, ITweet tweetToReplyTo)
{
if (tweetToPublish == null || tweetToReplyTo == null)
{
throw new ArgumentException("Tweet cannot be null!");
}
var publishedTweetDTO = PublishTweetDTOInReplyTo(tweetToPublish.TweetDTO, tweetToReplyTo.TweetDTO);
UpdateTweetIfTweetSuccessfullyBeenPublished(tweetToPublish, publishedTweetDTO);
return tweetToPublish.IsTweetPublished;
}
private void InsereRC(ref Nodo N, ITweet value)
{
if (N == null)
{
Nodo novoNodo = new Nodo(value);
N = novoNodo;
}
else if (value.CreatedAt < N.valor.CreatedAt) // menor vai pra esquerda
InsereRC(ref N.esquerda, value);
else //if (value >= N.valor) // maior ou igual vai pra direita
InsereRC(ref N.direita, value);
return;
}
public void FollowUserIfRequired(ITweet tweet)
{
if (FollowWords.Any(word => tweet.Text.IndexOf(word, StringComparison.OrdinalIgnoreCase) > -1))
{
try
{
User.GetLoggedUser().FollowUser(tweet.CreatedBy.Id);
}
catch (Exception)
{
// Ignore exceptions.
}
}
}
private static FSTweet InviTweetToPTTweet(ITweet t)
{
FSTweet ptTweet = new FSTweet();
if (t.Coordinates != null)
{
ptTweet.Coordinates = t.Coordinates.Longitude.ToString() + ","
+ t.Coordinates.Latitude.ToString();
}
ptTweet.CreatedOn = t.CreatedAt;
ptTweet.Id = t.Id.ToString();
ptTweet.ReplyToId = t.InReplyToUserIdStr;
ptTweet.Text = t.Text;
return ptTweet;
}
// find IDs of the search queries that correspond to the streamed tweet
private List<string> GetTweetMatchingSearchIDs(ITweet tweet, string streamQueryID, List<ArrayList<ArrayList<QueryToken>>> searchTokens, List<string> searchQueryIDs)
{
List<int> matchingIdx = CompareStreamToSearchIDs(streamQueryID, searchQueryIDs);
List<ArrayList<ArrayList<QueryToken>>> matchingSearchTokens = searchTokens.Where((x, idx) => matchingIdx.Contains(idx)).ToList();
List<int> matchingIDsIndeces = new List<int>();
foreach (var queryTokens in matchingSearchTokens.Select((value, idx) => new {idx, value}))
if (IsMatch(tweet, queryTokens.value))
matchingIDsIndeces.Add(queryTokens.idx);
matchingIdx = matchingIdx.Where((x, idx) => matchingIDsIndeces.Contains(idx)).ToList();
List<string> matchingIDs = searchQueryIDs.Where((x, idx) => matchingIdx.Contains(idx)).ToList();
return matchingIDs;
}
public void Add(ITweet tweet)
{
if (tweet.Media != null)
{
foreach (var media in tweet.Media)
{
this.SaveTweetPic(tweet, media.MediaURL, CreateFileName(tweet));
}
}
else
{
// saves the tweet without a picture
this.SaveTweet(tweet);
}
}
void HandleTweet(ITweet tweet)
{
if ((from tag in tweet.Hashtags where tag.Text == HashtagTrigger select tag).Any())
{
Log.Info("Index rebuild triggered from Twitter by '{0}'".FormatWith(tweet.Creator.Name), this);
CrawlingLog.Log.Info("Index rebuild triggered from Twitter by '{0}'".FormatWith(tweet.Creator.Name));
if (IndexCustodian.IsIndexingPaused(m_index) || IndexCustodian.IsRebuilding(m_index))
{
CrawlingLog.Log.Warn("Indexing call muted");
Log.Info("Indexing call muted", this);
return;
}
IndexCustodian.FullRebuild(m_index);
}
}
public TweetItem(ITweet tweet)
{
Text = tweet.Text;
CreationDate = tweet.CreatedAt;
User = tweet.Creator.ScreenName;
if (tweet.Creator != null)
{
Language = tweet.Creator.Lang;
if (tweet.Creator.FollowersCount.HasValue)
{
Followers = tweet.Creator.FollowersCount.Value;
}
if (tweet.Creator.FriendsCount.HasValue)
{
Friends = tweet.Creator.FriendsCount.Value;
}
}
}
public TweetSentimentData(ITweet tweet)
{
this.Id = tweet.IdStr;
this.Text = tweet.Text;
if (tweet.InReplyToStatusIdStr != null)
{
this.ReplyToId = tweet.InReplyToStatusIdStr;
}
else
{
this.ReplyToId = "";
}
this.CreatedOn = tweet.CreatedAt;
if (tweet.Coordinates != null)
{
this.Coordinates = tweet.Coordinates.Longitude.ToString() + ","
+ tweet.Coordinates.Latitude.ToString();
}
this.Sentiment = SentimentEngine.CalculateSentiment(this.Text);
}
// check if tweet satisfies the query from the maching ID
private bool IsMatch(ITweet tweet, ArrayList<ArrayList<QueryToken>> searchTokens)
{
bool match = false;
foreach (var orTokens in searchTokens)
{
bool andMatch = true;
foreach (var andToken in orTokens)
{
string tokenText = andToken.ToString();
if (andToken.Parts.Count() > 1)
tokenText = tokenText.TrimStart('\"').TrimEnd('\"');
bool tokenMatchesTweet = false;
Regex regContainsFrom = new Regex(@"^from\:\w+$", RegexOptions.IgnoreCase);
if (regContainsFrom.IsMatch(tokenText))
{
tokenText = Regex.Replace(tokenText, @"^from\:", "", RegexOptions.IgnoreCase);
tokenMatchesTweet = DoesAccountMatch(tweet, tokenText);
}
else
{
Regex regContainsWord = new Regex(@"(?<=^|\s)(" + Regex.Escape(tokenText) + @")(?=[\s\p{P}]|$)", RegexOptions.IgnoreCase);
tokenMatchesTweet = regContainsWord.IsMatch(tweet.Text);
}
andMatch = andMatch && (tokenMatchesTweet ^ andToken.Negated);
if (!andMatch)
break;
}
match = match || andMatch;
}
return match;
}
private static Tweet MapTweet(ITweet tweet, string track)
{
return tweet == null
? null
: new Tweet
{
CreatedAt = tweet.CreatedAt,
CreatedById = tweet.CreatedBy.Id,
CreatedByIdStr = tweet.CreatedBy.IdStr,
CreatedByName = tweet.CreatedBy.Name,
CreatedByScreenName = tweet.CreatedBy.ScreenName,
Hashtags = tweet.Hashtags
.Select(hashtag =>
new Hashtag
{
Text = hashtag.Text,
Indices = hashtag.Indices,
})
.ToList(),
Id = tweet.Id,
RetweetedTweet = MapTweet(tweet.RetweetedTweet, track),
Text = tweet.Text,
Track = track,
UserMentions = tweet.UserMentions
.Where(userMention => userMention.Id.HasValue)
.Select(userMention =>
new UserMention
{
Id = userMention.Id.Value,
IdStr = userMention.IdStr,
Indices = userMention.Indices,
Name = userMention.Name,
ScreenName = userMention.ScreenName,
})
.ToList(),
};
}
public void StartStream()
{
Tweetinvi.ExceptionHandler.SwallowWebExceptions = false;
var credentials = Tweetinvi.Auth.SetUserCredentials(
TwitterAppCredentials.ConsumerKey,
TwitterAppCredentials.ConsumerSecret,
TwitterAppCredentials.AccessToken,
TwitterAppCredentials.AccessSecret
);
var user = Tweetinvi.User.GetUserFromScreenName("AndrewYang");
_filteredStream = Tweetinvi.Stream.CreateFilteredStream();
_filteredStream.FilterLevel = Tweetinvi.Streaming.Parameters.StreamFilterLevel.None;
_filteredStream.TweetMode = Tweetinvi.TweetMode.Extended;
//_filteredStream.AddLocation(new Location(30.6266, 81.4609, 30.6319, 81.6065));
_filteredStream.AddFollow(user.Id);
_filteredStream.AddTrack("YangGang");
_filteredStream.AddTrack("NevadaCaucuses");
_filteredStream.AddTrack("StillVotingYang");
_filteredStream.AddTrack("NevadaForYang");
//stream.AddTrack("SecureTheBag");
//stream.AddTrack("YangMediaBlackout");
//stream.AddTrack("YangMediaShoutout");
//stream.AddTrack("YangWillWin");
//stream.AddTrack("YangOrBust");
//stream.AddTrack("YangBeatsTrump");
//stream.AddTrack("NewHampshireForYang");
//stream.AddTrack("AmericaNeedsYang");
//stream.AddTrack("LetYangSpeak");
//stream.AddTrack("VoteYang");
_filteredStream.MatchingTweetReceived += (sender, args) =>
{
try
{
ITweet fullTweet = null;
ITweet childTweet = null;
var tweet = args.Tweet;
if (tweet.IsRetweet)
{
return;
}
TwitterUser savedUser;
using (var db = new TwitterSearchModel())
{
savedUser = db.TwitterUsers.Where(u => u.TwitterUserID == tweet.CreatedBy.IdStr).FirstOrDefault();
}
if (savedUser == null)
{
var user = Tweetinvi.User.GetUserFromId(tweet.CreatedBy.Id);
var userJson = Tweetinvi.JsonSerializer.ToJson(user.UserDTO);
Console.WriteLine($"New User: {userJson}");
using (var db = new TwitterSearchModel())
{
db.TwitterUsers.Add(new TwitterUser
{
TwitterUserID = user.IdStr,
TwitterUserJson = userJson
});
db.SaveChanges();
}
}
TweetRecord savedTweet;
using (var db = new TwitterSearchModel())
{
savedTweet = db.TweetRecords.Where(t => t.TweetID == tweet.IdStr).FirstOrDefault();
}
if (savedTweet == null)
{
fullTweet = Tweetinvi.Tweet.GetTweet(tweet.Id);
//var voteYang = Tweetinvi.Timeline.GetUserTimeline(.GetExistingList()
var tweetJson = Tweetinvi.JsonSerializer.ToJson(fullTweet.TweetDTO);
using (var db = new TwitterSearchModel())
{
db.TweetRecords.Add(new TweetRecord
{
TweetID = tweet.IdStr,
TweetJson = tweetJson
});
db.SaveChanges();
}
Console.WriteLine($"User: {fullTweet.CreatedBy.Name}");
Console.WriteLine($"Tweet: {fullTweet.FullText ?? fullTweet.Text}");
Console.WriteLine($"{fullTweet.Url}");
Console.WriteLine();
}
//tweetPostQueue.Enqueue(tweet)
//var fbPostResult = PostToFacebook(tweet).Result;
string childTweetIDStr = tweet.InReplyToStatusIdStr ?? tweet.QuotedStatusIdStr;
if (childTweetIDStr != null)
{
long childTweetID = tweet.InReplyToStatusId ?? tweet.QuotedStatusId ?? 0;
childTweet = Tweetinvi.Tweet.GetTweet(childTweetID);
TweetRecord savedChildTweet;
using (var db = new TwitterSearchModel())
{
savedChildTweet = db.TweetRecords.Where(t => t.TweetID == childTweetIDStr).FirstOrDefault();
}
if (savedChildTweet == null)
{
if (childTweetID != 0)
{
if (childTweet != null)
{
using (var db = new TwitterSearchModel())
{
db.TweetRecords.Add(
new TweetRecord
{
TweetID = childTweetIDStr,
TweetJson = Tweetinvi.JsonSerializer.ToJson(childTweet.TweetDTO)
});
db.SaveChanges();
}
}
}
}
}
if (fullTweet != null && childTweet == null)
{
_tweetHub.Clients.All.SendAsync("ReceiveTweet", fullTweet.TweetDTO.ToJson(), null);
}
if (fullTweet != null && childTweet != null)
{
_tweetHub.Clients.All.SendAsync("ReceiveTweet", fullTweet.TweetDTO.ToJson(), childTweet.TweetDTO.ToJson());
}
}
catch (Exception e)
{
Console.WriteLine($"ERROR: { e.Message}");
}
finally
{
}
};
_filteredStream.StartStreamMatchingAnyCondition();
}
public Tweet(ITweet data)
{
Data = data;
TextToDisplay = ParseTextPieces(data);
}
public static async Task <IEnumerable <ITweet> > SearchRepliesTo(ITweet tweet, bool recursiveReplies)
{
return(await Sync.ExecuteTaskAsync(() => Search.SearchRepliesTo(tweet, recursiveReplies)));
}
// Generates div container for div. This container has tweeter name, tweet date, tweet text and the controls container
public HtmlGenericControl GenerateTweetContainer(ITweet tweetData)
{
#region LblRetweetedBy
Label lblRetweetedBy = new Label();
if (tweetData.RetweetedTweet != null)
{
var retweetedBy = tweetData.CreatedBy;
tweetData = tweetData.RetweetedTweet;
lblRetweetedBy.Text = retweetedBy.Name + " retweeted<br />";
lblRetweetedBy.Attributes["class"] = "retweetedByUser";
}
#endregion
#region LblTweetSenderUserName
Label lblTweetSenderUserName = new Label();
lblTweetSenderUserName.Text = tweetData.CreatedBy.Name;
lblTweetSenderUserName.Attributes["class"] = "tweetSenderUserName";
#endregion
#region LblTweetSenderScreenName
Label lblTweetSenderScreenName = new Label();
lblTweetSenderScreenName.Text = "<a href=ProfilePage.aspx?user="******" target='_blank' style='text-decoration:none;color:#828282;'>@" + tweetData.CreatedBy.ScreenName + "</a>";
lblTweetSenderScreenName.Attributes["class"] = "tweetSenderScreenName";
#endregion
#region LblTweetPublishDate
Label lblTweetPublishDate = new Label();
lblTweetPublishDate.Attributes["class"] = "tweetPublicationDate";
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
DateTime createdAt = tweetData.CreatedAt;
DateTime now = DateTime.Now;
TimeSpan span = now.Subtract(createdAt);
// Time conversions, checks how long time ago the tweet was createad
if (span.TotalMinutes < 1)
{
lblTweetPublishDate.Text = span.Seconds.ToString() + "s";
}
else if (span.TotalHours < 1)
{
lblTweetPublishDate.Text = span.Minutes.ToString() + "m";
}
else if (span.TotalDays < 1)
{
lblTweetPublishDate.Text = span.Hours.ToString() + "h";
}
else if (span.TotalDays > 365)
{
lblTweetPublishDate.Text = tweetData.CreatedAt.ToString("MMM d yyy");
}
else
{
lblTweetPublishDate.Text = tweetData.CreatedAt.ToString("MMM d");
}
#endregion
#region TweetPublicationData
HtmlGenericControl tweetPublicationData = new HtmlGenericControl("div");
tweetPublicationData.Attributes["class"] = "card-content tweet-sender";
tweetPublicationData.Attributes["id"] = "divTweetSender";
#endregion
tweetPublicationData.Controls.Add(lblRetweetedBy);
tweetPublicationData.Controls.Add(lblTweetSenderUserName);
tweetPublicationData.Controls.Add(lblTweetSenderScreenName);
tweetPublicationData.Controls.Add(lblTweetPublishDate);
#region DivTweetText
HtmlGenericControl divTweetText = new HtmlGenericControl("div");
divTweetText.Attributes["class"] = "card-content";
divTweetText.Attributes["id"] = "divCardContent";
// Replace new lines with br tag
divTweetText.InnerHtml = tweetData.Text.Replace("\n", "<br />");
// Find all links and replace them with hyper links
divTweetText.InnerHtml = Regex.Replace(divTweetText.InnerHtml,
@"((http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?)",
"<a target='_blank' href='$1'>$1</a>");
divTweetText.InnerHtml = Regex.Replace(divTweetText.InnerHtml,
@"@(\w+)",
"<a target='_blank' href=ProfilePage.aspx?user=$1>@$1</a>");
divTweetText.InnerHtml = Regex.Replace(divTweetText.InnerHtml,
@"#(\w+)",
"<a target='_blank' href=Search.aspx?query=%23$1>#$1</a>");
#endregion
#region TweetContainer
HtmlGenericControl tweetContainer = new HtmlGenericControl("div");
tweetContainer.Attributes["class"] = "card-stacked";
tweetContainer.Attributes["id"] = "divCardStacked";
#endregion
tweetContainer.Controls.Add(tweetPublicationData);
tweetContainer.Controls.Add(divTweetText);
return(tweetContainer);
}
public Task DestroyTweet(ITweet tweet)
{
return(DestroyTweet(tweet.TweetDTO));
}
/// <summary>
/// The twitter async stream methods call this method to queue the tweets
/// </summary>
/// <param name="tweet"></param>
public void NextTweet(ITweet tweet)
{
queue.Enqueue(new SerializableTweet(tweet));
}
private async Task Tweet()
{
var lastTweet = await newsDatabase.GetLastTweet();
bool canDoNewTweet = lastTweet == null ? true : DateTime.Now.Subtract(lastTweet.Tweet.Date).Minutes > GetRandomMinutes();
if (canDoNewTweet)
{
var nextNewsNoTwitter = (await newsDatabase.GetNewsNoTweet(1)).FirstOrDefault();
if (nextNewsNoTwitter != null)
{
var t = nextNewsNoTwitter.Tags == null ? String.Empty :
TrimWords(nextNewsNoTwitter.Tags.Take(5).Select(_ => "#" + _), TWITTER_MAX_LENGHT - 1
/* subtract 1 `space` char between link and tags */);
var h = TrimWords(nextNewsNoTwitter.Header.SaveLettersAndNumbers().
TrimAndCompactWhitespaces().SplitNoEmpty(new char[] { ' ' }),
TWITTER_MAX_LENGHT - t.Length - 2
/* subtract 1 `space` char between header and link, and 1 `space` char between link and tags */);
var newsUrl = NEWS_URL_PREFIX + nextNewsNoTwitter.Guid;
var twitterMsg = new string[] { h, newsUrl, t };
Auth.SetUserCredentials(
"KaKE385JQWliKR3bzpUpw",
"LKyCUv4VsYb4e6aCsTCwn2ygwnEjrCj7D3fgQeDFQk",
"624687706-2Y87CmUZDsxs9dsIDcDduCexHOXy51xPrZTaezZL",
"wMqexZoDcvpzyj7vorf9Sd94QFkOorYnRugY7qRxvk");
var twitter = User.GetAuthenticatedUser();
if (twitter != null)
{
byte[] img = await GetNewsImage(nextNewsNoTwitter.Url);
ITweet tweet = null;
string tweetText = String.Join(" ", twitterMsg);
if (img == null)
{
tweet = await TweetAsync.PublishTweet(tweetText);
}
else
{
tweet = await TweetAsync.PublishTweetWithImage(tweetText, img);
}
if (tweet != null)
{
await newsDatabase.UpdateNewsTweet(nextNewsNoTwitter.Guid, tweet.IdStr, DateTime.Now);
logger.Info($"New tweet: {tweet.IdStr}/{nextNewsNoTwitter.Guid} {tweetText}");
}
else
{
var ex = Tweetinvi.ExceptionHandler.GetLastException();
if(!String.IsNullOrWhiteSpace(ex?.TwitterDescription))
{
if(ex.StatusCode == 400)
{
await newsDatabase.UpdateNewsTweet(nextNewsNoTwitter.Guid, ex.StatusCode.ToString(), DateTime.Now);
}
else
{
logger.Warn($"{ex.StatusCode} | {ex.TwitterDescription} | {tweetText} | {h.Length + t.Length + 2}");
}
}
}
await Task.Delay(1000);
}
}
}
}
// Tweet generating. The code here could be a bit cleaner and nicer
protected void GenerateTweet(ITweet tweetData, string divIdentifier)
{
BLTwitterClient twitterClient = new BLTwitterClient();
// Find the div to append to. Different for mentions and normal timeline
Control divToAppend = Master.FindControl("ContentPlaceHolder1").FindControl(divIdentifier);
HtmlGenericControl tweetSenderPictureContainer = twitterClient.GenerateTweetSenderPictureContainer(tweetData);
HtmlGenericControl tweetControlsContainer = twitterClient.GenerateTweetControlsContainer();
HtmlGenericControl tweetContainer = twitterClient.GenerateTweetContainer(tweetData);
HtmlGenericControl tweetDataContainer = twitterClient.GenerateTweetDataContainer();
#region Rest of the tweetControlsContainer
// Buttons are generated here. I ran into some logic problems when trying to generate buttons in BL, so they're here
// Reply button
Button replyButton = new Button();
replyButton.Text = " ";
replyButton.Attributes["class"] = "reply";
replyButton.Attributes["onClick"] = "replyButton_Click";
replyButton.Command += replyButton_Click;
replyButton.CommandArgument = tweetData.ToJson();
// Retweet button
Button retweetButton = new Button();
retweetButton.Text = tweetData.RetweetCount.ToString();
retweetButton.Attributes["class"] = "retweet";
retweetButton.Command += retweetButton_Click;
retweetButton.CommandArgument = tweetData.Id.ToString();
if (tweetData.Retweeted)
{
isRetweeted = true;
retweetButton.Style.Add("background-image", "url('../images/retweetGreen.png')");
retweetButton.Style.Add("color", "#19CF8D");
}
else
{
retweetButton.Style.Add("background-image", "url('../images/retweet.png')");
}
// Like button
Button likeButton = new Button();
// Using tweetData.Retweeted didn't work here as it did above, so I had to check if RetweetedTweet is empty or not
if (tweetData.RetweetedTweet != null)
{
// This throws an exception all the time. FavoriteCount is in every retweet, and you can get it without try but it still throws an exception
// I have no idea why it does this, but this fixes it in a way
try
{
likeButton.Text = tweetData.RetweetedTweet.FavoriteCount.ToString();
}
catch (Exception)
{
}
}
else
{
likeButton.Text = tweetData.FavoriteCount.ToString();
}
likeButton.Attributes["class"] = "like";
likeButton.Command += likeButton_Click;
likeButton.CommandArgument = tweetData.Id.ToString();
if (tweetData.Favorited)
{
isFavorited = true;
likeButton.Style.Add("background-image", "url('../images/likeRed.png')");
likeButton.Style.Add("color", "#E2264D");
}
else
{
likeButton.Style.Add("background-image", "url('../images/like.png')");
}
// Delete button
if (tweetData.CreatedBy.ScreenName == ((IAuthenticatedUser)Session["user"]).ScreenName)
{
Button deleteButton = new Button();
deleteButton.Text = " ";
deleteButton.Attributes["class"] = "delete";
deleteButton.Command += deleteButton_Click;
deleteButton.CommandArgument = tweetData.Id.ToString();
deleteButton.OnClientClick = "return confirm('Are you sure you want to delete this tweet?');";
deleteButton.Style.Add("background-image", "url('../images/delete.png')");
tweetControlsContainer.Controls.Add(deleteButton);
}
#endregion
// Add everything to controls
tweetControlsContainer.Controls.Add(replyButton);
tweetControlsContainer.Controls.Add(retweetButton);
tweetControlsContainer.Controls.Add(likeButton);
tweetContainer.Controls.Add(tweetControlsContainer);
tweetDataContainer.Controls.Add(tweetSenderPictureContainer);
tweetDataContainer.Controls.Add(tweetContainer);
divToAppend.Controls.Add(tweetDataContainer);
}
public bool PublishTweet(ITweet tweet)
{
_tweetController.PublishTweet(tweet);
StartLoggedUserOperation(() => _tweetController.PublishTweet(tweet));
return(tweet.IsTweetPublished);
}
// Favorite Tweet
public static async Task<bool> FavoriteTweet(ITweet tweet)
{
return await Sync.ExecuteTaskAsync(() => Tweet.FavoriteTweet(tweet));
}
public static async Task <IEnumerable <ITweet> > SearchDirectRepliesTo(ITweet tweet)
{
return(await Sync.ExecuteTaskAsync(() => Search.SearchDirectRepliesTo(tweet)));
}
// Get Retweet
public static async Task<IEnumerable<ITweet>> GetRetweets(ITweet tweet)
{
return await Sync.ExecuteTaskAsync(() => Tweet.GetRetweets(tweet));
}
private bool TryRaiseTweetEvent(ITweet tweet)
{
if (tweet == null)
{
return false;
}
var tweetReceivedEventArgs = new TweetReceivedEventArgs(tweet);
this.Raise(TweetCreatedByAnyone, tweetReceivedEventArgs);
if (tweet.CreatedBy.Equals(_loggedUser))
{
this.Raise(TweetCreatedByMe, tweetReceivedEventArgs);
}
else
{
this.Raise(TweetCreatedByAnyoneButMe, tweetReceivedEventArgs);
}
if (_friendIds.Contains(tweet.CreatedBy.Id))
{
this.Raise(TweetCreatedByFriend, tweetReceivedEventArgs);
}
return true;
}
public Task FavoriteTweet(ITweet tweet)
{
return(FavoriteTweet(tweet.TweetDTO));
}
public Message ReplyTwitterTweetMessage(int conversationId, int twitterAccountId, string content, bool isCloseConversation = false)
{
var twitterService = DependencyResolver.Resolve <ITwitterService>();
Conversation conversation = _conversationService.CheckIfExists(conversationId);
if (conversation.Source != ConversationSource.TwitterTweet)
{
throw SocialExceptions.BadRequest("Conversation source must be twitter tweet.");
}
SocialAccount twitterAccount = _socialAccountService.FindAllWithDeleted().FirstOrDefault(t => t.Id == twitterAccountId);
if (twitterAccount != null && twitterAccount.IsDeleted)
{
twitterAccount = _socialAccountService.FindAll().FirstOrDefault(t => t.SocialUser.OriginalId == twitterAccount.SocialUser.OriginalId);
}
if (twitterAccount == null)
{
throw SocialExceptions.BadRequest("Twitter account has been deleted.");
}
var messages = Repository.FindAll().Include(t => t.Sender).Include(t => t.Receiver).Where(t => t.ConversationId == conversation.Id).ToList();
var previousMessages = messages.Where(t => t.SenderId != twitterAccountId).OrderByDescending(t => t.SendTime);
Message replyMessage = null;
foreach (var previousMessage in previousMessages)
{
if (previousMessage.IsDeleted)
{
continue;
}
//if (previousMessage.Sender.Type == SocialUserType.IntegrationAccount)
//{
// continue;
//}
ITweet previousTweet = twitterService.GetTweet(twitterAccount, long.Parse(previousMessage.OriginalId));
if (previousTweet != null && !previousTweet.IsTweetDestroyed)
{
// publish tweet
if (!content.Contains("@" + previousTweet.CreatedBy.ScreenName))
{
content = "@" + previousTweet.CreatedBy.ScreenName + " " + content;
}
var replyTweet = twitterService.ReplyTweet(twitterAccount, previousTweet, content);
if (replyTweet == null)
{
continue;
}
// add message
replyMessage = TwitterConverter.ConvertToMessage(replyTweet);
replyMessage.ConversationId = conversation.Id;
replyMessage.SenderId = twitterAccount.Id;
replyMessage.SendAgentId = UserContext.UserId;
replyMessage.ReceiverId = previousMessage.Sender.Id;
Save(replyMessage, isCloseConversation);
break;
}
}
if (replyMessage == null)
{
throw SocialExceptions.OriginalPostOrTweetHasBeenDeleted();
}
return(this.Find(replyMessage.Id));
}
public IEnumerable <ITweet> SearchDirectRepliesTo(ITweet tweet)
{
return(SearchRepliesTo(tweet, false));
}
public MineTweetsModel(ITweet IT)
{
_tweetHandler = IT;
}
public TweetReceivedEventArgs(ITweet tweet, string json) : base(tweet, json)
{
Json = json;
}
public async Task <TwitterProcessResult> ProcessTweet(SocialAccount currentAccount, ITweet currentTweet)
{
return(await _tweetServcie.ProcessTweet(currentAccount, currentTweet));
}
public TweetFavouritedEventArgs(ITweet tweet, string json, IUser favoritingUser) : base(tweet, json)
{
FavouritingUser = favoritingUser;
}
public ITweet ReplyTweet(SocialAccount socialAccount, ITweet inReplyTo, string message)
{
return(_twitterClient.PublishTweet(socialAccount.Token, socialAccount.TokenSecret, message, inReplyTo));
}
public UsedGuidController(IManageYourData dataStore, ITweet tweeter)
{
_dataStore = dataStore;
_tweeter = tweeter;
}
// STATUS [ June 24, 2019 ]: this works
// OPTION 1: tweet id parameter is long
/// <summary>
/// Gets one tweet by providing tweetId (e.g., 1142590848724557824)
/// </summary>
/// <remarks>
/// Uses tweetinvi to execute the search
/// See: https://github.com/linvi/tweetinvi/wiki/Tweets
/// </remarks>
/// <param name="tweetId">
/// The tweed Id of the tweet you want in long form
/// </param>
/// <example>
/// var tweetIdLong = 1142590848724557824;
/// var tweets = GetTweetFromTweetId(tweetIdLong);
/// </example>
/// <returns>
/// Tweetinvi.Models.ITweet
/// </returns>
public ITweet GetTweetFromTweetId(long tweetId)
{
ITweet tweet = Tweet.GetTweet(tweetId);
return(tweet);
}
public TwitterMessage(ITweet tweet)
{
Tweet = tweet;
}
public MessageToBeAnalysedAndHashtagged(ITweet tweet, string hashtag) : base(tweet)
{
Hashtag = hashtag;
}
public MessageToBeAnalysed(ITweet tweet)
{
Tweet = tweet;
}
public TweetEventArgs(ITweet tweet)
{
Tweet = tweet;
}
public Task UnfavoriteTweet(ITweet tweet)
{
return(UnfavoriteTweet(tweet.TweetDTO));
}
public TweetReceivedEventArgs(ITweet tweet) : base(tweet)
{
}
public TweetFavouritedEventArgs(ITweet tweet, IUser favoritingUser) : base(tweet)
{
FavouritingUser = favoritingUser;
}
// Publish Retweet
public static async Task<ITweet> PublishRetweet(ITweet tweet)
{
return await Sync.ExecuteTaskAsync(() => Tweet.PublishRetweet(tweet));
}
public MatchedTweetReceivedEventArgs(ITweet tweet, IEnumerable <string> matchingTracks) : base(tweet)
{
MatchingTracks = matchingTracks;
}
// Destroy Tweet
public static async Task<bool> DestroyTweet(ITweet tweet)
{
return await Sync.ExecuteTaskAsync(() => Tweet.DestroyTweet(tweet));
}
public MatchedTweetAndLocationReceivedEventArgs(ITweet tweet, IEnumerable <string> matchingTracks, IEnumerable <ILocation> matchingLocations)
: base(tweet, matchingTracks)
{
MatchedLocations = matchingLocations;
}
// Generate OEmbedTweet
public static async Task<IOEmbedTweet> GenerateOEmbedTweet(ITweet tweet)
{
return await Sync.ExecuteTaskAsync(() => Tweet.GenerateOEmbedTweet(tweet));
}
public List <string> FindCustomerOriginalIdsInTweetTree(ITweet currentTweet, List <ITweet> tweets, IList <SocialAccount> socialAccounts)
{
return(FindCustomerOriginalIdsFromAncestorsInTweetTree(currentTweet, tweets, socialAccounts)
.Concat(FindCustomerOriginalIdsFromDecendantsInTweetTree(currentTweet, tweets, socialAccounts)).Distinct().ToList());
}
