def index(request):
# Set up Twitter API with our auth details
api = Api(consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
access_token_key=ACCESS_TOKEN_KEY,
access_token_secret=ACCESS_TOKEN_SECRET)
profile, _ = Profile.objects.get_or_create(user=request.user)
if profile.twitter_name: # If we had a profile and saved a twitter name, use it here or use our username
user_id = profile.twitter_name
else:
user_id = request.user.username
if request.method == "GET":
if 'user' in request.GET:
user_id = request.GET['user']
twitter = api.GetUserTimeline(screen_name=user_id, count=10)
twitter_user = api.GetUser(screen_name=user_id)
country_list = Country.objects.values('name', 'longitude', 'latitude')
for tweet in twitter: # this is horribly slow atm, could speed this up if I thought about it harder.
for country in country_list:
if country[
'name'] in tweet.text: # stupid simple search method, doesn't rank countries by relevance
tweet.country = {
'name': country['name'],
'latitude': country['latitude'],
'longitude': country['longitude']
}
break
return render(request, 'index.html', {
'twitter': twitter,
'twitter_user': twitter_user
})
def get_user_info(cls, user_id, access_token, access_token_secret):
import time
start_time = int(time.time())
#access_token = "877437266544570369-3nOyHrXxHLMtpgLjPn1dUuUV3gT996o"
#access_token = "898153207653740546-VWW0XEnlqlX9HDxZMzIZBEuWEMSfMCo"
#user_id = 877437266544570369
api = Api(cls.CONSUMER_KEY, cls.CONSUMER_SECRET, access_token,
access_token_secret)
user = api.GetUser(user_id=user_id)
end_time = int(time.time())
user_dict = user.AsDict()
result = {}
if "screen_name" in user_dict:
result['nickname'] = user_dict['screen_name']
result['sex'] = 1
if "profile_image_url" in user_dict:
user_dict['profile_image_url'] = user_dict[
'profile_image_url'].replace("normal", "400x400") #把小头像换成大图
result['headimgurl'] = user_dict['profile_image_url']
return result
def set_up_sample_test_data():
with open('token/tokens.json', "r") as file:
tokens = json.load(file)
api = Api(consumer_key=tokens["consumer_key"],
consumer_secret=tokens["consumer_secret"],
access_token_key=tokens["access_token_key"],
access_token_secret=tokens["access_token_secret"],
tweet_mode="extended")
timeline = api.GetUserTimeline(screen_name="Piechocinski",
count=5,
trim_user=False,
include_rts=False)
json_timeline = [post.AsDict() for post in timeline]
with open("test.json", "w") as file:
json.dump(json_timeline, file, indent=4)
user = api.GetUser(screen_name="Piechocinski")
json_user = user.AsDict()
with open("test2.json", "w") as file:
json.dump(json_user, file, indent=4)
def __call__(self):
registry = getUtility(IRegistry)
TWITTER_CONSUMER_KEY = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_key'
).encode()
TWITTER_CONSUMER_SECRET = registry.get(
'cs.auth.twitter.controlpanel.ITwitterLoginSettings.twitter_consumer_secret'
).encode()
session = ISession(self.request)
token = oauth.Token(
session[AuthorizationTokenKeys.oauth_token],
session[AuthorizationTokenKeys.oauth_token_secret],
)
consumer = oauth.Consumer(key=TWITTER_CONSUMER_KEY,
secret=TWITTER_CONSUMER_SECRET)
client = oauth.Client(consumer, token)
resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, 'GET')
if resp.get('status', '999') != '200':
IStatusMessage(self.request).add(
_(u"Error authenticating with Twitter. Please try again."),
type="error")
self.request.response.redirect(self.context.absolute_url())
return u""
access_token = dict(parse_qsl(content))
# Save the data in the session so that the extraction plugin can
# authenticate the user to Plone
session = ISession(self.request)
session[SessionKeys.user_id] = str(access_token['user_id'])
session[SessionKeys.screen_name] = access_token['screen_name']
session[SessionKeys.oauth_token] = access_token['oauth_token']
session[SessionKeys.
oauth_token_secret] = access_token['oauth_token_secret']
api = Api(consumer_key=TWITTER_CONSUMER_KEY,
consumer_secret=TWITTER_CONSUMER_SECRET,
access_token_key=session[AuthorizationTokenKeys.oauth_token],
access_token_secret=session[
AuthorizationTokenKeys.oauth_token_secret])
us = api.GetUser(str(access_token['user_id']))
session[SessionKeys.name] = us.name
session[SessionKeys.profile_image_url] = us.profile_image_url
session[SessionKeys.description] = us.description
session[SessionKeys.location] = us.location
session.save()
# Add user data into our plugin storage:
acl = self.context.acl_users
acl_plugins = acl.plugins
ids = acl_plugins.listPluginIds(IExtractionPlugin)
for id in ids:
plugin = getattr(acl_plugins, id)
if ICSTwitterPlugin.providedBy(plugin):
if plugin._storage.get(session[SessionKeys.user_id],
None) is None:
user_data = {
'screen_name': session[SessionKeys.screen_name],
'fullname': session[SessionKeys.name],
'profile_image_url':
session[SessionKeys.profile_image_url],
'description': session[SessionKeys.description],
'location': session[SessionKeys.location]
}
plugin._storage[session[SessionKeys.user_id]] = user_data
IStatusMessage(self.request).add(_(u"Welcome. You are now logged in."),
type="info")
return_args = ''
if self.request.get('came_from', None) is not None:
return_args = {'came_from': self.request.get('came_from')}
return_args = '?' + urllib.urlencode(return_args)
self.request.response.redirect(self.context.absolute_url() +
'/logged_in' + return_args)
def get_username_by_id(api: twitter.Api, author_id: int) -> str:
user: twitter.models.User = api.GetUser(user_id=author_id)
return user.screen_name
class TwitterApi:
DESTROY_STATUS_ENDPOINT = "https://api.twitter.com/1.1/statuses/destroy/:id.json"
DESTROY_FAVORITE_ENDPOINT = "https://api.twitter.com/1.1/favorites/destroy.json"
# Rate limit per 15 minutes window # TODO use a queue
POST_DIRECT_MESSAGE_RATE_LIMIT = 10
# Maximum amount of friendships we can look at with "GET friendships/lookup"
MAX_AMOUNT_FRIENDSHIPS_LOOKUP = 100
def __init__(self, twitter_credentials):
try:
self.username = twitter_credentials["username"]
# python-twitter
self.api = Api(
consumer_key=twitter_credentials["consumer_key"],
consumer_secret=twitter_credentials["consumer_secret"],
access_token_key=twitter_credentials["access_token"],
access_token_secret=twitter_credentials["access_token_secret"])
# tweepy
auth = tweepy.OAuthHandler(twitter_credentials["consumer_key"],
twitter_credentials["consumer_secret"])
auth.set_access_token(twitter_credentials["access_token"],
twitter_credentials["access_token_secret"])
self.tweepy_api = tweepy.API(auth)
except KeyError as key_error:
logging.critical(
"Invalid \"twitter_credentials\" argument: {}".format(
key_error.args[0]))
raise
except TypeError as type_error:
logging.critical(
"Incorrect \"twitter_credentials\" argument: {}".format(
type_error.args[0]))
raise
def check_rate_limit(self, endpoint_url):
try:
return self.api.CheckRateLimit(endpoint_url)
except error.TwitterError as e:
logging.critical(
'An error happened when rate limit of endpoint {} was checked: {}'
.format(endpoint_url, e.message))
return None
def verify_credentials(self):
try:
return self.api.VerifyCredentials(None, True)
except error.TwitterError as e:
logging.error(
'An error happened while checking the Twitter API credentials validity: {}'
.format(e.message))
raise
def get_followers_set(self):
try:
return set(self.api.GetFollowerIDs())
except error.TwitterError as e:
logging.critical(
'Twitter Supervisor is unable to get the user\'s followers IDs list: {}'
.format(e.message))
raise
def get_user(self, user_id):
try:
return self.api.GetUser(user_id), None
except error.TwitterError as e:
logging.error(
'An error happened while searching for user n°{0}: {1}'.format(
user_id, e.message))
return None, e.message
def get_friendship_lookup(self, users_id):
try:
return self.api.LookupFriendship(users_id)
except error.TwitterError as e:
logging.critical(
'An error happened while looking up friendships: {}'.format(
e.message))
raise
def get_friendship_show(self, target_id):
try:
return self.tweepy_api.show_friendship(
source_screen_name=self.username, target_id=target_id), None
except tweepy.TweepError as e:
return None, e
def send_direct_message(self, text):
logging.info('Sending direct message: \"{}\"'.format(text))
try:
return self.api.PostDirectMessage(text, screen_name=self.username)
except error.TwitterError as e:
logging.error('Unable to send direct message: {}'.format(
e.message))
return None
def get_user_timeline(self):
try:
return self.api.GetUserTimeline(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} timeline: {1}'.format(
self.username, e.message))
return None
def get_favorites(self):
try:
return self.api.GetFavorites(screen_name=self.username,
count=200,
since_id=20)
except error.TwitterError as e:
logging.error('Unable to get user @{0} favorites: {1}'.format(
self.username, e.message))
return None
def delete_status(self, status_id):
try:
return self.api.DestroyStatus(status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete status n°{0} because of error: {1}'.format(
status_id, e.message))
return None
def delete_favorite(self, status_id):
try:
return self.api.DestroyFavorite(status_id=status_id)
except error.TwitterError as e:
logging.error(
'Unable to delete favorite tweet n°{0} because of error: {1}'.
format(status_id, e.message))
return None
def delete_old_stuff(self, items_type, number_of_preserved_items):
if items_type == 'tweet' or items_type == 'retweet':
items = self.get_user_timeline()
rate_limit = self.check_rate_limit(self.DESTROY_STATUS_ENDPOINT)
if items_type == 'retweet':
items = list(filter(lambda x: x.retweeted is True, items))
elif items_type == 'favorite':
items = self.get_favorites()
rate_limit = self.check_rate_limit(self.DESTROY_FAVORITE_ENDPOINT)
else:
logging.error(
'This type of item to delete is not valid: {0}'.format(
items_type))
return []
if rate_limit is not None:
logging.debug(
'Deletable status - Remaining: {} - Reset: {}'.format(
rate_limit.remaining, rate_limit.reset))
if rate_limit.remaining < len(items) - number_of_preserved_items:
start_index = len(items) - rate_limit.remaining
else:
start_index = number_of_preserved_items
else:
logging.error(
'Unable to check the rate limit of the endpoint used to destroy {0}. No {0} will be deleted.'
)
return []
deleted_items = []
for i in range(start_index, len(items)):
if items_type == 'favorite':
deleted_item = self.delete_favorite(items[i].id)
else:
deleted_item = self.delete_status(items[i].id)
if deleted_item is not None:
deleted_items.append(deleted_item)
logging.info('Delete {0} n°{1} from {2}'.format(
items_type, items[i].id, items[i].user.screen_name))
return deleted_items
