238 lines
10 KiB
Python
238 lines
10 KiB
Python
import json
|
|
import logging
|
|
from xml.etree import ElementTree as ET
|
|
from requests import request
|
|
import oauth2 as oauth
|
|
from urlparse import urlparse, urlunparse, urljoin
|
|
from urllib import urlencode
|
|
import httplib
|
|
from itertools import islice
|
|
from regluit.core import bookloader
|
|
import regluit.core
|
|
|
|
# import parse_qsl from cgi if it doesn't exist in urlparse
|
|
try:
|
|
from urlparse import parse_qsl
|
|
except:
|
|
from cgi import parse_qsl
|
|
|
|
from django.conf import settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# QUESTION: should the request_token, access_token be part of the state of the client?
|
|
# for simplicity for now, I will make them part of the state of GoodReadsClient
|
|
|
|
class GoodreadsException(Exception):
|
|
pass
|
|
|
|
class GoodreadsAuthorizationRequired(GoodreadsException):
|
|
pass
|
|
|
|
def filter_none(d):
|
|
d2 = {}
|
|
for (k,v) in d.iteritems():
|
|
if v is not None:
|
|
d2[k] = v
|
|
return d2
|
|
|
|
class GoodreadsClient(object):
|
|
|
|
url = 'http://www.goodreads.com'
|
|
request_token_url = urljoin(url,'oauth/request_token/')
|
|
authorize_url = urljoin(url, '/oauth/authorize/')
|
|
access_token_url = urljoin(url,'/oauth/access_token/')
|
|
|
|
def __init__(self,key,secret,access_token=None):
|
|
self.key = key
|
|
self.secret = secret
|
|
self.consumer = oauth.Consumer(key=self.key,
|
|
secret=self.secret)
|
|
|
|
self.client = oauth.Client(self.consumer)
|
|
self.unauth_client = None
|
|
|
|
if access_token is not None:
|
|
self.__load_access_token(access_token)
|
|
else:
|
|
self.access_token = None
|
|
|
|
@property
|
|
def is_authorized(self):
|
|
return (self.access_token is not None)
|
|
def begin_authorization (self, callback_url=None):
|
|
# get request token
|
|
response, content = self.client.request(GoodreadsClient.request_token_url, 'GET')
|
|
|
|
if int(response['status']) != httplib.OK:
|
|
raise Exception('Invalid response: %s' % response['status'])
|
|
|
|
request_token = dict(parse_qsl(content))
|
|
|
|
q = {'oauth_token':request_token['oauth_token']}
|
|
if callback_url is not None:
|
|
q['oauth_callback'] = callback_url
|
|
|
|
authorize_link = GoodreadsClient.authorize_url + '?' + urlencode(q)
|
|
return (authorize_link, request_token)
|
|
|
|
def complete_authorization(self, request_token):
|
|
token = oauth.Token(request_token['oauth_token'],
|
|
request_token['oauth_token_secret'])
|
|
|
|
self.client = oauth.Client(self.consumer, token)
|
|
response, content = self.client.request(GoodreadsClient.access_token_url, 'POST')
|
|
if int(response['status']) != httplib.OK:
|
|
raise Exception('Invalid response: %s' % response['status'])
|
|
|
|
access_token_raw = dict(parse_qsl(content))
|
|
self.__load_access_token(access_token_raw)
|
|
return access_token_raw
|
|
|
|
def __load_access_token(self, access_token):
|
|
token = oauth.Token(access_token['oauth_token'],
|
|
access_token['oauth_token_secret'])
|
|
self.access_token = token
|
|
self.client = oauth.Client(self.consumer, self.access_token)
|
|
|
|
def __clear_access_token(self):
|
|
self.access_token = None
|
|
self.consumer = oauth.Consumer(key=self.key,
|
|
secret=self.secret)
|
|
|
|
def auth_user(self):
|
|
if self.is_authorized:
|
|
response, content = self.client.request('%s/api/auth_user' % GoodreadsClient.url,
|
|
'GET')
|
|
if int(response['status']) != httplib.OK:
|
|
raise GoodreadsException('Error authenticating Goodreads user: %s ' % response)
|
|
else:
|
|
doc = ET.fromstring(content)
|
|
user = doc.find('user')
|
|
userid = user.get('id')
|
|
name = user.find('name').text
|
|
link = user.find('link').text
|
|
return({'userid':userid, 'name':name, 'link':link})
|
|
else:
|
|
raise GoodreadsAuthorizationRequired('Attempt to access auth_user without authorization.')
|
|
|
|
def add_book(self, book_id=871441, shelf_name='to-read'):
|
|
# the book is: "Moby-Dick: A Pop-Up Book" 871441
|
|
body = urlencode({'name': 'to-read', 'book_id': book_id})
|
|
headers = {'content-type': 'application/x-www-form-urlencoded'}
|
|
response, content = self.client.request('%s/shelf/add_to_shelf.xml' % GoodreadsClient.url,
|
|
'POST', body, headers)
|
|
# check that the new resource has been created
|
|
if int(response['status']) != httplib.CREATED:
|
|
raise GoodreadsException('Cannot create resource: %s' % response['status'])
|
|
logger.info('response,content: %s | %s ' % (response,content))
|
|
else:
|
|
return True
|
|
|
|
def review_list(self, user_id, shelf='all',page=1,sort=None,per_page=20,order='a',search=None,v=2):
|
|
"""have to account for situation in which we might need authorized access
|
|
for now: assume no need for auth
|
|
sort: available_for_swap, position, num_pages, votes, recommender, rating, shelves, format,
|
|
avg_rating, date_pub, isbn, comments, author, title, notes, cover, isbn13, review, date_pub_edition,
|
|
condition, asin, date_started, owned, random, date_read, year_pub, read_count, date_added,
|
|
date_purchased, num_ratings, purchase_location, date_updated (optional)
|
|
"""
|
|
|
|
path="/review/list/"
|
|
params = filter_none({'id':user_id,'shelf':shelf,'page':page,'sort':sort,'per_page':per_page,'order':order,
|
|
'search':search, 'v':2})
|
|
params["key"] = self.key
|
|
method = "GET"
|
|
|
|
request_url = urljoin(GoodreadsClient.url, path)
|
|
|
|
# loop through all the pages starting with page
|
|
|
|
more_pages = True
|
|
|
|
while (more_pages):
|
|
|
|
logger.info('request to review_list: %s %s', request_url, params)
|
|
r = request(method,request_url,params=params)
|
|
|
|
if r.status_code != httplib.OK:
|
|
raise GoodreadsException('Error in review_list: %s %s ' % (r.headers, r.content))
|
|
else:
|
|
#logger.info('headers, content: %s | %s ' % (r.headers,r.content))
|
|
doc = ET.fromstring(r.content)
|
|
# for the moment convert to a iterable of book data presented as dict -- one the way to paging through all results
|
|
reviews = doc.findall('reviews/review')
|
|
for review in reviews:
|
|
yield ({'id':review.find('id').text,
|
|
'book': {'id': review.find('book/id').text.strip(),
|
|
'isbn10':review.find('book/isbn').text,
|
|
'isbn13':review.find('book/isbn13').text,
|
|
'title':review.find('book/title').text.strip(),
|
|
'text_reviews_count':review.find('book/text_reviews_count').text.strip(),
|
|
'link':review.find('book/link').text.strip(),
|
|
'small_image_url':review.find('book/small_image_url').text.strip(),
|
|
'ratings_count':review.find('book/ratings_count').text.strip(),
|
|
'description':review.find('book/description').text.strip()}
|
|
})
|
|
if len(reviews) == 0:
|
|
more_pages = False
|
|
else:
|
|
params["page"] += 1
|
|
|
|
|
|
def shelves_list(self,user_id,page=1):
|
|
path = "/shelf/list.xml"
|
|
params = {'user_id':user_id, 'page':page}
|
|
params["key"] = self.key
|
|
method = "GET"
|
|
request_url = urljoin(GoodreadsClient.url, path)
|
|
|
|
r = request(method,request_url,params=params)
|
|
|
|
if r.status_code != httplib.OK:
|
|
logger.info('headers, content: %s | %s ' % (r.headers,r.content))
|
|
raise GoodreadsException('Error in shelves_list: %s %s ' % (r.headers, r.content))
|
|
else:
|
|
logger.info('headers, content: %s | %s ' % (r.headers,r.content))
|
|
doc = ET.fromstring(r.content)
|
|
shelves = doc.find('shelves')
|
|
# do a simple parsing to a dictionary
|
|
|
|
d = dict( [ (k,int(shelves.attrib[k])) for k in shelves.attrib ] )
|
|
d["user_shelves"] = [{'name':shelf.find('name').text,
|
|
'book_count':int(shelf.find('book_count').text),
|
|
'description':shelf.find('description').text if shelf.find('description').attrib['nil'] != 'true' else None,
|
|
'exclusive_flag':shelf.find('exclusive_flag').text} \
|
|
for shelf in shelves.findall('user_shelf')]
|
|
|
|
d["total_book_count"] = sum([shelf['book_count'] if shelf['exclusive_flag'] == 'true' else 0 for shelf in d["user_shelves"]])
|
|
return d
|
|
|
|
|
|
def load_goodreads_shelf_into_wishlist(user, shelf_name='all', goodreads_user_id=None, max_books=None):
|
|
"""
|
|
Load a specified Goodreads shelf (by default: all the books from the Goodreads account associated with user)
|
|
"""
|
|
|
|
gc = GoodreadsClient(key=settings.GOODREADS_API_KEY, secret=settings.GOODREADS_API_SECRET)
|
|
|
|
if goodreads_user_id is None:
|
|
if user.profile.goodreads_user_id is not None:
|
|
goodreads_user_id = user.profile.goodreads_user_id
|
|
else:
|
|
raise Exception("No Goodreads user_id is associated with user.")
|
|
|
|
for (i, review) in enumerate(islice(gc.review_list(goodreads_user_id,shelf=shelf_name),max_books)):
|
|
isbn = review["book"]["isbn10"] if review["book"]["isbn10"] is not None else review["book"]["isbn13"]
|
|
logger.info("%d %s %s %s ", i, review["book"]["title"], isbn, review["book"]["small_image_url"])
|
|
try:
|
|
edition = bookloader.add_by_isbn(isbn)
|
|
# let's not trigger too much traffic to Google books for now
|
|
# regluit.core.tasks.add_related.delay(isbn)
|
|
user.wishlist.works.add(edition.work)
|
|
logger.info("Work with isbn %s added to wishlist.", isbn)
|
|
except Exception, e:
|
|
logger.info ("error adding ISBN %s: %s", isbn, e)
|
|
|
|
|