static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddJsonFile("appsecrets.json");
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile("appsecrets.json")
.Build();
//Console.Read();
//The Key has been revoked
//TODO Sleeping looks like :) , the secrets will be moved to an ennrypted files
Auth.SetUserCredentials(config["TwitterAuthConfig:consumerKey"],
config["TwitterAuthConfig:consumerSecret"],
config["TwitterAuthConfig:userAccessToken"], config["TwitterAuthConfig:userAccessSecret"]);
//Tweetinvi.Tweet.PublishTweet("SensingApp:Snowed in)");
//var authenticatedUser = User.GetAuthenticatedUser();
//var tweets = Timeline.GetUserTimeline();
var usertimeline = from c in Timeline.GetUserTimeline(User.GetUserFromScreenName(args[0]).Id) orderby c.CreatedAt ascending select c;
foreach (var tweet in usertimeline)
{
Tweetinvi.Models.ITweet t = tweet;
Utility.WriteWithColor("<<" + t.CreatedAt + ">>");
Utility.WriteWithColor(tweet.ToString() + ":");
}
Console.Read();
}
public Tweet(Tweetinvi.Models.ITweet tweet)
{
this.ID = tweet.Id.ToString();
this.Content = tweet.FullText;
//Get media URL
try
{
this.MediaUrl = tweet.Entities.Medias[0].MediaURL;
}
catch (Exception e)
{
try
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(e);
Console.ForegroundColor = ConsoleColor.White;
this.MediaUrl = tweet.ExtendedTweet.ExtendedEntities.Medias[0].MediaURL;
}
catch (Exception e2)
{
Console.Error.WriteLine($"FOR SOME REASON THERE IS NO IMAGE LINK IN THIS IMAGE TWEET \n GO YELL AT TWITTER FOR THIS I GUESS \n \nSTACK TRACE: {e2}");
throw e2;
//TODO: handle this
}
}
//Get reply count. tweet.replycount is nullable so replace the null with zero
var temp = tweet.ReplyCount;
if (temp == null)
{
this.Replies = 0;
}
else
{
this.Replies = temp;
}
this.Fav = tweet.FavoriteCount;
this.CreationTime = tweet.CreatedAt;
this.RT = tweet.RetweetCount;
this.TweetUrl = tweet.Url;
this.Followers = tweet.CreatedBy.FollowersCount;
//Use this to take into account user popularity
if (Fav != 0)
{
this.LikeFollowRatio = (float)Followers / (float)Fav;
}
else
{
this.LikeFollowRatio = -1;
}
this.AgeHours = DateTime.Today.Date.Subtract(tweet.CreatedAt.Date).Hours;
this.AgeDays = DateTime.Today.Date.Subtract(tweet.CreatedAt.Date).Days;
}
private static void HandleUserReply(Tweetinvi.Models.ITweet userTweet)
{
if (!userTweet.InReplyToStatusId.HasValue ||
userTweet.InReplyToScreenName != gridExplorerBotScreenName)
{
Console.WriteLine("Not a reply to grid explorer bot. id: " + userTweet.Id);
return;
}
if (userTweet.CreatedBy == null ||
userTweet.CreatedBy.ScreenName == "" ||
userTweet.CreatedBy.ScreenName == gridExplorerBotScreenName)
{
Console.WriteLine("Invalid user info or reply to self. id: " + userTweet.Id);
return;
}
string userTextLower = userTweet.GetSafeDisplayText().ToLower();
string cleanedUserText = System.Net.WebUtility.HtmlDecode(userTextLower);
Console.WriteLine("Cleaned user text: " + cleanedUserText);
if (Game.MatchesResetCommand(cleanedUserText))
{
string freshGameOutput = Program.StartFreshGame(DateTimeOffset.UtcNow);
Tweet(freshGameOutput);
return;
}
if (Game.MatchesHelpCommand(cleanedUserText))
{
string commandsListText = Game.GetCommandsList();
TweetChain(commandsListText, userTweet);
return;
}
Console.WriteLine("Fetching parent tweet");
Tweetinvi.Models.ITweet parentGridBotTweet = Tweetinvi.Tweet.GetTweet(userTweet.InReplyToStatusId.Value);
if (parentGridBotTweet.CreatedAt < Program.oldestSupportedData)
{
Console.WriteLine("Parent tweet too old. Save data may not be read in correctly. id: " + userTweet.Id);
TweetReplyTo("This tweet is too old to parse correctly.", userTweet);
return;
}
string cleanedParentText = System.Net.WebUtility.HtmlDecode(parentGridBotTweet.Text);
Console.WriteLine("Running one tick");
string gameOutput = Program.RunOneTick(cleanedParentText, cleanedUserText, parentGridBotTweet.CreatedAt);
TweetReplyTo(gameOutput, userTweet);
}
private void button1_Click(object sender, EventArgs e)
{
if (tweetList.SelectedIndex >= 0)
{
selectedTweet = tweetDict[tweetList.SelectedIndex];
Dictionary <string, string> payload = new Dictionary <string, string>();
payload.Add("user", selectedTweet.CreatedBy.Name);
payload.Add("tweet", "@" + selectedTweet.CreatedBy.Name + ": " + selectedTweet.FullText);
payload.Add("profileImage", selectedTweet.CreatedBy.ProfileImageUrl400x400);
wssv.WebSocketServices.Broadcast(Newtonsoft.Json.JsonConvert.SerializeObject(payload));
}
}
public void pack(Tweetinvi.Models.ITweet tweet)
{
ImageDownloader image = new ImageDownloader(tweet.CreatedBy.ProfileImageUrl400x400);
m_date = tweet.CreatedAt;
m_userName = "******" + tweet.CreatedBy.UserIdentifier.ScreenName;
m_fullName = tweet.CreatedBy.Name;
m_profile.Image = image.download();
m_identifier.Text = m_fullName + " " + m_userName + " " + m_date.ToString();
m_text.Text = tweet.Text;
m_id = tweet.IdStr;
}
private static void GivePhoneAndTweetReply(string likeTempleTweetIdString)
{
Console.WriteLine("Awarding phone " + likeTempleTweetIdString);
long likeTempleTweetId = long.Parse(likeTempleTweetIdString);
Tweetinvi.Models.ITweet likeTempleTweet = Tweetinvi.Tweet.GetTweet(likeTempleTweetId);
string cleanedParentText = System.Net.WebUtility.HtmlDecode(likeTempleTweet.Text);
string gameOutput = Program.AwardMobilePhone(cleanedParentText, likeTempleTweet.CreatedAt);
TweetReplyTo(gameOutput, likeTempleTweet);
}
private static void HandleFavorites(AccountActivityBody accountActivity, Dictionary <string, PrayerCount> tweetIdToPrayerCountMap)
{
if (accountActivity.favorite_events == null || accountActivity.favorite_events.Length == 0)
{
Console.WriteLine("No favorites events");
return;
}
foreach (Tweetinvi.Streams.Model.AccountActivity.AccountActivityFavouriteEventDTO favoriteEvent in accountActivity.favorite_events)
{
Tweetinvi.Models.ITweet favoritedTweet = Tweetinvi.Tweet.GenerateTweetFromDTO(favoriteEvent.FavouritedTweet);
if (favoritedTweet == null ||
favoritedTweet.CreatedBy == null ||
favoritedTweet.CreatedBy.ScreenName != gridExplorerBotScreenName)
{
Console.WriteLine("Didn't favorite a Grid Explorer Bot tweet");
continue;
}
if (favoritedTweet.CreatedAt < Program.oldestSupportedData)
{
Console.WriteLine("Favorited tweet is too old.");
continue;
}
string cleanedFavoritedTweetText = System.Net.WebUtility.HtmlDecode(favoritedTweet.Text);
if (!Program.IsInLikeTemple(cleanedFavoritedTweetText, favoritedTweet.CreatedAt))
{
Console.WriteLine("Isn't in Like Temple");
continue;
}
if (tweetIdToPrayerCountMap.ContainsKey(favoritedTweet.IdStr))
{
tweetIdToPrayerCountMap[favoritedTweet.IdStr].mCurrent -= Program.prayersPerFavorite;
}
else
{
int currentPrayerCount = GetPrayerCount(favoritedTweet);
tweetIdToPrayerCountMap[favoritedTweet.IdStr] = new PrayerCount()
{
mInitial = currentPrayerCount - Program.prayersPerFavorite,
mCurrent = currentPrayerCount,
};
}
}
}
public void AddFromTweet(Tweetinvi.Models.ITweet tweet, Event ev)
{
using (TweetContext context = GetContext())
{
Tweet result = context.Tweets.Where(t => t.TweetId == tweet.Id && t.Event.Id == ev.Id).SingleOrDefault();
if (result != null)
{
List <Tweetinvi.Models.Entities.IMediaEntity> mediaEntities = tweet.Media.Where(e => e.MediaType.Equals("photo")).ToList();
foreach (Tweetinvi.Logic.TwitterEntities.MediaEntity entity in mediaEntities)
{
Add(new MediaUrl(entity.MediaURL, result));
}
}
}
}
public static string GetLatestTweet(BotInstance BotInstance)
{
try
{
Auth.SetUserCredentials(
BotInstance.LoginConfig["Twitter"]["ConsumerKey"].ToString(),
BotInstance.LoginConfig["Twitter"]["ConsumerSecret"].ToString(),
BotInstance.LoginConfig["Twitter"]["AccessToken"].ToString(),
BotInstance.LoginConfig["Twitter"]["AccessSecret"].ToString()
);
Tweetinvi.Models.IUser TwitterUser = User.GetUserFromScreenName("TheHarbonator");
Tweetinvi.Models.ITweet UsersLatestTweet = TwitterUser.GetUserTimeline(1).Last();
return(UsersLatestTweet.Url);
}
catch { return("!Was Unable To Find URL!"); }
}
public static Tweetinvi.Models.ITweet Tweet(string text)
{
Console.WriteLine("Publishing tweet: " + text);
Tweetinvi.Models.ITweet newTweet = Tweetinvi.Tweet.PublishTweet(text);
if (newTweet != null)
{
Console.WriteLine("Published new tweet: " + newTweet.Id);
}
else
{
Console.WriteLine("Failed to publish tweet");
}
return(newTweet);
}
public void OnClientConnected()
{
if (this.IsHandleCreated)
{
Invoke(new Action(() =>
{
if (selectedTweet != null)
{
selectedTweet = tweetDict[tweetList.SelectedIndex];
Dictionary <string, string> payload = new Dictionary <string, string>();
payload.Add("user", selectedTweet.CreatedBy.Name);
payload.Add("tweet", "@" + selectedTweet.CreatedBy.Name + ": " + selectedTweet.FullText);
payload.Add("profileImage", selectedTweet.CreatedBy.ProfileImageUrl400x400);
wssv.WebSocketServices.Broadcast(Newtonsoft.Json.JsonConvert.SerializeObject(payload));
}
}));
}
}
private static void HandleUserRetweet(Tweetinvi.Models.ITweet userTweet, Dictionary <string, PrayerCount> tweetIdToPrayerCountMap)
{
if (!userTweet.IsRetweet)
{
Console.WriteLine("Not a retweet");
return;
}
if (userTweet.RetweetedTweet == null ||
userTweet.RetweetedTweet.CreatedBy == null ||
userTweet.RetweetedTweet.CreatedBy.ScreenName != gridExplorerBotScreenName)
{
Console.WriteLine("Not a retweet of grid explorer bot");
return;
}
if (userTweet.RetweetedTweet.CreatedAt < Program.oldestSupportedData)
{
Console.WriteLine("Retweeted tweet is too old.");
return;
}
string cleanedFavoritedTweetText = System.Net.WebUtility.HtmlDecode(userTweet.RetweetedTweet.Text);
if (!Program.IsInLikeTemple(cleanedFavoritedTweetText, userTweet.RetweetedTweet.CreatedAt))
{
Console.WriteLine("Isn't in the Like Temple");
return;
}
if (tweetIdToPrayerCountMap.ContainsKey(userTweet.RetweetedTweet.IdStr))
{
tweetIdToPrayerCountMap[userTweet.RetweetedTweet.IdStr].mInitial -= Program.prayersPerRetweet;
}
else
{
int currentPrayerCount = GetPrayerCount(userTweet.RetweetedTweet);
tweetIdToPrayerCountMap[userTweet.RetweetedTweet.IdStr] = new PrayerCount()
{
mInitial = currentPrayerCount - Program.prayersPerRetweet,
mCurrent = currentPrayerCount,
};
}
}
public static void TweetChain(string longText, Tweetinvi.Models.ITweet previousTweet)
{
Console.WriteLine("Publishing Tweet Chain");
Console.WriteLine("Text: " + longText);
var tweetTexts = SplitLinesIntoTweets(longText);
foreach (string text in tweetTexts)
{
if (previousTweet == null)
{
previousTweet = Tweet(text);
}
else
{
previousTweet = TweetReplyTo(text, previousTweet);
}
}
}
private Usuarios getUsuario(Tweetinvi.Models.ITweet oTweet)
{
Usuarios oUsuario = new Usuarios();
oUsuario.Id = oTweet.CreatedBy.Id;
oUsuario.Name = oTweet.CreatedBy.Name;
oUsuario.ScreenName = oTweet.CreatedBy.ScreenName;
oUsuario.Description = oTweet.CreatedBy.Description;
oUsuario.Location = oTweet.CreatedBy.Location.ToString();
oUsuario.FriendsCount = oTweet.CreatedBy.FriendsCount;
oUsuario.FollowersCount = oTweet.CreatedBy.FollowersCount;
oUsuario.Language = oTweet.CreatedBy.Language.ToString();
oUsuario.ProfileImageUrl = oTweet.CreatedBy.ProfileImageUrl;
oUsuario.StatusesCount = oTweet.CreatedBy.StatusesCount;
oUsuario.Verified = oTweet.CreatedBy.Verified;
oUsuario.Url = oTweet.CreatedBy.Url;
oUsuario.CreatedAt = oTweet.CreatedBy.CreatedAt;
return(oUsuario);
}
private Texto getTexto(Tweetinvi.Models.ITweet oTweet)
{
Texto oTexto = new Texto();
oTexto.Id = oTweet.Id;
oTexto.CreatedById = oTweet.CreatedBy.Id;
oTexto.FullText = oTweet.FullText;
oTexto.Hashtags = new string[oTweet.Hashtags.Count];
int hash_count = 0;
foreach (Tweetinvi.Logic.TwitterEntities.HashtagEntity hashtag in oTweet.Hashtags)
{
oTexto.Hashtags[hash_count] = hashtag.Text;
hash_count++;
}
oTexto.Language = oTweet.Language.ToString();
oTexto.PublishedTweetLength = oTweet.PublishedTweetLength;
return(oTexto);
}
static void TweetAppraisal(Bitmap image, string text)
{
using (MemoryStream memoryStream = new MemoryStream())
{
image.SaveAsPng(memoryStream);
byte[] bytes = memoryStream.ToArray();
Console.WriteLine("Uploading image to twitter");
Tweetinvi.Models.IMedia media = Tweetinvi.Upload.UploadBinary(new Tweetinvi.Parameters.UploadParameters {
Binary = bytes
});
Console.WriteLine("Publishing tweet");
Tweetinvi.Models.ITweet tweet = Tweetinvi.Tweet.PublishTweet(text, new Tweetinvi.Parameters.PublishTweetOptionalParameters
{
Medias = new List <Tweetinvi.Models.IMedia> {
media
}
});
Console.WriteLine("Tweet published to: " + tweet.Url);
}
}
public static Tweetinvi.Models.ITweet TweetReplyTo(string text, Tweetinvi.Models.ITweet tweet)
{
string screenName = tweet.CreatedBy.ScreenName;
long parentTweetID = tweet.Id;
Console.WriteLine("Publishing tweet in reply to : " + screenName + " " + parentTweetID);
Console.WriteLine("Text: " + text);
string textToPublish = string.Format("@{0} {1}", screenName, text);
Tweetinvi.Models.ITweet newTweet = Tweetinvi.Tweet.PublishTweetInReplyTo(textToPublish, parentTweetID);
if (newTweet != null)
{
Console.WriteLine("Published new tweet: " + newTweet.Id);
}
else
{
Console.WriteLine("Failed to publish tweet");
}
return(newTweet);
}
private void Print(Tweetinvi.Models.ITweet t)
{
Console.WriteLine(t.CreatedAt.ToString("yyyy-MM-dd hh:mm") + "\t: " + t.Text);
}
public async Task SendTweet(Tweetinvi.Models.ITweet tweet)
{
await Clients.All.SendAsync("ReceiveTweet", tweet);
}
private static string GetSafeDisplayText(this Tweetinvi.Models.ITweet tweet)
{
return(tweet.Text.Substring(tweet.SafeDisplayTextRange[0]));
}
private static int GetPrayerCount(Tweetinvi.Models.ITweet tweet)
{
return(tweet.FavoriteCount * Program.prayersPerFavorite + tweet.RetweetCount * Program.prayersPerRetweet);
}
private void tweetList_SelectedIndexChanged(object sender, EventArgs e)
{
selectedTweet = tweetDict[tweetList.SelectedIndex];
}
private async Task Publish()
{
try
{
Console.WriteLine("Publishing...");
var mainTweet = await _composeTweetService.ComposeTotalVolumeTweet();
if (!string.IsNullOrEmpty(mainTweet))
{
Console.WriteLine(mainTweet);
var childrenTweets = await _composeTweetService.ComposeVolumePerCoinTweets();
childrenTweets.ForEach(ct => Console.WriteLine(ct));
var completedOrdersTweet = await _composeTweetService.ComposeCompletedOrderTweet();
Console.WriteLine(completedOrdersTweet);
var openOrdersTweets = await _composeTweetService.ComposeOrdersAndActiveMarkets();
openOrdersTweets.ForEach(ct => Console.WriteLine(ct));
var detailsTweet = _composeTweetService.ComposeMoreDetailsTweet();
Console.WriteLine(detailsTweet);
var parentTweet = Tweet.PublishTweet(mainTweet);
Tweetinvi.Models.ITweet prevTweet = parentTweet;
Tweetinvi.Models.ITweet currTweet;
foreach (var childTweet in childrenTweets)
{
currTweet = Tweet.PublishTweetInReplyTo(childTweet, prevTweet);
prevTweet = currTweet;
}
;
var completedOrdersPostedTweet = Tweet.PublishTweetInReplyTo(completedOrdersTweet, prevTweet);
prevTweet = completedOrdersPostedTweet;
foreach (var openOrderTweet in openOrdersTweets)
{
currTweet = Tweet.PublishTweetInReplyTo(openOrderTweet, prevTweet);
prevTweet = currTweet;
}
;
Tweet.PublishTweetInReplyTo(detailsTweet, prevTweet);
var channelId = Convert.ToUInt64(_discordCredentials.Value.ChannelId);
var discordChannel = _discordSocketClient.GetChannel(channelId) as IMessageChannel;
await discordChannel.SendMessageAsync(parentTweet.Url);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
