public UIElement CreateFavoritePanel(TwitterStatus st, TwitterUser us)
{
StackPanel sp = new StackPanel();
StackPanel abp = new StackPanel();
abp.Orientation = Orientation.Horizontal;
var ab = new TextBlock();
ab.Text = String.Format(MessageMentionFavoritedFormat, us.Name);
ab.FontSize = 18;
var abim = new Image();
abim.Width = 36;
abim.Height = 36;
abim.MouseDown += im_MouseDown2;
abim.Tag = sp;//TODO : ここ
abim.Source = new BitmapImage(new Uri(us.ProfileImageUrlHttps));//TODO : ここ
abp.Children.Add(abim);
abp.Children.Add(ab);
var te = new TextBlock();
te.FontSize = 13;
te.Foreground = Brushes.LightGray;
te.Text = st.TextDecoded;
sp.Children.Add(abp);
sp.Children.Add(te);
sp.Tag = us;
return sp;
}
public ExListWindow(MainWindow mw)
{
InitializeComponent();
main = mw;
svc = main.Service;
me = main.CurrentUser;
}
public async Task<IHttpActionResult> PutTwitterUser(int id, TwitterUser twitterUser)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != twitterUser.Id)
{
return BadRequest();
}
db.Entry(twitterUser).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TwitterUserExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public UserInfo(TwitterUser user)
{
this.Id = user.Id;
this.Name = WebUtility.HtmlDecode(user.Name).Trim();
this.ScreenName = user.ScreenName;
this.Location = WebUtility.HtmlDecode(user.Location);
this.Description = WebUtility.HtmlDecode(user.Description);
try
{
this.ImageUrl = new Uri(user.ProfileImageUrlHttps);
}
catch (Exception)
{
this.ImageUrl = null;
}
this.Url = user.Url;
this.Protect = user.Protected;
this.FriendsCount = user.FriendsCount;
this.FollowersCount = user.FollowersCount;
this.CreatedAt = MyCommon.DateTimeParse(user.CreatedAt);
this.StatusesCount = user.StatusesCount;
this.Verified = user.Verified;
if (user.Status != null)
{
this.RecentPost = user.Status.Text;
this.PostCreatedAt = MyCommon.DateTimeParse(user.Status.CreatedAt);
this.PostSource = user.Status.Source;
}
}
public ListWindow(MainWindow mw, TwitterUser ta)
{
main = mw;
svc = main.Service;
me = main.CurrentUser;
tg = ta;
InitializeComponent();
}
public DirectMessage(MainWindow mw)
{
InitializeComponent();
main = mw;
svc = main.Service;
CurrentUser = main.CurrentUser;
users = new HashSet<TwitterUser>();
dmlist = new ConcurrentDictionary<TwitterUser, List<TwitterDirectMessage>>();
}
public static Bitmap getprofileimage(TwitterUser user)
{
if (userpics.ContainsKey(user.ScreenName))
{
return (userpics[user.ScreenName]);
}
return null;
}
public void AuthenticationSuccessful(TwitterUser user)
{
CanSave = true;
usernameLabel.Text = user.ScreenName;
saveButton.Enabled = !string.IsNullOrEmpty(tweetsPerRunTextBox.Text);
saveButton.Text = "Save";
testButton.Text = "Success!";
testButton.Enabled = false;
}
public void Test_ValidTwitterer()
{
var user = "******";
var twitterer = "Tom";
var twitterUser = new TwitterUser(user);
twitterUser.Twitterers.Add(twitterer);
Assert.IsNotNull(twitterUser, "Twitter Post is null");
Assert.AreEqual<string>(twitterer, twitterUser.Twitterers[0], "Twitterer is invalid");
}
public NGTweeterUser Convert(TwitterUser twitterUser)
{
return new NGTweeterUser
{
Id = twitterUser.Id,
Name = twitterUser.Name,
ScreenName = twitterUser.ScreenName,
ProfileImageUrl = twitterUser.ProfileImageUrl
};
}
private void NotifyUserOnTwitter(ChatMessage message, User user, TwitterUser u)
{
TweetSharp.TwitterService svc = new TwitterService(GetClientInfo());
svc.AuthenticateWith(ConfigurationManager.AppSettings["User.Token"],
ConfigurationManager.AppSettings["User.TokenSecret"]);
svc.SendTweet(String.Format(_tweetFormat,
u.ScreenName,
String.IsNullOrEmpty(user.TwitterUserName) ? user.JabbrUserName : user.TwitterUserName, message.Room));
}
private void AssertValidAuthor(TwitterUser user)
{
Assert.NotNull(user.Name);
Assert.NotNull(user.ScreenName);
Assert.NotNull(user.Url);
Assert.NotNull(user.Description);
Assert.NotNull(user.Location);
Assert.True(user.TweetsCount > 0);
Assert.True(user.Followers > 0);
Assert.True(user.Following > 0);
}
public void Test_ValidTweet()
{
var user = "******";
var tweet = new TwitterPost(user, "Some random message");
var twitterUser = new TwitterUser(user);
twitterUser.TwitterPosts.Add(tweet);
Assert.IsNotNull(twitterUser, "Twitter User is null");
Assert.IsTrue(twitterUser.TwitterPosts.Count == 1, "Tweet count is invalid");
Assert.AreEqual<IPost>(tweet, twitterUser.TwitterPosts[0], "Tweet is invalid");
}
public TegakiDrawWindow(MainWindow mw, DateTime d)
{
InitializeComponent();
MainCanvas.Strokes.StrokesChanged += Strokes_StrokesChanged;
main = mw;
svc = main.Service;
me = main.CurrentUser;
dt = d;
fn = "tegaki" + String.Format("{0:D4}{1:D2}{2:D2}-{3:D2}{4:D2}{5:D2}", dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second) + ".png";
ImageFileName.Text = fn;
}
private static User CreateUserFromTwitterUser(TwitterUser user)
{
return new User
{
Id = user.Id.ToString(CultureInfo.InvariantCulture),
Name = user.Name,
ProfileImageUrl = user.ProfileImageUrl,
ScreenName = user.ScreenName,
FollowersCount = user.FollowersCount,
IsVerified = user.IsVerified.GetValueOrDefault()
};
}
protected void ReceiveUserProfile(TwitterUser user, TwitterResponse response)
{
if (response.StatusCode != HttpStatusCode.OK)
return;
Token.ScreenName = user.ScreenName;
Token.Id = user.Id;
Token.AvatarUrl = user.ProfileImageUrl;
if (UserDataFilled != null)
UserDataFilled(Token);
}
private void AccountDetailsRequestFinished(TwitterUser _user, string _error)
{
if (string.IsNullOrEmpty(_error))
{
AddNewResult("Received account details");
AppendResult("Twitter User="******"Failed to receive account details");
AppendResult("Error=" + _error);
}
}
internal static void NotifyBlocked(TwitterUser source, TwitterUser target)
{
if (MuteBlockManager.IsBlocked(source) || MuteBlockManager.IsOfficialMuted(source))
{
return;
}
if (!NotificationLatch.CheckSetPositive(
NotificationLatchTarget.Block, source.Id, target.Id))
{
return;
}
Head.NotifyBlocked(source, target);
}
public RelationControlViewModel(UserInfoViewModel parent, TwitterAccount source, TwitterUser target)
{
this._parent = parent;
this._source = source;
this._target = target;
var rds = source.RelationData;
this.IsFollowing = rds.IsFollowing(target.Id);
this.IsFollowedBack = rds.IsFollowedBy(target.Id);
this.IsBlocking = rds.IsBlocking(target.Id);
this.IsNoRetweets = rds.IsNoRetweets(target.Id);
Task.Run(() => this.GetFriendship(rds));
}
public ActionResult TwitterPost(string TeewtText)
{
service.SendTweet(new SendTweetOptions {
Status = TeewtText
}, (tweet, response) => { });
TwitterUser user = service.VerifyCredentials(new VerifyCredentialsOptions());
TempData["Name"] = user.Name;
TempData["userpic"] = user.ProfileImageUrl;
return(Redirect("http://localhost:14623/Twitter"));
}
public void Setup()
{
_user = new TwitterUser
{
Name = "Azimuth Project",
Location = "Donetsk, Ukraine",
ScreenName = "AzimuthP",
ProfileImageUrl = "photo.jpg"
};
_webClient = Substitute.For<IWebClient>();
_webClient.GetWebData(ConsumerKey, ConsumerSecret, AccessToken, AccessSecret).Returns(Task.FromResult(_user));
}
public void Update(TwitterUser user)
{
TwitterUser userToUpdate = _loggedInUsers.Where(x => x.RecId == user.RecId).SingleOrDefault();
if (userToUpdate == null)
{
return;
}
int index = _loggedInUsers.IndexOf(userToUpdate);
_loggedInUsers[index] = user;
}
public TwitterUserAddition(TwitterUser user)
{
this.TwitterUser = user;
try
{
var Imagebyte = new WebClient().DownloadData(user.ProfileImageLocation);
UserImage = Image.FromStream(new MemoryStream(Imagebyte));
}
catch (Exception ex)
{
UserImage = global::TwitterAtomationWa.Properties.Resources.NoImages;
}
}
public UserViewModel([NotNull] TwitterUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
this.Model = UserModel.Get(user);
this.CompositeDisposable.Add(
new EventListener <Action <TimelineIconResolution> >(
h => Setting.IconResolution.ValueChanged += h,
h => Setting.IconResolution.ValueChanged -= h,
_ => this.RaisePropertyChanged(() => ProfileImageUriOptimized)));
}
// This URL is registered as the application's callback at http://dev.twitter.com
public ActionResult AuthorizeCallback(string oauth_token, string oauth_verifier)
{
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
try
{
// Step 3 - Exchange the Request Token for an Access Token
TwitterService service = new TwitterService(_consumerKey, _consumerSecret);
OAuthAccessToken accessToken = service.GetAccessToken(requestToken, oauth_verifier);
VerifyCredentialsOptions option = new VerifyCredentialsOptions();
// Step 4 - User authenticates using the Access Token
service.AuthenticateWith(accessToken.Token, accessToken.TokenSecret);
TwitterUser user = service.VerifyCredentials(option);
string[] splited = user.Name.Split(' ');
string name = splited[0];
string lastName = splited[1];
string email = string.Empty;
if (user.Email == null)
{
email = user.ScreenName;
}
else
{
email = user.Email;
}
//Se valida si el usuario de Facebook existe, en caso de que no se registra, en caso contrario se agrega a cuenta de correo actual
CustomerModel consumidor = new CustomerModel();
consumidor.ValidarUsuarioTwitter(email, user.Id.ToString(), name, lastName, "");
//Se agrega los datos del usuario al objeto
consumidor.TwitterID = user.Id.ToString();
consumidor.Email = user.Email;
consumidor.CustomerName = name;
consumidor.CustomerLastname = lastName;
//Se guarda en sesion datos el usuario
Session["twitter"] = consumidor;
return(RedirectToAction("Inicio", "Inicio"));
}
catch (Exception e)
{
throw;
}
}
public IActionResult Index(string id)
{
_logger.LogTrace("User Index: {Id}", id);
id = id.Trim(new[] { ' ', '@' }).ToLowerInvariant();
// Ensure valid username
// https://help.twitter.com/en/managing-your-account/twitter-username-rules
TwitterUser user = null;
if (!string.IsNullOrWhiteSpace(id) && UserRegexes.TwitterAccount.IsMatch(id) && id.Length <= 15)
{
user = _twitterUserService.GetUser(id);
}
var acceptHeaders = Request.Headers["Accept"];
if (acceptHeaders.Any())
{
var r = acceptHeaders.First();
if (r.Contains("application/activity+json"))
{
if (user == null)
{
return(NotFound());
}
var apUser = _userService.GetUser(user);
var jsonApUser = JsonConvert.SerializeObject(apUser);
return(Content(jsonApUser, "application/activity+json; charset=utf-8"));
}
}
if (user == null)
{
return(View("UserNotFound"));
}
var displayableUser = new DisplayTwitterUser
{
Name = user.Name,
Description = user.Description,
Acct = user.Acct.ToLowerInvariant(),
Url = user.Url,
ProfileImageUrl = user.ProfileImageUrl,
Protected = user.Protected,
InstanceHandle = $"@{user.Acct.ToLowerInvariant()}@{_instanceSettings.Domain}"
};
return(View(displayableUser));
}
public void GetProfileImage(string value)
{
if (value != "")
{
Image1.Visible = true;
TwitterResponse <TwitterUser> followers = TwitterUser.Show(tokens, value);
Image1.ImageUrl = followers.ResponseObject.ProfileImageLocation;
}
else
{
TextBox2.Text += "Enter valid Screen Name";
}
}
public void TwitterUser_GetData()
{
TwitterUser t = new TwitterUser(new TwitterUserDataSource());
t.GetData(t.Context);
TwitterDataComponent tdc = t.DroneDataComponent as TwitterDataComponent;
Assert.IsNull(tdc.TwitterUserList); //first time through will not run... don't need to collect data just set the next run interval
Assert.IsNotNull(t.Context.NextRun);
t.GetData(t.Context);
Assert.IsNotNull(tdc.TwitterUserList);
Assert.IsTrue(tdc.TwitterUserList[0].followers_count > 0);
}
public async Task <IHttpActionResult> DeleteTwitterUser(int id)
{
TwitterUser twitterUser = await db.TwitterUsers.FindAsync(id);
if (twitterUser == null)
{
return(NotFound());
}
db.TwitterUsers.Remove(twitterUser);
await db.SaveChangesAsync();
return(Ok(twitterUser));
}
/// <summary>
/// Get FollowersId Of ScreenName
/// </summary>
/// <param name="twitterUser">Twitter UserName And Password</param>
/// <param name="UserToFollow">ScreenName Of Whom You Want To Get FollowersId</param>
/// <returns>Returm True UnFollow Is Success</returns>
public List <string> FollowersId(TwitterUser twitterUser, string ScreenName)
{
List <string> lstFollowersId = new List <string>();
Twitter.Core.SocialGraphMethods.SocialGraph socialGraph = new Twitter.Core.SocialGraphMethods.SocialGraph();
xmlResult = socialGraph.FollowersId(twitterUser, ScreenName);
XmlNodeList xmlNodeList = xmlResult.GetElementsByTagName("id");
foreach (XmlNode xmlNode in xmlNodeList)
{
lstFollowersId.Add(xmlNode.InnerText.ToString());
}
return(lstFollowersId);
}
private static string GetUserImage(TwitterUser user)
{
string url = user.ProfileImageUrl;
string path = GetDownloadFilePath(user.Name + Path.GetExtension(url));
if (!File.Exists(path))
{
using (var webClient = new WebClient())
{
webClient.DownloadFile(url, path);
}
}
return(path);
}
public BackstageAccountModel(TwitterAccount account)
{
this._account = account;
this.UpdateConnectionState();
StoreHelper.GetUser(this._account.Id)
.Subscribe(
u =>
{
_user = u;
this.RaiseTwitterUserChanged();
},
ex => BackstageModel.RegisterEvent(
new OperationFailedEvent("アカウント情報を取得できません(@" + _account.UnreliableScreenName + ")", ex)));
}
/// <summary>
/// This Method Will Check That User Is Authenticatde Or Not
/// </summary>
/// <param name="User">Twitter UserName And Password</param>
/// <returns>Return True If User Is Authenticated</returns>
public bool Verify_Credentials(TwitterUser User)
{
Twitter.Core.AccountMethods.Account account = new Twitter.Core.AccountMethods.Account();
xmlResult = account.Verify_Credentials(User);
XmlNodeList xmlNodeList = xmlResult.GetElementsByTagName("user");
foreach (XmlNode xmlNode in xmlNodeList)
{
//XmlElement idElement = (XmlElement)xmlNode;
//twitterUser.UserID = idElement.GetElementsByTagName("id")[0].InnerText;
return(true);
}
return(false);
}
internal static LoginProfile ProfileFromTwitter(TwitterUser twitterUser)
{
return new LoginProfile()
{
Name = twitterUser.Name,
DisplayName = twitterUser.ScreenName,
Avatar = twitterUser.ProfileImageUrl,
TimeZone = twitterUser.TimeZone,
Locale = twitterUser.Location,
Id = twitterUser.Id.ToString(CultureInfo.InvariantCulture),
Link = twitterUser.Url,
Provider = ProviderConstants.Twitter
};
}
public static void TwitterToNeo4J()
{
var auth = new TwitterAuth(
"nYy5AhN7oiGMHYtSZwuovXsud",
"40U6Vn9KbACfwKhZUCyNEBuP7XiOoDmrbTTkV0Bah6YdJHtbWF",
"1259825000-AzHEC4d37thxV5YyNxo7QGEllzDmJHbADPVNbsn",
"aYFtTTtBdjnLAjWciD8wJBjomDKlaSqwAnWTscm9cPiMr"
);
var t = new TwitterNeo4J();
try {
var api = new TwitterApi(auth);
var tweets = api.GetTimelineForUser(InitialUserId);
var tweetArray = tweets as ITweet[] ?? tweets.ToArray();
TwitterUser user = IUserToUser(tweetArray[0].CreatedBy);
t.InsertUser(user);
foreach (ITweet iTweet in tweetArray)
{
Tweet tweet = ITweetToTweet(iTweet);
t.InsertTweet(tweet);
t.AddTweeted(user, tweet);
}
foreach (long userId in api.GetAllFollowingForUser(InitialUserId))
{
TwitterUser user2 = IUserToUser(api.getUserFromId(userId));
t.InsertUser(user2);
t.AddFollowing(user, user2);
}
foreach (long userId in api.GetAllFollowersForUser(InitialUserId))
{
TwitterUser user2 = IUserToUser(api.getUserFromId(userId));
t.InsertUser(user2);
t.AddFollowing(user2, user);
}
} catch (Exception e) {
Console.WriteLine(e.Message);
}
}
/// <summary>
/// Ensures the given user has cached connections to the given collection of users and caches any user info not already in the database.
/// </summary>
/// <seealso cref="UpdateUserConnections(IConfiguration, string, ICollection{string})"/>
/// <param name="configuration"></param>
/// <param name="queried">The user to update connections for.</param>
/// <param name="users">The list of users connected to the queried user.</param>
internal static void UpdateUserConnections(IConfiguration configuration, TwitterUser queried, ICollection <TwitterUser> users)
{
using (IDriver driver = GetDriver(configuration))
{
using (ISession session = driver.Session(AccessMode.Write))
{
foreach (var user in users)
{
session.WriteTransaction(tx => UpdateUserConnection(tx, queried, user));
}
session.WriteTransaction(tx => MarkQueried(tx, queried.ID));
}
}
}
public static InputSetting CreateDirectMessage(
IEnumerable <TwitterAccount> accounts, [NotNull] TwitterUser recipient, string body = null)
{
if (recipient == null)
{
throw new ArgumentNullException("recipient");
}
return(new InputSetting
{
Accounts = accounts,
Recipient = recipient,
Body = body
});
}
/// <summary>
/// Parse streamed twitter event
/// </summary>
/// <param name="ev">event name</param>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
private static void ParseStreamEvent(string ev, dynamic graph, IStreamHandler handler)
{
try
{
var source = new TwitterUser(graph.source);
var target = new TwitterUser(graph.target);
var timestamp = ((string)graph.created_at).ParseTwitterDateTime();
switch (ev)
{
case "favorite":
case "unfavorite":
case "quoted_tweet":
case "favorited_retweet":
case "retweeted_retweet":
handler.OnMessage(new StreamStatusEvent(source, target,
new TwitterStatus(graph.target_object), ev, timestamp));
break;
case "block":
case "unblock":
case "follow":
case "unfollow":
case "user_update":
case "mute":
case "unmute":
handler.OnMessage(new StreamUserEvent(source, target,
ev, timestamp));
break;
case "list_created":
case "list_destroyed":
case "list_updated":
case "list_member_added":
case "list_member_removed":
case "list_user_subscribed":
case "list_user_unsubscribed":
handler.OnMessage(new StreamListEvent(source, target,
new TwitterList(graph.target_object), ev, timestamp));
break;
default:
break;
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Event parse failed:" + ev, graph.ToString(), ex));
}
}
internal static LoginProfile ProfileFromTwitter(TwitterUser twitterUser)
{
return(new LoginProfile()
{
Name = twitterUser.Name,
DisplayName = twitterUser.ScreenName,
Avatar = twitterUser.ProfileImageUrl,
TimeZone = twitterUser.TimeZone,
Locale = twitterUser.Location,
Id = twitterUser.Id.ToString(CultureInfo.InvariantCulture),
Link = twitterUser.Url,
Provider = ProviderConstants.Twitter
});
}
public static TwitterStatus Map([CanBeNull] DatabaseStatus status, [CanBeNull] StatusEnts statusEntities,
[CanBeNull] IEnumerable <long> favorers, [CanBeNull] IEnumerable <long> retweeters,
[CanBeNull] TwitterUser user)
{
if (status == null)
{
throw new ArgumentNullException(nameof(status));
}
if (statusEntities == null)
{
throw new ArgumentNullException(nameof(statusEntities));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (status.StatusType != StatusType.Tweet)
{
throw new ArgumentException("This overload targeting normal tweet.");
}
if (status.UserId != user.Id)
{
throw new ArgumentException("ID mismatched between status and user.");
}
var ent = statusEntities.Memoize();
if (ent.Any(e => e.ParentId != status.Id))
{
throw new ArgumentException("ID mismatched between status and entities.");
}
Tuple <int, int> displayTextRange = null;
if (status.DisplayTextRangeBegin != null && status.DisplayTextRangeEnd != null)
{
displayTextRange = Tuple.Create(status.DisplayTextRangeBegin.Value, status.DisplayTextRangeEnd.Value);
}
Tuple <double, double> coords = null;
if (status.Latitude != null && status.Longitude != null)
{
coords = Tuple.Create(status.Latitude.Value, status.Longitude.Value);
}
var favs = favorers?.ToArray() ?? new long[0];
var rts = retweeters?.ToArray() ?? new long[0];
return(new TwitterStatus(status.Id, user, status.Text, displayTextRange, status.CreatedAt,
ent.Select(Map).ToArray(), status.Source, status.InReplyToStatusId, status.InReplyToOrRecipientUserId,
favs, rts, status.InReplyToOrRecipientScreenName, coords, null, null));
}
// This URL is registered as the application's callback at http://dev.twitter.com
public ActionResult AuthorizeCallback(string oauth_token, string oauth_verifier)
{
var requestToken = new OAuthRequestToken {
Token = oauth_token
};
// Step 3 - Exchange the Request Token for an Access Token
TwitterService service = new TwitterService(AuthenticationTokens.TwitterConsumerKey, AuthenticationTokens.TwitterConsumerSecret);
OAuthAccessToken accessToken = service.GetAccessToken(requestToken, oauth_verifier);
//Store the access token and secret and create a new user account
TwitterAuthentication authentication = new TwitterAuthentication()
{
AccessToken = accessToken.Token,
AccessTokenSecret = accessToken.TokenSecret
};
//Authenticate account with twitter
service.AuthenticateWith(AuthenticationTokens.TwitterConsumerKey,
AuthenticationTokens.TwitterConsumerSecret,
authentication.AccessToken, authentication.AccessTokenSecret);
TwitterUser twitterUser = service.VerifyCredentials();
ServiceLayer.UserDetailsService.AuthenticateTwitterAccount(authentication, twitterUser.ScreenName,
twitterUser.Id);
//store the credentials in forms auth?
var authTicket = new FormsAuthenticationTicket(1, twitterUser.ScreenName, DateTime.Now,
DateTime.Now.AddMonths(6), true, "");
string cookieContents = FormsAuthentication.Encrypt(authTicket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, cookieContents)
{
Expires = authTicket.Expiration,
Path = FormsAuthentication.FormsCookiePath
};
if (HttpContext != null)
{
HttpContext.Response.Cookies.Add(cookie);
}
//new {authentication.AccessToken, authentication.AccessTokenSecret, twitterUser.ScreenName}
return(RedirectToAction("UserProfile"));
}
internal static LoginProfile ProfileFromTwitter(TwitterUser twitterUser)
{
return(twitterUser == null
? null
: new LoginProfile
{
Name = twitterUser.Name,
DisplayName = twitterUser.ScreenName,
Avatar = twitterUser.ProfileImageSecureLocation,
TimeZone = twitterUser.TimeZone,
Locale = twitterUser.Language,
Id = twitterUser.Id.ToString(CultureInfo.InvariantCulture),
Provider = ProviderConstants.Twitter
});
}
private StringBuilder showUserDetail(TwitterUser user)
{
getWaitCursor();
StringBuilder userInfo = new StringBuilder();
userInfo.Append("Name: " + user.Name).AppendLine();
userInfo.Append("Twitter user since: " + user.CreatedDate).AppendLine();
//userInfo.Append(user.Website).AppendLine();HJ
userInfo.Append(user.NumberOfStatuses + " twitts").AppendLine();
userInfo.Append(user.NumberOfFavorites + " favorites").AppendLine();
userInfo.Append(user.NumberOfFollowers + " followers").AppendLine();
userInfo.Append(user.NumberOfFriends + " friends").AppendLine().AppendLine();
getDefaultCursor();
return(userInfo);
}
internal static void NotifyQuoted(TwitterUser source, TwitterStatus original, TwitterStatus quote)
{
if (MuteBlockManager.IsBlocked(source) || MuteBlockManager.IsOfficialMuted(source))
{
return;
}
if (!Setting.NotifyBackfilledTweets.Value &&
quote.CreatedAt < App.StartupDateTime)
{
// backfilled tweets
return;
}
Task.Run(() => UserProxy.StoreUser(source));
Head.NotifyQuoted(source, original, quote);
}
string FindIconForUser(TwitterUser user)
{
string icon = "";
if (File.Exists(Path.Combine(PhotoDirectory, "" + user.ID)))
{
icon = Path.Combine(PhotoDirectory, "" + user.ID);
}
else
{
DownloadBuddyIcon(user);
}
return(icon);
}
public bool RemoveUser(TwitterUser user)
{
if (_users.TryRemove(user.Id, out _))
{
user = _context.Find <TwitterUser>(user.Id);
_context.Remove(user);
_context.SaveChanges();
UsersChanged?.Invoke(this, new UserChangedEventArgs(null, user));
return(true);
}
return(false);
}
/// <summary>
/// Verify and get information about the user (requires an access token).
/// </summary>
public TwitterUser VerifyCredentials()
{
// Make a call to the API
HttpStatusCode status;
string response = Raw.VerifyCredentials(out status);
// Check for errors
if (status != HttpStatusCode.OK)
{
throw TwitterException.Parse(response);
}
// Parse the response
return(TwitterUser.ParseJson(response));
}
public static TwitterStatus Map([NotNull] DatabaseStatus status, [NotNull] StatusEnts statusEntities,
[CanBeNull] IEnumerable <long> favorers, [CanBeNull] IEnumerable <long> retweeters,
[NotNull] TwitterUser user)
{
if (status == null)
{
throw new ArgumentNullException("status");
}
if (statusEntities == null)
{
throw new ArgumentNullException("statusEntities");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
if (status.StatusType != StatusType.Tweet)
{
throw new ArgumentException("This overload targeting normal tweet.");
}
if (status.UserId != user.Id)
{
throw new ArgumentException("ID mismatched between staus and user.");
}
var ent = statusEntities.Memoize();
if (ent.Any(e => e.ParentId != status.Id))
{
throw new ArgumentException("ID mismatched between status and entities.");
}
return(new TwitterStatus
{
CreatedAt = status.CreatedAt,
Entities = ent.Select(Map).ToArray(),
FavoritedUsers = favorers.Guard().ToArray(),
Id = status.Id,
InReplyToScreenName = status.InReplyToOrRecipientScreenName,
InReplyToStatusId = status.InReplyToStatusId,
InReplyToUserId = status.InReplyToOrRecipientUserId,
Latitude = status.Latitude,
Longitude = status.Longitude,
RetweetedUsers = retweeters.Guard().ToArray(),
StatusType = StatusType.Tweet,
Source = status.Source,
Text = status.Text,
User = user,
});
}
public void Test_ValidToString()
{
var user = "******";
var message = "Some random message";
var tweet = new TwitterPost(user, message);
var twitterUser = new TwitterUser(user);
twitterUser.TwitterPosts.Add(tweet);
Assert.IsNotNull(twitterUser, "Twitter User is null");
Assert.IsTrue(twitterUser.TwitterPosts.Count == 1, "Tweet count is invalid");
StringBuilder sb = new StringBuilder();
sb.AppendFormat("@{0}: {1}", user, message);
Assert.AreEqual<string>(sb.ToString(), twitterUser.TwitterPosts[0].ToString(), "Twitter Post ToString is invalid");
}
public TwitterUser MapProfileInfo(string jsonResponse)
{
var jss = new JavaScriptSerializer();
var data = jss.Deserialize<dynamic>(jsonResponse);
if (data != null && data[0] != null)
{
var d = data[0];
TwitterUser user = new TwitterUser();
user.IdString = d["id_str"];
user.Description = d["description"];
user.Name = d["name"];
user.ScreenName = d["screen_name"];
return user;
}
return null;
}
public static User NewUser(TwitterUser User)
{
return new UserClass {
Name = User.Name,
UserName = User.ScreenName,
Picture = User.ProfileImageUrl,
Bio = User.Description,
JoinedOn = User.CreatedDate.ToString(),
Following = User.FriendsCount,
Followers = User.FollowersCount,
UpdatesCount = User.StatusesCount,
Website = User.Url,
Location = User.Location,
TimeZone = User.TimeZone
};
}
public void SetUserDetails(TwitterUser tup)
{
if (!DesignerProperties.GetIsInDesignMode(this))
{
BitmapImage imgSource = new BitmapImage(new Uri(tup.ProfileImageUrl));
imgUserPhoto.Source = imgSource;
tbUserName.Text = tup.ScreenName;
tbUserDesc.Text = tup.Description;
tbLocation.Text = tup.Location;
tbFollowers.Text = Convert.ToString((int)tup.FollowersCount);
tbFollowing.Text = Convert.ToString((int)tup.FriendsCount);
dmuserProfile.CommandParameter = tup.ScreenName;
btnUnFollow.Visibility = Visibility.Visible;
btnFollow.Visibility = Visibility.Collapsed;
btnUnFollow.DataContext = tup;
btnFollow.DataContext = tup;
}
}
public static void UserObjToTwitterUser(TwitterAPI.User User, TwitterUser twitterUser)
{
twitterUser.Id = Parse.Long(User.Id);
twitterUser.Name = User.Name;
twitterUser.ScreenName = User.ScreenName;
twitterUser.Description = User.Description;
twitterUser.Url = User.URL;
twitterUser.AppUser = false;
twitterUser.ProtectedTweets = Parse.Bool(User.ProtectedTweets);
twitterUser.Location = User.Location;
twitterUser.GeoEnabled = Parse.Bool(User.GeoEnabled);
twitterUser.MemberSince = TwitterAPI.Utility.Parse.TwitterToDateTime(User.Created);
twitterUser.UTCOffset = User.UTCOffset;
twitterUser.TimeZone = User.TimeZone;
twitterUser.Verified = Parse.Bool(User.Verified);
twitterUser.ContributorsEnabled = Parse.Bool(User.ContributorsEnabled);
twitterUser.IsTranslator = Parse.Bool(User.IsTranslator);
twitterUser.Lang = User.Lang;
twitterUser.ShowAllInlineMedia = Parse.Bool(User.ShowAllInlineMedia);
twitterUser.FollowRequestSent = Parse.Bool(User.FollowRequestSent);
twitterUser.ListedCount = Parse.Int(User.ListedCount);
twitterUser.StatusesCount = Parse.Int(User.StatusesCount);
twitterUser.Notifications = User.Notifications;
twitterUser.Following = Parse.Bool(User.Following);
twitterUser.FavoritesCount = Parse.Int(User.FavoritesCount);
twitterUser.FollowersCount = Parse.Int(User.FollowersCount);
twitterUser.FriendsCount = Parse.Int(User.FriendsCount);
twitterUser.ProfileBkgColor = User.ProfileBkgColor;
twitterUser.ProfileTextColor = User.ProfileTextColor;
twitterUser.ProfileLinkColor = User.ProfileLinkColor;
twitterUser.ProfileSidebarFillColor = User.ProfileSidebarFillColor;
twitterUser.ProfileSidebarBorderColor = User.ProfileSidebarBorderColor;
twitterUser.ProfileUseBkgImage = Parse.Bool(User.ProfileUseBkgImg);
twitterUser.ProfileBkgImgUrl = User.ProfileBkgImgURL;
twitterUser.ProfileBkgTile = User.ProfileBkgTile;
twitterUser.ProfileImageUrl = User.ProfileImageURL;
}
public static void fetchprofileimage(TwitterUser user)
{
if (userpics.ContainsKey(user.ScreenName))
return;
HttpWebRequest request = (HttpWebRequest)
WebRequest.Create(user.ProfileImageUrl);
// execute the request
HttpWebResponse response = (HttpWebResponse)
request.GetResponse();
// we will read data via the response stream
Stream resStream = response.GetResponseStream();
System.Drawing.Bitmap img = new System.Drawing.Bitmap(resStream, false);
Bitmap finalImg = new Bitmap(img, 32, 32);
userpics.Add(user.ScreenName, finalImg);
}
public TweetPage(KbtterContext ct, TwitterStatus st)
{
InitializeComponent();
ctx = ct;
stat = st;
dynraw = JObject.Parse(st.RawSource);
if (stat.RetweetedStatus != null)
{
rtuser = stat.User;
stat = stat.RetweetedStatus;
dynraw = dynraw.retweeted_status;
this.Background = new SolidColorBrush(new Color { R = 200, G = 255, B = 200, A = 127 });
}
else
{
this.Background = new SolidColorBrush(new Color { R = 200, G = 255, B = 255, A = 127 });
}
SetStatus();
}
public static TwitterUser[] GetFollowersFor(string sUsername)
{
// Pass your credentials to the service
TwitterService service = new TwitterService("g0fsdKhJObiZLamY2P7vfg", "ghUKQ9y0LvN08clZq6wwU41a0gMlrv9oGj9zd55292w");
// Step 1 - Retrieve an OAuth Request Token
OAuthRequestToken requestToken = service.GetRequestToken();
// Step 2 - Redirect to the OAuth Authorization URL
Uri uri = service.GetAuthorizationUri(requestToken);
//Process.Start(uri.ToString());
// Step 3 - Exchange the Request Token for an Access Token
string verifier = "123456"; // <-- This is input into your application by your user
OAuthAccessToken access = service.GetAccessToken(requestToken, verifier);
access.TokenSecret = "6CFvw63PNUNx4cbj53n5idwlaRUVSz9lKNhr8FM";
access.Token = "14820993-dEh4f6mD1RNSe1pp8ZmKwJb9g0TGyyGqyHuvZsM9s";
// Step 4 - User authenticates using the Access Token
service.AuthenticateWith(access.Token, access.TokenSecret);
TwitterCursorList<TwitterUser> followersList = null;
TwitterCursorList<TwitterUser> list = service.ListFollowersOf(sUsername, -1);
long? nextCursor = list.NextCursor;
followersList = new TwitterCursorList<TwitterUser>(list);
while ((nextCursor ?? 0) != 0)
{
TwitterCursorList<TwitterUser> tempFollowersList = service.ListFollowersOf(sUsername, (long)nextCursor);
if (tempFollowersList.Count <= 0)
break;
followersList.AddRange(tempFollowersList);
nextCursor = tempFollowersList.NextCursor;
}
TwitterUser[] array = new TwitterUser[followersList.Count];
followersList.CopyTo(array);
return array;
}
private void AccountDetailsRequestFinished (TwitterUser _user, string _error)
{
if (string.IsNullOrEmpty(_error))
{
AddNewResult("Received account details");
AppendResult("Twitter User="******"Failed to receive account details");
AppendResult("Error=" + _error);
}
}
public async void TestManyToManyCascadeWithSameClassRelationshipAsync() {
// We will configure the following scenario
// 'John' follows 'Peter' and 'Thomas'
// 'Thomas' follows 'John'
// 'Will' follows 'Claire'
// 'Claire' follows 'Will'
// 'Jaime' follows 'Peter', 'Thomas' and 'Mark'
// 'Mark' doesn't follow anyone
// 'Martha' follows 'Anthony'
// 'Anthony' follows 'Peter'
// 'Peter' follows 'Martha'
//
// Then, we will fetch 'Thomas' and we will load the other users using cascade operations
// 'Claire' and 'Will' won't be loaded because they are outside of the 'Thomas' tree
//
// Cascade operations should stop once the user has been loaded once
// So, more or less, the cascade operation tree will be the following (order may not match)
// 'Thomas' |-(follows)> 'John' |-(follows)> 'Peter' |-(follows)> 'Martha' |-(follows)> 'Anthony' |-(follows)-> 'Peter'*
// | | | | |-(followed by)> 'Martha'*
// | | | |-(followed by)> 'Peter'*
// | | |-(followed by)> 'John'*
// | | |-(followed by)> 'Jaime'*
// | | |-(followed by)> 'Anthony'*
// | |-(follows)> 'Thomas'*
// | |-(followed by)> 'Thomas'*
// |
// |-(followed by)> 'Jaime' |-(follows)> 'Peter'*
// | |-(follows)> 'Thomas'*
// | |-(follows)> 'Mark' |-(followed by)> 'Jaime'*
// |-(followed by)> 'John'*
//
// (*) -> Entity already loaded in a previous operation. Stop cascade loading
var conn = Utils.CreateAsyncConnection();
await conn.DropTableAsync<TwitterUser>();
await conn.DropTableAsync<FollowerLeaderRelationshipTable>();
await conn.CreateTableAsync<TwitterUser>();
await conn.CreateTableAsync<FollowerLeaderRelationshipTable>();
var john = new TwitterUser { Name = "John" };
var thomas = new TwitterUser { Name = "Thomas" };
var will = new TwitterUser { Name = "Will" };
var claire = new TwitterUser { Name = "Claire" };
var jaime = new TwitterUser { Name = "Jaime" };
var mark = new TwitterUser { Name = "Mark" };
var martha = new TwitterUser { Name = "Martha" };
var anthony = new TwitterUser { Name = "anthony" };
var peter = new TwitterUser { Name = "Peter" };
var allUsers = new []{ john, thomas, will, claire, jaime, mark, martha, anthony, peter };
await conn.InsertAllAsync(allUsers);
john.FollowingUsers = new List<TwitterUser>{ peter, thomas };
thomas.FollowingUsers = new List<TwitterUser>{ john };
will.FollowingUsers = new List<TwitterUser>{ claire };
claire.FollowingUsers = new List<TwitterUser>{ will };
jaime.FollowingUsers = new List<TwitterUser>{ peter, thomas, mark };
mark.FollowingUsers = new List<TwitterUser>();
martha.FollowingUsers = new List<TwitterUser>{ anthony };
anthony.FollowingUsers = new List<TwitterUser>{ peter };
peter.FollowingUsers = new List<TwitterUser>{ martha };
foreach (var user in allUsers) {
await conn.UpdateWithChildrenAsync(user);
}
Action<TwitterUser, TwitterUser> checkUser = (expected, obtained) =>
{
Assert.NotNull(obtained, "User is null: {0}", expected.Name);
Assert.AreEqual(expected.Name, obtained.Name);
Assert.That(obtained.FollowingUsers, Is.EquivalentTo(expected.FollowingUsers));
var followers = allUsers.Where(u => u.FollowingUsers.Contains(expected));
Assert.That(obtained.Followers, Is.EquivalentTo(followers));
};
var obtainedThomas = await conn.GetWithChildrenAsync<TwitterUser>(thomas.Id, recursive: true);
checkUser(thomas, obtainedThomas);
var obtainedJohn = obtainedThomas.FollowingUsers.FirstOrDefault(u => u.Id == john.Id);
checkUser(john, obtainedJohn);
var obtainedPeter = obtainedJohn.FollowingUsers.FirstOrDefault(u => u.Id == peter.Id);
checkUser(peter, obtainedPeter);
var obtainedMartha = obtainedPeter.FollowingUsers.FirstOrDefault(u => u.Id == martha.Id);
checkUser(martha, obtainedMartha);
var obtainedAnthony = obtainedMartha.FollowingUsers.FirstOrDefault(u => u.Id == anthony.Id);
checkUser(anthony, obtainedAnthony);
var obtainedJaime = obtainedThomas.Followers.FirstOrDefault(u => u.Id == jaime.Id);
checkUser(jaime, obtainedJaime);
var obtainedMark = obtainedJaime.FollowingUsers.FirstOrDefault(u => u.Id == mark.Id);
checkUser(mark, obtainedMark);
}
public async void TestManyToManyRecursiveDeleteWithSameClassRelationshipAsync() {
// We will configure the following scenario
// 'John' follows 'Peter' and 'Thomas'
// 'Thomas' follows 'John'
// 'Will' follows 'Claire'
// 'Claire' follows 'Will'
// 'Jaime' follows 'Peter', 'Thomas' and 'Mark'
// 'Mark' doesn't follow anyone
// 'Martha' follows 'Anthony'
// 'Anthony' follows 'Peter'
// 'Peter' follows 'Martha'
//
// Then, we will delete 'Thomas' and the other users will be deleted using cascade operations
//
// 'Followed by' branches will be ignored in the delete method because the property doesn't have the
// 'CascadeDelete' operation and it's marked as ReadOnly
//
// 'Jaime', 'Mark', 'Claire' and 'Will' won't be deleted because they're outside the 'Thomas' tree
//
// Cascade operations should stop once the user has been marked for deletion once
// So, more or less, the cascade operation tree will be the following (order may not match)
// 'Thomas' |-(follows)> 'John' |-(follows)> 'Peter' |-(follows)> 'Martha' |-(follows)> 'Anthony' |-(follows)-> 'Peter'*
// |-(follows)> 'Thomas'*
//
//
// (*) -> Entity already marked for deletion in a previous operation. Stop cascade delete
var conn = Utils.CreateAsyncConnection();
await conn.DropTableAsync<TwitterUser>();
await conn.DropTableAsync<FollowerLeaderRelationshipTable>();
await conn.CreateTableAsync<TwitterUser>();
await conn.CreateTableAsync<FollowerLeaderRelationshipTable>();
var john = new TwitterUser { Name = "John" };
var thomas = new TwitterUser { Name = "Thomas" };
var will = new TwitterUser { Name = "Will" };
var claire = new TwitterUser { Name = "Claire" };
var jaime = new TwitterUser { Name = "Jaime" };
var mark = new TwitterUser { Name = "Mark" };
var martha = new TwitterUser { Name = "Martha" };
var anthony = new TwitterUser { Name = "anthony" };
var peter = new TwitterUser { Name = "Peter" };
john.FollowingUsers = new List<TwitterUser>{ peter, thomas };
thomas.FollowingUsers = new List<TwitterUser>{ john };
will.FollowingUsers = new List<TwitterUser>{ claire };
claire.FollowingUsers = new List<TwitterUser>{ will };
jaime.FollowingUsers = new List<TwitterUser>{ peter, thomas, mark };
mark.FollowingUsers = new List<TwitterUser>();
martha.FollowingUsers = new List<TwitterUser>{ anthony };
anthony.FollowingUsers = new List<TwitterUser>{ peter };
peter.FollowingUsers = new List<TwitterUser>{ martha };
var allUsers = new []{ john, thomas, will, claire, jaime, mark, martha, anthony, peter };
// Inserts all the objects in the database recursively
await conn.InsertAllWithChildrenAsync(allUsers, recursive: true);
// Deletes the entity tree starting at 'Thomas' recursively
await conn.DeleteAsync(thomas, recursive: true);
var expectedUsers = new []{ jaime, mark, claire, will };
var existingUsers = await conn.Table<TwitterUser>().ToListAsync();
// Check that the users have been deleted and only the users outside the 'Thomas' tree still exist
Assert.That(existingUsers, Is.EquivalentTo(expectedUsers));
}
public static IEnumerable<IModel> GenerateStatuses(TwitterUser user, int count)
{
throw new NotImplementedException();
}
