def save_data(self, token, trigger_id, **data):
"""
let's save the data
"""
if token and 'link' in data and data['link'] is not None and len(data['link']) > 0:
# get the data of this trigger
trigger = Readability.objects.get(trigger_id=trigger_id)
token_key, token_secret = token.split('#TH#')
readability_instance = ReaderClient(self.consumer_key,
self.consumer_secret,
token_key,
token_secret)
bookmark_id = readability_instance.add_bookmark(url=data['link'])
if trigger.tag is not None and len(trigger.tag) > 0:
try:
readability_instance.add_tags_to_bookmark(
bookmark_id, tags=(trigger.tag.lower()))
sentence = str('readability {} created item id {}').format(
data['link'], bookmark_id)
logger.debug(sentence)
except Exception as e:
logger.critical(e)
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
def save_data(self, token, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param **data: the data to check to be used and save
:type trigger_id: int
:type **data: dict
:return: the status of the save statement
:rtype: boolean
"""
status = False
if token and 'link' in data and data['link'] is not None and len(
data['link']) > 0:
# get the data of this trigger
trigger = Readability.objects.get(trigger_id=trigger_id)
token_key, token_secret = token.split('#TH#')
readability_instance = ReaderClient(self.consumer_key,
self.consumer_secret,
token_key, token_secret)
bookmark_id = readability_instance.add_bookmark(url=data['link'])
if trigger.tag is not None and len(trigger.tag) > 0:
try:
readability_instance.add_tags_to_bookmark(
bookmark_id, tags=(trigger.tag.lower()))
sentence = str('readability {} created item id {}').format(
data['link'], bookmark_id)
logger.debug(sentence)
status = True
except Exception as e:
logger.critical(e)
status = False
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
class ServiceReadability(ServicesMgr):
def __init__(self, token=None):
base = 'https://www.readability.com'
self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base)
self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base)
self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base)
self.consumer_key = settings.TH_READABILITY['consumer_key']
self.consumer_secret = settings.TH_READABILITY['consumer_secret']
self.token = token
if token:
token_key, token_secret = self.token.split('#TH#')
self.client = ReaderClient(token_key, token_secret,
self.consumer_key, self.consumer_secret)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
date_triggered = kwargs['date_triggered']
trigger_id = kwargs['trigger_id']
data = []
if self.token is not None:
bookmarks = self.client.get_bookmarks(
added_since=date_triggered).content
for bookmark in bookmarks.values():
for b in bookmark:
if 'article' in b:
title = ''
if 'title' in b['article']:
title = b['article']['title']
link = ''
if 'url' in b['article']:
link = b['article']['url']
content = ''
if 'excerpt' in b['article']:
content = b['article']['excerpt']
data.append(
{'title': title,
'link': link,
'content': content})
cache.set('th_readability_' + str(trigger_id), data)
return data
def process_data(self, **kwargs):
"""
get the data from the cache
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
"""
kw = {'cache_stack': 'th_readability', 'trigger_id': str(kwargs['trigger_id'])}
return super(ServiceReadability, self).process_data(**kw)
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
status = False
if self.token and 'link' in data and\
data['link'] is not None and\
len(data['link']) > 0:
# get the data of this trigger
trigger = Readability.objects.get(trigger_id=trigger_id)
bookmark_id = self.client.add_bookmark(url=data['link'])
if trigger.tag is not None and len(trigger.tag) > 0:
try:
self.client.add_tags_to_bookmark(
bookmark_id, tags=(trigger.tag.lower()))
sentence = str('readability {} created item id {}').format(
data['link'], bookmark_id)
logger.debug(sentence)
status = True
except Exception as e:
logger.critical(e)
status = False
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
"""
request_token = super(ServiceReadability, self).auth(request)
callback_url = self.callback_url(request, 'readability')
# URL to redirect user to, to authorize your app
auth_url_str = '%s?oauth_token=%s&oauth_callback=%s'
auth_url = auth_url_str % (self.AUTH_URL,
request_token['oauth_token'],
callback_url)
return auth_url
def callback(self, request):
"""
Called from the Service when the user accept to activate it
"""
kwargs = {'access_token': '', 'service': 'ServiceReadability',
'return': 'readability'}
return super(ServiceReadability, self).callback(request, **kwargs)
class ReaderClientMultipleBookmarkTest(unittest.TestCase):
"""
Tests for bookmark functionality
"""
def setUp(self):
"""
Add a few bookmarks.
"""
token_key, token_secret = xauth()
self.reader_client = ReaderClient(token_key=token_key, token_secret=token_secret)
self.urls = [
'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/',
'http://www.theatlantic.com/business/archive/2013/01/why-smart-poor-students-dont-apply-to-selective-colleges-and-how-to-fix-it/272490/',
]
self.favorite_urls = [
'http://www.theatlantic.com/sexes/archive/2013/01/the-lonely-existence-of-mel-feit-mens-rights-advocate/267413/',
'http://www.theatlantic.com/technology/archive/2013/01/women-in-combat-an-idea-whose-time-has-come-aided-by-technology/272483/'
]
self.archive_urls = [
'http://www.theatlantic.com/business/archive/2013/01/what-economics-can-and-cant-tell-us-about-the-legacy-of-legal-abortion/267459/',
'http://www.theatlantic.com/business/archive/2013/01/5-ways-to-understand-just-how-absurd-spains-26-unemployment-rate-is/272502/'
]
self.all_urls = self.urls + self.favorite_urls + self.archive_urls
for url in self.urls:
response = self.reader_client.add_bookmark(url)
self.assertTrue(response.status_code in [201, 202])
for url in self.favorite_urls:
response = self.reader_client.add_bookmark(url, favorite=True)
self.assertTrue(response.status_code in [201, 202])
for url in self.archive_urls:
response = self.reader_client.add_bookmark(url, archive=True)
self.assertTrue(response.status_code in [201, 202])
def test_get_bookmarks(self):
"""
Test getting all bookmarks
"""
response = self.reader_client.get_bookmarks()
self.assertEqual(response.status_code, 200)
self.assertEqual(
len(response.json()['bookmarks']), len(self.all_urls))
# test favorite bookmarks
response = self.reader_client.get_bookmarks(favorite=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(
len(response.json()['bookmarks']), len(self.favorite_urls))
for bm in response.json()['bookmarks']:
self.assertTrue(bm['article']['url'] in self.favorite_urls)
# test archive bookmarks
response = self.reader_client.get_bookmarks(archive=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(
len(response.json()['bookmarks']), len(self.archive_urls))
for bm in response.json()['bookmarks']:
self.assertTrue(bm['article']['url'] in self.archive_urls)
def tearDown(self):
"""
Remove all added bookmarks.
"""
for bm in self.reader_client.get_bookmarks().json()['bookmarks']:
del_response = self.reader_client.delete_bookmark(bm['id'])
self.assertEqual(del_response.status_code, 204)
class ReaderClientSingleBookmarkTest(unittest.TestCase):
"""
Tests that only need one bookmark
"""
def setUp(self):
"""
Get a client and add a bookmark
"""
token_key, token_secret = xauth()
self.reader_client = ReaderClient(token_key=token_key, token_secret=token_secret)
self.url = 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/'
add_response = self.reader_client.add_bookmark(self.url)
self.assertTrue(add_response.status_code in [201, 202])
def tearDown(self):
"""
Remove all added bookmarks.
"""
for bm in self.reader_client.get_bookmarks().json()['bookmarks']:
del_response = self.reader_client.delete_bookmark(bm['id'])
self.assertEqual(del_response.status_code, 204)
def test_get_bookmark(self):
"""
Test getting one bookmark by id
"""
bookmark_id = self._get_bookmark_data()['id']
bm_response = self.reader_client.get_bookmark(bookmark_id)
self.assertEqual(bm_response.status_code, 200)
some_expected_keys = set(['article', 'user_id', 'favorite', 'id'])
received_keys = set(bm_response.json().keys())
self.assertTrue(some_expected_keys.issubset(received_keys))
def test_bookmark_tag_functionality(self):
"""
Test adding, fetching and deleting tags on a bookmark.
"""
bookmark_id = self._get_bookmark_data()['id']
# test getting empty tags
tag_response = self.reader_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status_code, 200)
self.assertEqual(len(tag_response.json()['tags']), 0)
# test adding tags
tags = ['tag', 'another tag']
tag_string = ', '.join(tags)
tag_add_response = \
self.reader_client.add_tags_to_bookmark(bookmark_id, tag_string)
self.assertEqual(tag_add_response.status_code, 202)
# re-fetch tags. should have 2
retag_response = self.reader_client.get_bookmark_tags(bookmark_id)
self.assertEqual(retag_response.status_code, 200)
self.assertEqual(len(retag_response.json()['tags']), 2)
for tag in retag_response.json()['tags']:
self.assertTrue(tag['text'] in tags)
# test getting tags for user
user_tag_resp = self.reader_client.get_tags()
self.assertEqual(user_tag_resp.status_code, 200)
self.assertEqual(len(user_tag_resp.json()['tags']), 2)
for tag in user_tag_resp.json()['tags']:
self.assertTrue(tag['text'] in tags)
# test getting a single tag while we're here
single_tag_resp = self.reader_client.get_tag(tag['id'])
self.assertEqual(single_tag_resp.status_code, 200)
self.assertTrue('applied_count' in single_tag_resp.json())
self.assertTrue('id' in single_tag_resp.json())
self.assertTrue('text' in single_tag_resp.json())
# delete tags
for tag in retag_response.json()['tags']:
del_response = self.reader_client.delete_tag_from_bookmark(
bookmark_id, tag['id'])
self.assertEqual(del_response.status_code, 204)
# check that tags are gone
tag_response = self.reader_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status_code, 200)
self.assertEqual(len(tag_response.json()['tags']), 0)
def _get_bookmark_data(self):
"""
Convenience method to get a single bookmark's data.
"""
bm_response = self.reader_client.get_bookmarks()
self.assertEqual(bm_response.status_code, 200)
bm_response_json = bm_response.json()
self.assertTrue(len(bm_response_json['bookmarks']) > 0)
return bm_response_json['bookmarks'][0]
class ReaderClientSingleBookmarkTest(TestCase):
"""Tests that only need one bookmark
"""
def setUp(self):
"""Get a client and add a bookmark
"""
token_pair = xauth(CONSUMER_KEY, CONSUMER_SECRET, USERNAME, PASSWORD)
self.token_key = token_pair[0]
self.token_secret = token_pair[1]
self.base_client = ReaderClient(CONSUMER_KEY, CONSUMER_SECRET,
self.token_key, self.token_secret)
self.url = 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/'
add_response = self.base_client.add_bookmark(self.url)
self.assertEqual(add_response.status, 202)
def tearDown(self):
"""Remove all added bookmarks.
"""
for bm in self.base_client.get_bookmarks().content['bookmarks']:
del_response = self.base_client.delete_bookmark(bm['id'])
self.assertEqual(del_response.status, 204)
def test_get_bookmark(self):
"""Test getting one bookmark by id
"""
# get a bookmark id
bm_response = self.base_client.get_bookmarks()
self.assertEqual(bm_response.status, 200)
self.assertTrue(len(bm_response.content['bookmarks']) > 0)
bookmark_id = bm_response.content['bookmarks'][0]['id']
bm_response = self.base_client.get_bookmark(bookmark_id)
self.assertEqual(bm_response.status, 200)
some_expected_keys = set(['article', 'user_id', 'favorite', 'id'])
received_keys = set(bm_response.content.keys())
self.assertTrue(some_expected_keys.issubset(received_keys))
def test_bookmark_tag_functionality(self):
"""Test adding, fetching and deleting tags on a bookmark.
"""
# get a bookmark id
bm_response = self.base_client.get_bookmarks()
self.assertEqual(bm_response.status, 200)
self.assertTrue(len(bm_response.content['bookmarks']) > 0)
bookmark_id = bm_response.content['bookmarks'][0]['id']
# test getting empty tags
tag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status, 200)
self.assertEqual(len(tag_response.content['tags']), 0)
# test adding tags
tags = ['tag', 'another tag']
tag_string = ', '.join(tags)
tag_add_response = \
self.base_client.add_tags_to_bookmark(bookmark_id, tag_string)
self.assertEqual(tag_add_response.status, 202)
# re-fetch tags. should have 2
retag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(retag_response.status, 200)
self.assertEqual(len(retag_response.content['tags']), 2)
for tag in retag_response.content['tags']:
self.assertTrue(tag['text'] in tags)
# test getting tags for user
user_tag_resp = self.base_client.get_tags()
self.assertEqual(user_tag_resp.status, 200)
self.assertEqual(len(user_tag_resp.content['tags']), 2)
for tag in user_tag_resp.content['tags']:
self.assertTrue(tag['text'] in tags)
# test getting a single tag while we're here
single_tag_resp = self.base_client.get_tag(tag['id'])
self.assertEqual(single_tag_resp.status, 200)
self.assertTrue('applied_count' in single_tag_resp.content)
self.assertTrue('id' in single_tag_resp.content)
self.assertTrue('text' in single_tag_resp.content)
# delete tags
for tag in retag_response.content['tags']:
del_response = self.base_client.delete_tag_from_bookmark(
bookmark_id, tag['id'])
self.assertEqual(del_response.status, 204)
# check that tags are gone
tag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status, 200)
self.assertEqual(len(tag_response.content['tags']), 0)
class ReaderClientMultipleBookmarkTest(TestCase):
"""Tests for bookmark functionality
"""
def setUp(self):
"""Add a few bookmarks.
"""
token_pair = xauth(CONSUMER_KEY, CONSUMER_SECRET, USERNAME, PASSWORD)
self.token_key = token_pair[0]
self.token_secret = token_pair[1]
self.base_client = ReaderClient(CONSUMER_KEY, CONSUMER_SECRET,
self.token_key, self.token_secret)
self.urls = [
'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/',
'http://www.theatlantic.com/business/archive/2013/01/why-smart-poor-students-dont-apply-to-selective-colleges-and-how-to-fix-it/272490/',
]
self.favorite_urls = [
'http://www.theatlantic.com/sexes/archive/2013/01/the-lonely-existence-of-mel-feit-mens-rights-advocate/267413/',
'http://www.theatlantic.com/technology/archive/2013/01/women-in-combat-an-idea-whose-time-has-come-aided-by-technology/272483/'
]
self.archive_urls = [
'http://www.theatlantic.com/business/archive/2013/01/what-economics-can-and-cant-tell-us-about-the-legacy-of-legal-abortion/267459/',
'http://www.theatlantic.com/business/archive/2013/01/5-ways-to-understand-just-how-absurd-spains-26-unemployment-rate-is/272502/'
]
self.all_urls = self.urls + self.favorite_urls + self.archive_urls
for url in self.urls:
add_response = self.base_client.add_bookmark(url)
self.assertEqual(add_response.status, 202)
for url in self.favorite_urls:
add_response = self.base_client.add_bookmark(url, favorite=True)
self.assertEqual(add_response.status, 202)
for url in self.archive_urls:
add_response = self.base_client.add_bookmark(url, archive=True)
self.assertEqual(add_response.status, 202)
def test_get_bookmarks(self):
"""Test getting all bookmarks
"""
bm_response = self.base_client.get_bookmarks()
self.assertEqual(bm_response.status, 200)
self.assertEqual(len(bm_response.content['bookmarks']),
len(self.all_urls))
# test favorite bookmarks
bm_response = self.base_client.get_bookmarks(favorite=True)
self.assertEqual(bm_response.status, 200)
self.assertEqual(len(bm_response.content['bookmarks']),
len(self.favorite_urls))
for bm in bm_response.content['bookmarks']:
self.assertTrue(bm['article']['url'] in self.favorite_urls)
# test archive bookmarks
bm_response = self.base_client.get_bookmarks(archive=True)
self.assertEqual(bm_response.status, 200)
self.assertEqual(len(bm_response.content['bookmarks']),
len(self.archive_urls))
for bm in bm_response.content['bookmarks']:
self.assertTrue(bm['article']['url'] in self.archive_urls)
def tearDown(self):
"""Remove all added bookmarks.
"""
for bm in self.base_client.get_bookmarks().content['bookmarks']:
del_response = self.base_client.delete_bookmark(bm['id'])
self.assertEqual(del_response.status, 204)
class ServiceReadability(ServicesMgr):
def __init__(self, token=None):
base = 'https://www.readability.com'
self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base)
self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base)
self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base)
self.consumer_key = settings.TH_READABILITY['consumer_key']
self.consumer_secret = settings.TH_READABILITY['consumer_secret']
self.token = token
if token:
token_key, token_secret = self.token.split('#TH#')
self.client = ReaderClient(token_key, token_secret,
self.consumer_key, self.consumer_secret)
def read_data(self, **kwargs):
"""
get the data from the service
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
:rtype: list
"""
date_triggered = kwargs['date_triggered']
trigger_id = kwargs['trigger_id']
data = []
if self.token is not None:
bookmarks = self.client.get_bookmarks(
added_since=date_triggered).content
for bookmark in bookmarks.values():
for b in bookmark:
if 'article' in b:
title = ''
if 'title' in b['article']:
title = b['article']['title']
link = ''
if 'url' in b['article']:
link = b['article']['url']
content = ''
if 'excerpt' in b['article']:
content = b['article']['excerpt']
data.append({
'title': title,
'link': link,
'content': content
})
cache.set('th_readability_' + str(trigger_id), data)
return data
def process_data(self, **kwargs):
"""
get the data from the cache
:param kwargs: contain keyword args : trigger_id at least
:type kwargs: dict
"""
kw = {
'cache_stack': 'th_readability',
'trigger_id': str(kwargs['trigger_id'])
}
return super(ServiceReadability, self).process_data(**kw)
def save_data(self, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param data: the data to check to be used and save
:type trigger_id: int
:type data: dict
:return: the status of the save statement
:rtype: boolean
"""
status = False
if self.token and 'link' in data and\
data['link'] is not None and\
len(data['link']) > 0:
# get the data of this trigger
trigger = Readability.objects.get(trigger_id=trigger_id)
bookmark_id = self.client.add_bookmark(url=data['link'])
if trigger.tag is not None and len(trigger.tag) > 0:
try:
self.client.add_tags_to_bookmark(
bookmark_id, tags=(trigger.tag.lower()))
sentence = str('readability {} created item id {}').format(
data['link'], bookmark_id)
logger.debug(sentence)
status = True
except Exception as e:
logger.critical(e)
status = False
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
"""
request_token = super(ServiceReadability, self).auth(request)
callback_url = self.callback_url(request, 'readability')
# URL to redirect user to, to authorize your app
auth_url_str = '%s?oauth_token=%s&oauth_callback=%s'
auth_url = auth_url_str % (self.AUTH_URL, request_token['oauth_token'],
callback_url)
return auth_url
def callback(self, request):
"""
Called from the Service when the user accept to activate it
"""
kwargs = {
'access_token': '',
'service': 'ServiceReadability',
'return': 'readability'
}
return super(ServiceReadability, self).callback(request, **kwargs)
class ServiceReadability(ServicesMgr):
def __init__(self, token=None):
base = 'https://www.readability.com'
self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base)
self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base)
self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base)
self.consumer_key = settings.TH_READABILITY['consumer_key']
self.consumer_secret = settings.TH_READABILITY['consumer_secret']
if token:
token_key, token_secret = token.split('#TH#')
self.client = ReaderClient(token_key, token_secret,
self.consumer_key, self.consumer_secret)
def read_data(self, token, trigger_id, date_triggered):
"""
get the data from the service
:param trigger_id: trigger ID to process
:param date_triggered: the date of the last trigger
:type trigger_id: int
:type date_triggered: datetime
:return: list of data found from the date_triggered filter
:rtype: list
"""
data = []
if token is not None:
bookmarks = self.client.get_bookmarks(
added_since=date_triggered).content
for bookmark in bookmarks.values():
for b in bookmark:
if 'article' in b:
title = ''
if 'title' in b['article']:
title = b['article']['title']
link = ''
if 'url' in b['article']:
link = b['article']['url']
content = ''
if 'excerpt' in b['article']:
content = b['article']['excerpt']
data.append(
{'title': title,
'link': link,
'content': content})
cache.set('th_readability_' + str(trigger_id), data)
return data
def process_data(self, trigger_id):
"""
get the data from the cache
:param trigger_id: trigger ID from which to save data
:type trigger_id: int
"""
cache_data = cache.get('th_readability_' + str(trigger_id))
return PublishingLimit.get_data('th_readability_',
cache_data,
trigger_id)
def save_data(self, token, trigger_id, **data):
"""
let's save the data
:param trigger_id: trigger ID from which to save data
:param **data: the data to check to be used and save
:type trigger_id: int
:type **data: dict
:return: the status of the save statement
:rtype: boolean
"""
status = False
if token and 'link' in data and\
data['link'] is not None and\
len(data['link']) > 0:
# get the data of this trigger
trigger = Readability.objects.get(trigger_id=trigger_id)
bookmark_id = self.client.add_bookmark(url=data['link'])
if trigger.tag is not None and len(trigger.tag) > 0:
try:
self.client.add_tags_to_bookmark(
bookmark_id, tags=(trigger.tag.lower()))
sentence = str('readability {} created item id {}').format(
data['link'], bookmark_id)
logger.debug(sentence)
status = True
except Exception as e:
logger.critical(e)
status = False
else:
sentence = "no token or link provided for trigger ID {} "
logger.critical(sentence.format(trigger_id))
status = False
return status
def auth(self, request):
"""
let's auth the user to the Service
"""
callback_url = 'http://%s%s' % (
request.get_host(), reverse('readability_callback'))
request_token = self.get_request_token()
# Save the request token information for later
request.session['oauth_token'] = request_token['oauth_token']
request.session['oauth_token_secret'] = request_token[
'oauth_token_secret']
# URL to redirect user to, to authorize your app
auth_url_str = '%s?oauth_token=%s&oauth_callback=%s'
auth_url = auth_url_str % (self.AUTH_URL,
request_token['oauth_token'],
callback_url)
return auth_url
def callback(self, request):
"""
Called from the Service when the user accept to activate it
"""
try:
# finally we save the user auth token
# As we already stored the object ServicesActivated
# from the UserServiceCreateView now we update the same
# object to the database so :
# 1) we get the previous objet
us = UserService.objects.get(
user=request.user,
name=ServicesActivated.objects.get(name='ServiceReadability'))
# 2) Readability API require to use 4 parms consumer_key/secret +
# token_key/secret instead of usually get just the token
# from an access_token request. So we need to add a string
# seperator for later use to slpit on this one
access_token = self.get_access_token(
request.session['oauth_token'],
request.session['oauth_token_secret'],
request.GET.get('oauth_verifier', '')
)
us.token = access_token.get('oauth_token') + \
'#TH#' + access_token.get('oauth_token_secret')
# 3) and save everything
us.save()
except KeyError:
return '/'
return 'readability/callback.html'
def get_request_token(self):
oauth = OAuth1Session(self.consumer_key,
client_secret=self.consumer_secret)
return oauth.fetch_request_token(self.REQ_TOKEN)
def get_access_token(self, oauth_token, oauth_token_secret,
oauth_verifier):
# Using OAuth1Session
oauth = OAuth1Session(self.consumer_key,
client_secret=self.consumer_secret,
resource_owner_key=oauth_token,
resource_owner_secret=oauth_token_secret,
verifier=oauth_verifier)
oauth_tokens = oauth.fetch_access_token(self.ACC_TOKEN)
return oauth_tokens
"since": since,
"sort": "oldest",
"count": 20
})
articles = res.json()['list']
if not articles:
since = res.json()['since']
with open('metadata.json', 'w') as f:
f.write(json.dumps({"since": since}))
exit(0)
articles = sorted(articles.values(), key=lambda x: x['sort_id']) # sort_id is provided by pocket to denote sort order
since = str(int(articles[-1]['time_updated']) + 1)
with open('metadata.json', 'w') as f:
f.write(json.dumps({"since": since}))
readability = ReaderClient(
token_key=config.READABILITY_USER_KEY,
token_secret=config.READABILITY_USER_SECRET,
consumer_key=config.READABILITY_CONSUMER_KEY,
consumer_secret=config.READABILITY_CONSUMER_SECRET
)
for a in articles:
readability.add_bookmark(a['resolved_url'])
class ReaderClientSingleBookmarkTest(TestCase):
"""Tests that only need one bookmark
"""
def setUp(self):
"""Get a client and add a bookmark
"""
token_pair = xauth(CONSUMER_KEY, CONSUMER_SECRET, USERNAME, PASSWORD)
self.token_key = token_pair[0]
self.token_secret = token_pair[1]
self.base_client = ReaderClient(CONSUMER_KEY, CONSUMER_SECRET,
self.token_key, self.token_secret)
self.url = 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/'
add_response = self.base_client.add_bookmark(self.url)
self.assertEqual(add_response.status, 202)
def tearDown(self):
"""Remove all added bookmarks.
"""
for bm in self.base_client.get_bookmarks().content['bookmarks']:
del_response = self.base_client.delete_bookmark(bm['id'])
self.assertEqual(del_response.status, 204)
def test_get_bookmark(self):
"""Test getting one bookmark by id
"""
# get a bookmark id
bm_response = self.base_client.get_bookmarks()
self.assertEqual(bm_response.status, 200)
self.assertTrue(len(bm_response.content['bookmarks']) > 0)
bookmark_id = bm_response.content['bookmarks'][0]['id']
bm_response = self.base_client.get_bookmark(bookmark_id)
self.assertEqual(bm_response.status, 200)
some_expected_keys = set(['article', 'user_id', 'favorite', 'id'])
received_keys = set(bm_response.content.keys())
self.assertTrue(some_expected_keys.issubset(received_keys))
def test_bookmark_tag_functionality(self):
"""Test adding, fetching and deleting tags on a bookmark.
"""
# get a bookmark id
bm_response = self.base_client.get_bookmarks()
self.assertEqual(bm_response.status, 200)
self.assertTrue(len(bm_response.content['bookmarks']) > 0)
bookmark_id = bm_response.content['bookmarks'][0]['id']
# test getting empty tags
tag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status, 200)
self.assertEqual(len(tag_response.content['tags']), 0)
# test adding tags
tags = ['tag', 'another tag']
tag_string = ', '.join(tags)
tag_add_response = \
self.base_client.add_tags_to_bookmark(bookmark_id, tag_string)
self.assertEqual(tag_add_response.status, 202)
# re-fetch tags. should have 2
retag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(retag_response.status, 200)
self.assertEqual(len(retag_response.content['tags']), 2)
for tag in retag_response.content['tags']:
self.assertTrue(tag['text'] in tags)
# test getting tags for user
user_tag_resp = self.base_client.get_tags()
self.assertEqual(user_tag_resp.status, 200)
self.assertEqual(len(user_tag_resp.content['tags']), 2)
for tag in user_tag_resp.content['tags']:
self.assertTrue(tag['text'] in tags)
# test getting a single tag while we're here
single_tag_resp = self.base_client.get_tag(tag['id'])
self.assertEqual(single_tag_resp.status, 200)
self.assertTrue('applied_count' in single_tag_resp.content)
self.assertTrue('id' in single_tag_resp.content)
self.assertTrue('text' in single_tag_resp.content)
# delete tags
for tag in retag_response.content['tags']:
del_response = self.base_client.delete_tag_from_bookmark(
bookmark_id, tag['id'])
self.assertEqual(del_response.status, 204)
# check that tags are gone
tag_response = self.base_client.get_bookmark_tags(bookmark_id)
self.assertEqual(tag_response.status, 200)
self.assertEqual(len(tag_response.content['tags']), 0)
