def test_google_reader_import(self):
self.client.login(username="******", password="******")
user = User.objects.get(username="******")
f = open(os.path.join(os.path.dirname(__file__), "fixtures/google_reader.xml"))
xml = f.read()
f.close()
reader_importer = GoogleReaderImporter(user, xml=xml)
reader_importer.import_feeds()
subs = UserSubscription.objects.filter(user=user)
self.assertEquals(subs.count(), 66)
usf = UserSubscriptionFolders.objects.get(user=user)
print json.decode(usf.folders)
self.assertEquals(
json.decode(usf.folders),
[
{u"Tech": [4, 5, 2, 9, 10, 12, 13, 14, 20, 23, 24, 26, 27, 28, 31, 32, 33, 34, 48, 49, 62, 64]},
1,
2,
3,
6,
{u"Blogs": [1, 3, 25, 29, 30, 39, 40, 41, 50, 55, 57, 58, 59, 60, 66]},
{u"Blogs \u2014 Tumblrs": [5, 21, 37, 38, 53, 54, 63, 65]},
{u"Blogs \u2014 The Bloglets": [6, 16, 22, 35, 51, 56]},
{u"New York": [7, 8, 17, 18, 19, 36, 45, 47, 52, 61]},
{u"Cooking": [11, 15, 42, 43, 46]},
44,
],
)
def import_starred_stories_from_google_reader(request):
code = 0
feed_count = 0
starred_count = 0
delayed = False
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
try:
starred_count = reader_importer.try_import_starred_stories()
except TimeoutError:
ProcessReaderStarredImport.delay(request.user.pk)
feed_count = UserSubscription.objects.filter(
user=request.user).count()
logging.user(
request,
"~FR~SBGoogle Reader starred stories import took too long, found %s feeds, %s stories. Tasking..."
% (feed_count, starred_count))
delayed = True
code = 2
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code,
delayed=delayed,
feed_count=feed_count,
starred_count=starred_count)
def import_from_google_reader(request):
code = 0
feed_count = 0
starred_count = 0
delayed = False
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
auto_active = bool(request.REQUEST.get('auto_active') or False)
try:
code = reader_importer.try_import_feeds(auto_active=auto_active)
except TimeoutError:
ProcessReaderImport.delay(request.user.pk, auto_active=auto_active)
feed_count = UserSubscription.objects.filter(user=request.user).count()
logging.user(request, "~FR~SBGoogle Reader import took too long, found %s feeds. Tasking..." % feed_count)
delayed = True
code = 2
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code, delayed=delayed, feed_count=feed_count, starred_count=starred_count)
def test_google_reader_import(self):
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
f = open(
os.path.join(os.path.dirname(__file__),
'fixtures/google_reader.xml'))
xml = f.read()
f.close()
reader_importer = GoogleReaderImporter(user, xml=xml)
reader_importer.import_feeds()
subs = UserSubscription.objects.filter(user=user)
self.assertEquals(subs.count(), 66)
usf = UserSubscriptionFolders.objects.get(user=user)
# print json.decode(usf.folders)
self.assertEquals(json.decode(usf.folders), [{
u'Tech': [
4, 5, 2, 9, 10, 12, 13, 14, 20, 23, 24, 26, 27, 28, 31, 32, 33,
34, 48, 49, 62, 64
]
}, 1, 2, 3, 6, {
u'Blogs':
[1, 3, 25, 29, 30, 39, 40, 41, 50, 55, 57, 58, 59, 60, 66]
}, {
u'Blogs \u2014 Tumblrs': [5, 21, 37, 38, 53, 54, 63, 65]
}, {
u'Blogs \u2014 The Bloglets': [6, 16, 22, 35, 51, 56]
}, {
u'New York': [7, 8, 17, 18, 19, 36, 45, 47, 52, 61]
}, {
u'Cooking': [11, 15, 42, 43, 46]
}, 44])
def import_from_google_reader(request):
code = 0
feed_count = 0
starred_count = 0
delayed = False
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
auto_active = bool(request.REQUEST.get('auto_active') or False)
try:
code = reader_importer.try_import_feeds(auto_active=auto_active)
except TimeoutError:
ProcessReaderImport.delay(request.user.pk, auto_active=auto_active)
feed_count = UserSubscription.objects.filter(user=request.user).count()
logging.user(request, "~FR~SBGoogle Reader import took too long, found %s feeds. Tasking..." % feed_count)
delayed = True
code = 2
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code, delayed=delayed, feed_count=feed_count, starred_count=starred_count)
def run(self, user_id):
user = User.objects.get(pk=user_id)
logging.user(user, "~FR~SBGoogle Reader starred stories import (task) starting...")
importer = GoogleReaderImporter(user=user)
importer.import_starred_items(count=1000)
feed_count = UserSubscription.objects.filter(user=user).count()
starred_count = MStarredStory.objects.filter(user_id=user.pk).count()
user.profile.send_import_reader_starred_finished_email(feed_count, starred_count)
logging.user(user, "~FR~SBGoogle Reader starred stories import (task): ~SK%s~SN~SB~FR feeds, ~SK%s~SN~SB~FR starred stories" % (feed_count, starred_count))
def run(self, user_id, auto_active=False):
user = User.objects.get(pk=user_id)
logging.user(user, "~FR~SBGoogle Reader import (task) starting...")
importer = GoogleReaderImporter(user=user)
importer.import_feeds(auto_active=auto_active)
importer.import_starred_items(count=10)
feed_count = UserSubscription.objects.filter(user=user).count()
user.profile.send_import_reader_finished_email(feed_count)
logging.user(user, "~FR~SBGoogle Reader import (task): ~SK%s~SN~SB~FR feeds" % (feed_count))
def import_from_google_reader(request):
code = 0
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
reader_importer.import_feeds()
reader_importer.import_starred_items()
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
return dict(code=code)
def handle(self, *args, **options):
if options['daemonize']:
daemonize()
settings.LOG_TO_STREAM = True
try:
user = User.objects.get(username__icontains=options['username'])
except User.MultipleObjectsReturned:
user = User.objects.get(username=options['username'])
reader_importer = GoogleReaderImporter(user)
reader_importer.import_starred_items(count=options['count'])
def handle(self, *args, **options):
if options['daemonize']:
daemonize()
settings.LOG_TO_STREAM = True
try:
user = User.objects.get(username__icontains=options['username'])
except User.MultipleObjectsReturned:
user = User.objects.get(username=options['username'])
reader_importer = GoogleReaderImporter(user)
reader_importer.import_starred_items(count=options['count'])
def reader_authorize(request):
ip = request.META.get('HTTP_X_FORWARDED_FOR', None) or request.META.get(
'REMOTE_ADDR', "")
reader_importer = GoogleReaderImporter(request.user)
if reader_importer.test():
logging.user(
request, "~BB~FW~SBSkipping Google Reader import, already tokened")
return render_to_response('social/social_connect.xhtml', {},
context_instance=RequestContext(request))
domain = Site.objects.get_current().domain
STEP2_URI = "http://%s%s" % (
(domain + '.com') if not domain.endswith('.com') else domain,
reverse('google-reader-callback'),
)
FLOW = OAuth2WebServerFlow(
client_id=settings.GOOGLE_OAUTH2_CLIENTID,
client_secret=settings.GOOGLE_OAUTH2_SECRET,
scope="http://www.google.com/reader/api",
redirect_uri=STEP2_URI,
user_agent='PyTune Pro, www.pytune.com',
approval_prompt="force",
)
logging.user(
request, "~BB~FW~SBAuthorize Google Reader import - %s" %
(request.META.get('HTTP_X_FORWARDED_FOR', None)
or request.META.get('REMOTE_ADDR', ""), ))
authorize_url = FLOW.step1_get_authorize_url(redirect_uri=STEP2_URI)
response = render_to_response('social/social_connect.xhtml', {
'next': authorize_url,
},
context_instance=RequestContext(request))
# Save request token and delete old tokens
auth_token_dict = dict()
if request.user.is_authenticated():
OAuthToken.objects.filter(user=request.user).delete()
auth_token_dict['user'] = request.user
else:
OAuthToken.objects.filter(
session_id=request.session.session_key).delete()
OAuthToken.objects.filter(remote_ip=ip).delete()
auth_token_dict['uuid'] = str(uuid.uuid4())
auth_token_dict['session_id'] = request.session.session_key
auth_token_dict['remote_ip'] = ip
OAuthToken.objects.create(**auth_token_dict)
response.set_cookie('pytune_reader_uuid', str(uuid.uuid4()))
return response
def test_google_reader_import(self):
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
f = open(os.path.join(os.path.dirname(__file__), 'fixtures/google_reader.xml'))
xml = f.read()
f.close()
reader_importer = GoogleReaderImporter(user, xml=xml)
reader_importer.import_feeds()
subs = UserSubscription.objects.filter(user=user)
self.assertEquals(subs.count(), 66)
usf = UserSubscriptionFolders.objects.get(user=user)
self.assertEquals(json.decode(usf.folders), [{'Blogs \xe2\x80\x94 The Bloglets': [6, 16, 22, 35, 51, 56]}, {'Blogs': [1, 3, 25, 29, 30, 39, 40, 41, 50, 55, 57, 58, 59, 60, 66]}, {'Cooking': [11, 15, 42, 43, 46]}, {'New York': [7, 8, 17, 18, 19, 36, 45, 47, 52, 61]}, {'Tech': [2, 4, 9, 10, 12, 13, 14, 20, 23, 24, 26, 27, 28, 31, 32, 33, 34, 48, 49, 62, 64]}, {'Blogs \xe2\x80\x94 Tumblrs': [5, 21, 37, 38, 53, 54, 63, 65]}, 44])
def reader_authorize(request):
ip = request.META.get("HTTP_X_REAL_IP", None) or request.META.get("REMOTE_ADDR", "")
reader_importer = GoogleReaderImporter(request.user)
if reader_importer.test():
logging.user(request, "~BB~FW~SBSkipping Google Reader import, already tokened")
return render_to_response("social/social_connect.xhtml", {}, context_instance=RequestContext(request))
domain = Site.objects.get_current().domain
STEP2_URI = "http://%s%s" % (
(domain + ".com") if not domain.endswith(".com") else domain,
reverse("google-reader-callback"),
)
FLOW = OAuth2WebServerFlow(
client_id=settings.GOOGLE_OAUTH2_CLIENTID,
client_secret=settings.GOOGLE_OAUTH2_SECRET,
scope="http://www.google.com/reader/api",
redirect_uri=STEP2_URI,
user_agent="NewsBlur Pro, www.newsblur.com",
approval_prompt="force",
)
logging.user(
request,
"~BB~FW~SBAuthorize Google Reader import - %s"
% (request.META.get("HTTP_X_REAL_IP", None) or request.META.get("REMOTE_ADDR", ""),),
)
authorize_url = FLOW.step1_get_authorize_url(redirect_uri=STEP2_URI)
response = render_to_response(
"social/social_connect.xhtml", {"next": authorize_url}, context_instance=RequestContext(request)
)
# Save request token and delete old tokens
auth_token_dict = dict()
if request.user.is_authenticated():
OAuthToken.objects.filter(user=request.user).delete()
auth_token_dict["user"] = request.user
else:
OAuthToken.objects.filter(session_id=request.session.session_key).delete()
OAuthToken.objects.filter(remote_ip=ip).delete()
auth_token_dict["uuid"] = str(uuid.uuid4())
auth_token_dict["session_id"] = request.session.session_key
auth_token_dict["remote_ip"] = ip
OAuthToken.objects.create(**auth_token_dict)
response.set_cookie("newsblur_reader_uuid", str(uuid.uuid4()))
return response
def run(self, user_id):
user = User.objects.get(pk=user_id)
logging.user(
user,
"~FR~SBGoogle Reader starred stories import (task) starting...")
importer = GoogleReaderImporter(user=user)
importer.import_starred_items(count=1000)
feed_count = UserSubscription.objects.filter(user=user).count()
starred_count = MStarredStory.objects.filter(user_id=user.pk).count()
user.profile.send_import_reader_starred_finished_email(
feed_count, starred_count)
logging.user(
user,
"~FR~SBGoogle Reader starred stories import (task): ~SK%s~SN~SB~FR feeds, ~SK%s~SN~SB~FR starred stories"
% (feed_count, starred_count))
def reader_authorize(request):
ip = request.META.get('HTTP_X_FORWARDED_FOR', None) or request.META.get('REMOTE_ADDR', "")
reader_importer = GoogleReaderImporter(request.user)
if reader_importer.test():
logging.user(request, "~BB~FW~SBSkipping Google Reader import, already tokened")
return render_to_response('social/social_connect.xhtml', {
}, context_instance=RequestContext(request))
domain = Site.objects.get_current().domain
STEP2_URI = "http://%s%s" % (
(domain + '.com') if not domain.endswith('.com') else domain,
reverse('google-reader-callback'),
)
FLOW = OAuth2WebServerFlow(
client_id=settings.GOOGLE_OAUTH2_CLIENTID,
client_secret=settings.GOOGLE_OAUTH2_SECRET,
scope="http://www.google.com/reader/api",
redirect_uri=STEP2_URI,
user_agent='PyTune Pro, www.pytune.com',
approval_prompt="force",
)
logging.user(request, "~BB~FW~SBAuthorize Google Reader import - %s" % (
request.META.get('HTTP_X_FORWARDED_FOR', None) or request.META.get('REMOTE_ADDR', ""),
))
authorize_url = FLOW.step1_get_authorize_url(redirect_uri=STEP2_URI)
response = render_to_response('social/social_connect.xhtml', {
'next': authorize_url,
}, context_instance=RequestContext(request))
# Save request token and delete old tokens
auth_token_dict = dict()
if request.user.is_authenticated():
OAuthToken.objects.filter(user=request.user).delete()
auth_token_dict['user'] = request.user
else:
OAuthToken.objects.filter(session_id=request.session.session_key).delete()
OAuthToken.objects.filter(remote_ip=ip).delete()
auth_token_dict['uuid'] = str(uuid.uuid4())
auth_token_dict['session_id'] = request.session.session_key
auth_token_dict['remote_ip'] = ip
OAuthToken.objects.create(**auth_token_dict)
response.set_cookie('pytune_reader_uuid', str(uuid.uuid4()))
return response
def import_from_google_reader(request):
code = 0
feed_count = 0
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
auto_active = bool(request.REQUEST.get('auto_active') or False)
try:
reader_importer.import_feeds(auto_active=auto_active)
reader_importer.import_starred_items()
except AssertionError:
code = -1
else:
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code, feed_count=feed_count)
def import_starred_stories_from_google_reader(request):
code = 0
feed_count = 0
starred_count = 0
delayed = False
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
try:
starred_count = reader_importer.try_import_starred_stories()
except TimeoutError:
ProcessReaderStarredImport.delay(request.user.pk)
feed_count = UserSubscription.objects.filter(user=request.user).count()
logging.user(request, "~FR~SBGoogle Reader starred stories import took too long, found %s feeds, %s stories. Tasking..." % (feed_count, starred_count))
delayed = True
code = 2
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code, delayed=delayed, feed_count=feed_count, starred_count=starred_count)
def import_from_google_reader(request):
scope = "http://www.google.com/reader/api"
sub_url = "%s/0/subscription/list" % scope
code = 0
if request.user.is_authenticated():
user_tokens = OAuthToken.objects.filter(user=request.user)
if user_tokens.count():
user_token = user_tokens[0]
consumer = oauth.Consumer(settings.OAUTH_KEY, settings.OAUTH_SECRET)
token = oauth.Token(user_token.access_token, user_token.access_token_secret)
client = oauth.Client(consumer, token)
resp, content = client.request(sub_url, 'GET')
reader_importer = GoogleReaderImporter(content, request.user)
reader_importer.process()
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
return dict(code=code)
def import_from_google_reader(request):
scope = "http://www.google.com/reader/api"
sub_url = "%s/0/subscription/list" % scope
code = 0
if request.user.is_authenticated():
user_tokens = OAuthToken.objects.filter(user=request.user)
if user_tokens.count():
user_token = user_tokens[0]
consumer = oauth.Consumer(settings.OAUTH_KEY,
settings.OAUTH_SECRET)
token = oauth.Token(user_token.access_token,
user_token.access_token_secret)
client = oauth.Client(consumer, token)
resp, content = client.request(sub_url, 'GET')
reader_importer = GoogleReaderImporter(content, request.user)
reader_importer.process()
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
return dict(code=code)
def run(self, user_id, auto_active=False):
user = User.objects.get(pk=user_id)
logging.user(user, "~FR~SBGoogle Reader import (task) starting...")
importer = GoogleReaderImporter(user=user)
importer.import_feeds(auto_active=auto_active)
importer.import_starred_items(count=10)
feed_count = UserSubscription.objects.filter(user=user).count()
user.profile.send_import_reader_finished_email(feed_count)
logging.user(
user, "~FR~SBGoogle Reader import (task): ~SK%s~SN~SB~FR feeds" %
(feed_count))
def import_from_google_reader(request):
code = 0
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
try:
reader_importer.import_feeds()
reader_importer.import_starred_items()
except AssertionError:
code = -1
else:
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
return dict(code=code)
def import_from_google_reader(request):
code = 0
feed_count = 0
if request.user.is_authenticated():
reader_importer = GoogleReaderImporter(request.user)
auto_active = bool(request.REQUEST.get('auto_active') or False)
try:
reader_importer.import_feeds(auto_active=auto_active)
reader_importer.import_starred_items()
except AssertionError:
code = -1
else:
code = 1
if 'import_from_google_reader' in request.session:
del request.session['import_from_google_reader']
feed_count = UserSubscription.objects.filter(user=request.user).count()
return dict(code=code, feed_count=feed_count)
def import_reader_starred_items(self, count=20):
importer = GoogleReaderImporter(self.user)
importer.import_starred_items(count=count)
def import_reader_starred_items(self, count=20):
importer = GoogleReaderImporter(self.user)
importer.import_starred_items(count=count)
