// test helpers
private void AssertFriendOrFollowerIds(CursoredList <long> friendOrFollowerIds)
{
Assert.AreEqual(2, friendOrFollowerIds.Count);
Assert.AreEqual(14846645L, friendOrFollowerIds[0]);
Assert.AreEqual(14718006L, friendOrFollowerIds[1]);
Assert.AreEqual(112233, friendOrFollowerIds.PreviousCursor);
Assert.AreEqual(332211, friendOrFollowerIds.NextCursor);
}
private void AssertFriendsOrFollowers(CursoredList <TwitterProfile> friendsOrFollowers)
{
Assert.AreEqual(2, friendsOrFollowers.Count);
Assert.AreEqual("royclarkson", friendsOrFollowers[0].ScreenName);
Assert.AreEqual("kdonald", friendsOrFollowers[1].ScreenName);
Assert.AreEqual(112233, friendsOrFollowers.PreviousCursor);
Assert.AreEqual(332211, friendsOrFollowers.NextCursor);
}
private void AssertIncomingOutgoingFriendships(CursoredList <long> friendships)
{
Assert.AreEqual(3, friendships.Count);
Assert.AreEqual(12345, friendships[0]);
Assert.AreEqual(23456, friendships[1]);
Assert.AreEqual(34567, friendships[2]);
Assert.AreEqual(1234567890, friendships.PreviousCursor);
Assert.AreEqual(1357924680, friendships.NextCursor);
}
public async void FollowToFollows(string username, formTwitter form)
{
try
{
Random rnd4 = new Random();
CursoredList <TwitterProfile> twitterp = await twitter.FriendOperations.GetFollowersAsync(username);
string resultado = "";
foreach (TwitterProfile tp in twitterp)
{
try
{
if (form.txtUsuarioAccesoTwitter.Text != tp.ScreenName)
{
await twitter.FriendOperations.FollowAsync(tp.ID);
List <Cuentas> cuentas = new List <Cuentas>();
form.bdSQLite.obtenerCuentas(ref resultado, ref cuentas);
var valor = cuentas.Find(x => x.Username == Convert.ToString(tp.ScreenName));
if (valor == null)
{
Cuentas cuenta = new Cuentas();
cuenta.Username = tp.ScreenName;
cuenta.Status = 1;
int i4 = rnd4.Next(10000);
if (i4 % 2 == 0)
{
cuenta.Follow = true;
}
else
{
cuenta.Follow = false;
}
form.bdSQLite.insertarCuenta(ref form.tareasTwitter, cuenta, ref resultado);
}
else
{
resultado = System.DateTime.Now + " " + "La cuenta ya se encuentra registrado.";
form.txtLog.Text = System.DateTime.Now + " " +
resultado +
Environment.NewLine + form.txtLog.Text;
}
}
}
catch (Exception ex)
{
continue;
}
}
form.construirTablaCuentas(ref resultado);
}
catch (Exception ex)
{
}
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList<TwitterProfile> twitterProfiles = new CursoredList<TwitterProfile>();
twitterProfiles.PreviousCursor = value.GetValue<long>("previous_cursor");
twitterProfiles.NextCursor = value.GetValue<long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("users"))
{
twitterProfiles.Add(mapper.Deserialize<TwitterProfile>(itemValue));
}
return twitterProfiles;
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList<UserList> userLists = new CursoredList<UserList>();
userLists.PreviousCursor = value.GetValue<long>("previous_cursor");
userLists.NextCursor = value.GetValue<long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("lists"))
{
userLists.Add(mapper.Deserialize<UserList>(itemValue));
}
return userLists;
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList<long> cursoredList = new CursoredList<long>();
cursoredList.PreviousCursor = value.GetValue<long>("previous_cursor");
cursoredList.NextCursor = value.GetValue<long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("ids"))
{
cursoredList.Add(itemValue.GetValue<long>());
}
return cursoredList;
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList <TwitterProfile> twitterProfiles = new CursoredList <TwitterProfile>();
twitterProfiles.PreviousCursor = value.GetValue <long>("previous_cursor");
twitterProfiles.NextCursor = value.GetValue <long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("users"))
{
twitterProfiles.Add(mapper.Deserialize <TwitterProfile>(itemValue));
}
return(twitterProfiles);
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList <long> cursoredList = new CursoredList <long>();
cursoredList.PreviousCursor = value.GetValue <long>("previous_cursor");
cursoredList.NextCursor = value.GetValue <long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("ids"))
{
cursoredList.Add(itemValue.GetValue <long>());
}
return(cursoredList);
}
public object Deserialize(JsonValue value, JsonMapper mapper)
{
CursoredList <UserList> userLists = new CursoredList <UserList>();
userLists.PreviousCursor = value.GetValue <long>("previous_cursor");
userLists.NextCursor = value.GetValue <long>("next_cursor");
foreach (JsonValue itemValue in value.GetValues("lists"))
{
userLists.Add(mapper.Deserialize <UserList>(itemValue));
}
return(userLists);
}
public void GetOutgoingFriendships_Cursored()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/friendships/outgoing.json?cursor=9876543")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Incoming_Or_Outgoing_Friendships"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <long> friendships = twitter.FriendOperations.GetOutgoingFriendshipsAsync(9876543).Result;
#else
CursoredList <long> friendships = twitter.FriendOperations.GetOutgoingFriendships(9876543);
#endif
AssertIncomingOutgoingFriendships(friendships);
}
public void GetFriendsInCursor_ByUserId()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/friends/list.json?cursor=987654321&user_id=98765")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friends_Or_Followers"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <TwitterProfile> friends = twitter.FriendOperations.GetFriendsInCursorAsync(98765L, 987654321).Result;
#else
CursoredList <TwitterProfile> friends = twitter.FriendOperations.GetFriendsInCursor(98765L, 987654321);
#endif
AssertFriendsOrFollowers(friends);
}
public void GetFriendIdsInCursor_CurrentUser()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/friends/ids.json?cursor=123456")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friend_Or_Follower_Ids"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <long> friendIds = twitter.FriendOperations.GetFriendIdsInCursorAsync(123456).Result;
#else
CursoredList <long> friendIds = twitter.FriendOperations.GetFriendIdsInCursor(123456);
#endif
AssertFriendOrFollowerIds(friendIds);
}
public void GetFollowers_currentUser()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/followers/list.json?cursor=-1")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friends_Or_Followers"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <TwitterProfile> followers = twitter.FriendOperations.GetFollowersAsync().Result;
#else
CursoredList <TwitterProfile> followers = twitter.FriendOperations.GetFollowers();
#endif
AssertFriendsOrFollowers(followers);
}
public void GetFollowersInCursor_ByScreenName()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/followers/list.json?cursor=12357&screen_name=oizik")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friends_Or_Followers"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <TwitterProfile> followers = twitter.FriendOperations.GetFollowersInCursorAsync("oizik", 12357).Result;
#else
CursoredList <TwitterProfile> followers = twitter.FriendOperations.GetFollowersInCursor("oizik", 12357);
#endif
AssertFriendsOrFollowers(followers);
}
public void GetFollowerIds_ByUserId()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/followers/ids.json?cursor=-1&user_id=98765")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friend_Or_Follower_Ids"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <long> followerIds = twitter.FriendOperations.GetFollowerIdsAsync(98765L).Result;
#else
CursoredList <long> followerIds = twitter.FriendOperations.GetFollowerIds(98765L);
#endif
AssertFriendOrFollowerIds(followerIds);
}
public void GetFollowerIdsInCursor_ByScreenName()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/followers/ids.json?cursor=24680&screen_name=habuma")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("Friend_Or_Follower_Ids"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <long> followerIds = twitter.FriendOperations.GetFollowerIdsInCursorAsync("habuma", 24680).Result;
#else
CursoredList <long> followerIds = twitter.FriendOperations.GetFollowerIdsInCursor("habuma", 24680);
#endif
AssertFriendOrFollowerIds(followerIds);
}
public void GetBlockedUserIds_Cursored()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/blocks/ids.json?cursor=21")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("CursoredList_Of_Ids"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <long> blockedUsers = twitter.BlockOperations.GetBlockedUserIdsAsync(21).Result;
#else
CursoredList <long> blockedUsers = twitter.BlockOperations.GetBlockedUserIds(21);
#endif
Assert.AreEqual(4, blockedUsers.Count);
Assert.AreEqual(12, blockedUsers.PreviousCursor);
Assert.AreEqual(65, blockedUsers.NextCursor);
}
public void GetBlockedUsers_Cursored()
{
mockServer.ExpectNewRequest()
.AndExpectUri("https://api.twitter.com/1.1/blocks/list.json?skip_status=true&cursor=25")
.AndExpectMethod(HttpMethod.GET)
.AndRespondWith(JsonResource("CursoredList_Of_Profiles"), responseHeaders);
#if NET_4_0 || SILVERLIGHT_5
CursoredList <TwitterProfile> blockedUsers = twitter.BlockOperations.GetBlockedUsersAsync(25).Result;
#else
CursoredList <TwitterProfile> blockedUsers = twitter.BlockOperations.GetBlockedUsers(25);
#endif
Assert.AreEqual(2, blockedUsers.Count);
Assert.AreEqual(12, blockedUsers.PreviousCursor);
Assert.AreEqual(65, blockedUsers.NextCursor);
}
//Obtener últimos 20 usuarios que nos han seguido en Twitter
public List <Seguidor> obtenerUltimos20Seguidores(ref string resultado)
{
try
{
List <Seguidor> seguidores = new List <Seguidor>();
CursoredList <TwitterProfile> seguidoresTwitter =
twitter.FriendOperations.GetFollowersAsync().Result;
foreach (TwitterProfile seguidorTwitter in seguidoresTwitter)
{
Seguidor seguidor = new Seguidor();
seguidor.perfilUsuario.id = seguidorTwitter.ID;
seguidor.perfilUsuario.nick = seguidorTwitter.ScreenName;
seguidor.perfilUsuario.nombre = seguidorTwitter.Name;
if (seguidorTwitter.IsFollowing)
{
seguidor.meSigue = "Sí";
}
else
{
seguidor.meSigue = "No";
}
seguidor.perfilUsuario.seguidores = seguidorTwitter.FollowersCount;
seguidor.perfilUsuario.siguiendo = seguidorTwitter.FriendsCount;
seguidor.perfilUsuario.fechaAlta = seguidorTwitter.CreatedDate;
seguidor.perfilUsuario.descripcion = seguidorTwitter.Description;
seguidor.perfilUsuario.urlPerfil = seguidorTwitter.ProfileUrl;
seguidor.perfilUsuario.ubicacion = seguidorTwitter.Location;
seguidor.perfilUsuario.idioma = seguidorTwitter.Language;
seguidores.Add(seguidor);
resultado = "Obteniendo seguidor [" + Convert.ToString(seguidorTwitter.ID) + "]" +
Environment.NewLine + resultado;
}
resultado = System.DateTime.Now + " " +
"Últimos 20 seguidores obtenidos" +
Environment.NewLine + resultado;
return(seguidores);
}
catch (Exception error)
{
resultado = System.DateTime.Now + " " +
"Error al obtener seguidores: " + error.Message;
return(null);
}
}
//Obtener últimos 20 usuarios a los que seguimos (amigos) en Twitter
public List <Amigo> obtenerUltimos20Amigos(ref string resultado)
{
try
{
List <Amigo> amigos = new List <Amigo>();
CursoredList <TwitterProfile> amigosTwitter =
twitter.FriendOperations.GetFriendsAsync().Result;
foreach (TwitterProfile amigoTwitter in amigosTwitter)
{
Amigo amigo = new Amigo();
amigo.perfilUsuario.id = amigoTwitter.ID;
amigo.perfilUsuario.nick = amigoTwitter.ScreenName;
amigo.perfilUsuario.nombre = amigoTwitter.Name;
if (amigoTwitter.IsFollowing)
{
amigo.meSigue = "Sí";
}
else
{
amigo.meSigue = "No";
}
amigo.perfilUsuario.seguidores = amigoTwitter.FollowersCount;
amigo.perfilUsuario.siguiendo = amigoTwitter.FriendsCount;
amigo.perfilUsuario.fechaAlta = amigoTwitter.CreatedDate;
amigo.perfilUsuario.descripcion = amigoTwitter.Description;
amigo.perfilUsuario.urlPerfil = amigoTwitter.ProfileUrl;
amigo.perfilUsuario.ubicacion = amigoTwitter.Location;
amigo.perfilUsuario.idioma = amigoTwitter.Language;
amigos.Add(amigo);
resultado = "Obteniendo amigo [" + Convert.ToString(amigoTwitter.ID) + "]" +
Environment.NewLine + resultado;
}
resultado = System.DateTime.Now + " " +
"Últimos 20 amigos obtenidos" +
Environment.NewLine + resultado;
return(amigos);
}
catch (Exception error)
{
resultado = System.DateTime.Now + " " +
"Error al obtener amigos: " + error.Message;
return(null);
}
}
//Obtener últimos 5000 usuarios a los que seguimos (amigos) en Twitter
//cursor = -1 obtendrá los 5000 amigos del usuario con el que hemos iniciado sesión
public List <long> obtenerUltimos5000Amigos(long cursor, ref string resultado)
{
try
{
CursoredList <long> amigosTwitter =
twitter.FriendOperations.GetFriendIdsInCursorAsync(cursor).Result;
resultado = System.DateTime.Now + " " +
"Últimos 5000 amigos obtenidos" +
Environment.NewLine + resultado;
return(amigosTwitter);
}
catch (Exception error)
{
resultado = System.DateTime.Now + " " +
"Error al obtener 5000 últimos amigos: " + error.Message;
return(null);
}
}
private CursoredList<TwitterProfile> GetCursoredProfileListAsync(List<long> userIds, long previousCursor, long nextCursor)
{
// TODO: Would be good to figure out how to retrieve profiles in a tighter-than-cursor granularity.
List<List<long>> chunks = this.ChunkList(userIds, 100);
CursoredList<TwitterProfile> users = new CursoredList<TwitterProfile>();
users.PreviousCursor = previousCursor;
users.NextCursor = nextCursor;
Task[] tasks = new Task[chunks.Count];
for (int i = 0; i < chunks.Count; i++)
{
string joinedIds = ArrayUtils.Join(chunks[i].ToArray());
tasks[i] = (this.restTemplate.GetForObjectAsync<IList<TwitterProfile>>(this.BuildUrl("users/lookup.json", "user_id", joinedIds))
.ContinueWith(task => users.AddRange(task.Result)));
}
Task.WaitAll(tasks);
return users;
}
private void GetCursoredProfileListAsync(
RestOperationCompletedEventArgs<CursoredList<long>> userIdsResult,
Action<RestOperationCompletedEventArgs<CursoredList<TwitterProfile>>> operationCompleted)
{
if (userIdsResult.Error == null)
{
// TODO: Would be good to figure out how to retrieve profiles in a tighter-than-cursor granularity.
List<List<long>> chunks = this.ChunkList(userIdsResult.Response, 100);
CursoredList<TwitterProfile> users = new CursoredList<TwitterProfile>();
users.PreviousCursor = userIdsResult.Response.PreviousCursor;
users.NextCursor = userIdsResult.Response.NextCursor;
IEnumerator<List<long>> chunkEnumerator = chunks.GetEnumerator();
this.GetCursoredProfileListAsyncRecursive(userIdsResult, users, chunkEnumerator, operationCompleted);
}
else
{
operationCompleted(new RestOperationCompletedEventArgs<CursoredList<TwitterProfile>>(null, userIdsResult.Error, userIdsResult.Cancelled, userIdsResult.UserState));
}
}
private void AssertCursoredListOfLists(CursoredList <UserList> lists)
{
AssertListOfLists(lists);
Assert.AreEqual(123456, lists.PreviousCursor);
Assert.AreEqual(234567, lists.NextCursor);
}
private void GetCursoredProfileListAsyncRecursive(
RestOperationCompletedEventArgs<CursoredList<long>> userIdsResult,
CursoredList<TwitterProfile> users,
IEnumerator<List<long>> userIdChunk,
Action<RestOperationCompletedEventArgs<CursoredList<TwitterProfile>>> operationCompleted)
{
if (userIdChunk.MoveNext())
{
string joinedIds = ArrayUtils.Join(userIdChunk.Current.ToArray());
this.restTemplate.GetForObjectAsync<IList<TwitterProfile>>(this.BuildUrl("users/lookup.json", "user_id", joinedIds),
r =>
{
if (r.Error == null)
{
users.AddRange(r.Response);
this.GetCursoredProfileListAsyncRecursive(userIdsResult, users, userIdChunk, operationCompleted);
}
else
{
operationCompleted(new RestOperationCompletedEventArgs<CursoredList<TwitterProfile>>(null, r.Error, r.Cancelled, r.UserState));
}
});
}
else
{
operationCompleted(new RestOperationCompletedEventArgs<CursoredList<TwitterProfile>>(users, userIdsResult.Error, userIdsResult.Cancelled, userIdsResult.UserState));
}
}
private void AssertCursoredListOfLists(CursoredList<UserList> lists)
{
AssertListOfLists(lists);
Assert.AreEqual(123456, lists.PreviousCursor);
Assert.AreEqual(234567, lists.NextCursor);
}
private CursoredList<TwitterProfile> GetCursoredProfileList(List<long> userIds, long previousCursor, long nextCursor)
{
// TODO: Would be good to figure out how to retrieve profiles in a tighter-than-cursor granularity.
List<List<long>> chunks = this.ChunkList(userIds, 100);
CursoredList<TwitterProfile> users = new CursoredList<TwitterProfile>();
users.PreviousCursor = previousCursor;
users.NextCursor = nextCursor;
foreach (List<long> userIdChunk in chunks)
{
string joinedIds = ArrayUtils.Join(userIdChunk.ToArray());
users.AddRange(this.restTemplate.GetForObject<IList<TwitterProfile>>(this.BuildUrl("users/lookup.json", "user_id", joinedIds)));
}
return users;
}
private void AssertIncomingOutgoingFriendships(CursoredList<long> friendships)
{
Assert.AreEqual(3, friendships.Count);
Assert.AreEqual(12345, friendships[0]);
Assert.AreEqual(23456, friendships[1]);
Assert.AreEqual(34567, friendships[2]);
Assert.AreEqual(1234567890, friendships.PreviousCursor);
Assert.AreEqual(1357924680, friendships.NextCursor);
}
private void AssertFriendsOrFollowers(CursoredList<TwitterProfile> friendsOrFollowers)
{
Assert.AreEqual(2, friendsOrFollowers.Count);
Assert.AreEqual("royclarkson", friendsOrFollowers[0].ScreenName);
Assert.AreEqual("kdonald", friendsOrFollowers[1].ScreenName);
Assert.AreEqual(112233, friendsOrFollowers.PreviousCursor);
Assert.AreEqual(332211, friendsOrFollowers.NextCursor);
}
// test helpers
private void AssertFriendOrFollowerIds(CursoredList<long> friendOrFollowerIds)
{
Assert.AreEqual(2, friendOrFollowerIds.Count);
Assert.AreEqual(14846645L, friendOrFollowerIds[0]);
Assert.AreEqual(14718006L, friendOrFollowerIds[1]);
Assert.AreEqual(112233, friendOrFollowerIds.PreviousCursor);
Assert.AreEqual(332211, friendOrFollowerIds.NextCursor);
}
private void AssertListOfLists(CursoredList<UserList> lists)
{
Assert.AreEqual(2, lists.Count);
UserList list1 = lists[0];
Assert.AreEqual(40842137, list1.ID);
Assert.AreEqual("forFun2", list1.Name);
Assert.AreEqual("@habuma/forfun2", list1.FullName);
Assert.AreEqual("forfun2", list1.Slug);
Assert.AreEqual("Just for fun, too", list1.Description);
Assert.AreEqual(3, list1.MemberCount);
Assert.AreEqual(0, list1.SubscriberCount);
Assert.AreEqual("/habuma/forfun2", list1.UriPath);
Assert.IsTrue(list1.IsPublic);
UserList list2 = lists[1];
Assert.AreEqual(40841803, list2.ID);
Assert.AreEqual("forFun", list2.Name);
Assert.AreEqual("@habuma/forfun", list2.FullName);
Assert.AreEqual("forfun", list2.Slug);
Assert.AreEqual("Just for fun", list2.Description);
Assert.AreEqual(22, list2.MemberCount);
Assert.AreEqual(100, list2.SubscriberCount);
Assert.AreEqual("/habuma/forfun", list2.UriPath);
Assert.IsFalse(list2.IsPublic);
Assert.AreEqual(123456, lists.PreviousCursor);
Assert.AreEqual(234567, lists.NextCursor);
}
