def add_untracked_friends(self):
"""Add previously untracked users.
If a person is manually followed through the twitter website, this
app doesn't know that a relationship exists.
This method adds untracked people to our repository so we know not
to refollow them and we won't multiple message them."""
self.log.debug("CHECK FOR UNTRACKED FRIENDS")
friends_ids_api = self.api.friends_ids()
targets = Target.objects.filter(hunter=self.user)\
.exclude(status__in=Target.ON_DECK)
friends_ids_django = [t.hunted.twitter_id for t in targets]
untracked_friends_ids = \
filter(lambda x: unicode(x) not in friends_ids_django,
friends_ids_api)
untracked_friends, remainder = lookup_users_by_id(self.api,
untracked_friends_ids)
for untracked_friend in untracked_friends:
"""These could be people who don't follow us, but we want to follow,
for example to keep up with news of their company"""
twitter_account, created = utils.get_or_create_twitter_account(
untracked_friend)
target, created = Target.objects.get_or_create(
hunter=self.user, hunted=twitter_account)
if created:
target.reason = "External add."
target.status = Target.FOLLOWER
target.save()
self.log.debug(" => add friend: %s" % twitter_account.screen_name)
else:
self.log.debug(" => we're following, but no reciprocation: %s" % twitter_account.screen_name)
def add_untracked_followers(self):
"""Add previously untracked users.
These are people that are following us, but the django database doesn't
know about. What that means is that they started following us since the
last run of this function.
There are 2 reasons that happens:
1) We followed them, then they started following us
2) They randomly decided to start following us or we tweeted at them
and they started following us.
In case 1, that means we had initially put them into purgatory and they
responded favorably. We should tweet/DM them and then mark them as
having reciprocated follow.
In case 2, we're just awesome. Just add them as if they have
reciprocated follow (basically, they're good, we just need them in the
database)
"""
self.log.debug("CHECK FOR UNTRACKED FOLLOWERS")
followers_ids_api = self.api.followers_ids()
target = Target.objects.filter(hunter=self.user)\
.filter(status=Target.FOLLOWER)
followers_ids_django = [t.hunted.twitter_id for t in target]
untracked_followers_ids = filter(
lambda x: unicode(x) not in followers_ids_django,
followers_ids_api)
untracked_followers, remainder = lookup_users_by_id(self.api,
untracked_followers_ids)
for untracked_follower in untracked_followers:
twitter_account, created = \
utils.get_or_create_twitter_account(untracked_follower)
target, created = Target.objects.get_or_create(
hunter=self.user, hunted=twitter_account)
if target.status == Target.PURGATORY:
# Yay someone we targeted reciprocated follow
self.follow_reciprocated(target)
else:
print target.status
# Either a totally external follow, an ingrate changed mind,
# or someone who we chatted became interested and followed
# Either way the action is the same, follow him
target.status = Target.FOLLOWER
target.save()
self.log.debug(" => Add follower: %s" % twitter_account.screen_name)
def twitter_done(request):
token = request.session.get('unauthed_token', None)
if not token:
return HttpResponse("No un-authed token cookie")
if token.key != request.GET.get('oauth_token'):
return HttpResponse("Something went wrong! Tokens do not match")
auth = tweepy.OAuthHandler(settings.CONSUMER_KEY, settings.CONSUMER_SECRET)
auth.request_token = token
oauth_token = request.REQUEST.get('oauth_token') # unnecessary
oauth_verifier = request.REQUEST.get('oauth_verifier')
auth.get_access_token(oauth_verifier)
ACCESS_KEY = auth.access_token.key
ACCESS_SECRET = auth.access_token.secret
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
me = api.me()
screen_name = me.screen_name.lower()
# Create an account for this twitter user if we haven't before
user, created = User.objects.get_or_create(username=screen_name)
if created: # or not created:
# WTF, get or create doesnt seem to work now and i'm being lazy
# it keeps returning false, even if the user doesn't exist.
# for now be lazy and just always reset the password
user.set_password(me.id)
user.save()
# Log user in
user = authenticate(
username = screen_name,
password = me.id
)
if user is None:
return HttpResponse("Sorry, couldn't log you in")
login(request, user)
twitter_account, created = get_or_create_twitter_account(me)
if created:
twitter_account.user = request.user
twitter_account.access_key = ACCESS_KEY
twitter_account.access_secret = ACCESS_SECRET
twitter_account.save()
# Take a snapshot of the account
twitter_account_snapshot = TwitterAccountSnapshot(
twitter_account = twitter_account,
followers_count = me.followers_count,
friends_count = me.friends_count,
listed_count = me.listed_count,
)
twitter_account_snapshot.save()
return HttpResponseRedirect("/")
# then pop the name off the competitors list in the UserProfile
# f**k it for now i'm going to just cycle the item to the bottom of the competitor list so we can start getting maximal coverage within api constraints by making sure the top person is new every time
self.competitors.append(self.competitors.pop(0))
# return # for now
self.profile.competitors = "\r\n".join(self.competitors)
self.profile.save()
# use the profile competitors list
# for each name in competitors list
# add all friends
# should filter out garbage users. something like:
users = [u for u in users if not Target.objects.filter(hunter=self.user, hunted__screen_name=u.screen_name.lower())]
for user in users:
twitter_account, created = utils.get_or_create_twitter_account(user)
target, created = Target.objects.get_or_create(
hunter=self.user, hunted=twitter_account)
print target.hunted.screen_name, created
if created:
try:
screen_name = user.screen_name.lower()
match = lambda x: screen_name in \
(x.from_user.lower(), x.to_user and x.to_user.lower())
if not self.strategy == UserProfile.STEAL:
trigger_tweet = filter(match, statuses)[0].text
else:
try:
trigger_tweet = "Steal from user: %s" % stolen_from.get(screen_name.lower(), "someone. i lost it. sorry.")
except Exception, e:
print "YUCK. ERRORS."
