def _error_handle(self, e):
if e.code == 400:
err = e.read()
err = json.loads(err)
if err['error'].get('error_subcode') == 463:
self._token_expired()
else:
self._token_invalid()
elif e.code == 403:
err = e.read()
err = json.loads(err)
self._permission_error()
def post_object(self, path, data=None, file_data=None):
if not 'access_token' in data and self.access_token:
data['access_token'] = self.access_token
url = "https://graph.facebook.com/" + self.api_version + "/%s" % str(path)
if not data:
data = {}
try:
if file_data:
form = MultiPartForm()
for key, val in iteritems(data):
form.add_field(key, val)
for key, val in file_data.iteritmes():
form.add_file(key, val['name'], val['source'], mimetype=val.get('mimetype'))
request = Request(url)
body = str(form)
request.add_header('Content-type', form.get_content_type())
request.add_header('Content-length', len(body))
request.data =body
ret = urlopen(request).read()
else:
ret = urlopen(url, urlencode(data)).read()
return json.loads(ret)
except HTTPError as e:
self._error_handle(e)
return {}
def get_object(self, path, **kwargs):
if not 'access_token' in kwargs and self.access_token:
kwargs['access_token'] = self.access_token
url = "https://graph.facebook.com/" + self.api_version + "/%s?%s" % (str(path), urlencode(kwargs))
try:
ret = urlopen(url).read()
return json.loads(ret)
except HTTPError as e:
self._error_handle(e)
def get_access_token(self, grant_type="password", email="*****@*****.**", password="******", client=None):
if grant_type == 'password':
if not client:
client = create_client_and_service()
response = self.client.post(reverse("OAuth2TokenView"), {'grant_type': 'password', 'client_id': client.client_id,
'client_secret': client.client_secret, 'username': email,
'password': password})
return json.loads(response.content)['access_token']
elif grant_type == 'authorization_code':
#Warning can't test with Macro
if not client:
client = create_client_and_service()
sign_in(self, email, password)
urllib2.urlopen(reverse("OAuth2TokenView"),)
response = self.client.post(reverse("OAuth2TokenView"), {'grant_type': 'password', 'client_id': client.client_id,
'client_secret': client.client_secret, 'username': email,
'password': password})
return json.loads(response.content)['access_token']
def pre_create(self, data, files, acceptable, required, exclude, request, request_kwargs, or_get):
if request.oauth2_user.pk:
data['from'] = user_public_resource(request.oauth2_user.pk)
data['client'] = request.oauth2_authorization_info.client_pk
if 'link' in data:
link_data = data['link']
if link_data[0] == '{':
link_data = json.loads(link_data)
else:
link_data = {'url': link_data}
data['link'] = link_public_resource.create(link_data)
return data, files
def data_with_google(self, access_token):
try:
ret = urlopen("https://www.googleapis.com/plus/v1/people/me?" +
urlencode({'access_token': access_token})).read()
email_ret = urlopen("https://www.googleapis.com/oauth2/v3/userinfo?" +
urlencode({'access_token': access_token, 'fields': 'email'})).read()
email = json.loads(email_ret)['email']
user_data = json.loads(ret)
if not user_data['isPlusUser'] or not email:
return None, None
google_id = user_data['id']
name = user_data['displayName']
try:
locale = user_data['language']
except KeyError:
locale = "en"
gender = user_data.get('gender', 'unknown')
if gender == 'male':
gender = 'M'
elif gender == 'female':
gender = 'F'
# location = user_data.get('currentLocation','')
photo_url = user_data.get('image', {'url': None}).get('url')
if photo_url:
img_temp = NamedTemporaryFile()
img_temp.write(urlopen(photo_url).read())
img_temp.flush()
img_temp.seek(0)
photo = File(img_temp)
else:
photo = None
data = {'name': name, 'locale': locale, 'email': email, 'gender': gender, 'google_id': google_id}
if photo:
files = {'photo': photo}
else:
files = None
return data, files
except HTTPError:
return None, None
def user_from_google_access_token(access_token):
try:
ret = urlopen("https://www.googleapis.com/plus/v1/people/me?" +
urlencode({'access_token': access_token})).read()
except HTTPError:
return None
user_data = json.loads(ret)
try:
user_google = UserGoogle.objects.get(google_id=user_data['id'])
user_google.save()
return user_google.user
except UserGoogle.DoesNotExist:
return None
def test_feed_post(self):
join(self)
access_token = get_access_token(self)
response = self._create_feed("test_feed", access_token)
self.assertEqual(response.status_code, 201)
feed_id = json.loads(response.content)['id']
sign_in(self)
response = self.client.get(reverse("FeedTokenApiView", kwargs={'pk': feed_id}))
# print response
feed_token = json.loads(response.content)['feed_token']
response = self.client.post(reverse("FeedPostsApiView", kwargs={'pk': feed_id}),
{'content': 'test', 'token': feed_token})
# print response.content
post_id = json.loads(response.content)['id']
response = self.client.delete(reverse("PostApiView", kwargs={'pk': post_id}),
{'access_token': access_token})
response = self.client.post(reverse("FeedPostsApiView", kwargs={'pk': feed_id}),
{'content': 'test', 'link': json.dumps({'url': 'http://www.daum.net', 'name': 'asdasd'})
,'token': feed_token})
print response
def to_python(self, value):
if isinstance(value, string_types):
try:
value = json.loads(value)
except ValueError:
return None
resource_name = value['_resource_name'] if isinstance(value, dict) and '_resource_name' in value else None
for resource in self.available_resources:
if isinstance(value, resource._meta.resource_instance_cls):
return value
if resource_name and resource_name == resource._meta.name:
_pk = value.get('_pk')
ret = resource(_pk)
# getattr(ret, '_instance')
return ret
return None
def load_signed_request(self, signed_request):
"""Load the user state from a signed_request value"""
try:
sig, payload = signed_request.split(u'.', 1)
sig = self.base64_url_decode(sig)
data = json.loads(self.base64_url_decode(payload))
expected_sig = hmac.new(
self.app_secret, msg=payload, digestmod=hashlib.sha256).digest()
# allow the signed_request to function for upto 1 day
if sig == expected_sig and \
data[u'issued_at'] > (time.time() - 86400):
self.signed_request = data
self.user_id = data.get(u'user_id')
self.access_token = data.get(u'oauth_token')
except ValueError:
pass # ignore if can't split on dot
def create_from_db(self, data=None, files=None, or_get=False):
kwargs = {}
# ref_kwargs = {}
_db_field_map = self._meta.document._db_field_map
for each_field in self._meta.document._fields.items():
field_name = _db_field_map.get(each_field[0])
if not field_name:
continue
data_source = None
if data and field_name in data:
data_source = data
elif files and field_name in files:
data_source = files
if data_source:
from django_town.mongoengine_extension.fields.extra import LocalStorageFileField
current_field = each_field[1]
if isinstance(current_field, (SortedListField, ListField)) and hasattr(data_source, 'getlist'):
kwargs[field_name] = data_source.getlist(field_name)
elif isinstance(current_field, EmbeddedDocumentField) and \
not isinstance(data_source.get(field_name), EmbeddedDocument):
kwargs[field_name] = json.loads(data_source.get(field_name))
elif isinstance(current_field, PointField):
latlng = data_source.get(field_name)
if latlng:
latlng = data_source.get(field_name).split(',')
kwargs[field_name] = [float(latlng[1]), float(latlng[0])]
# elif isinstance(current_field, LocalStorageFileField):
# file_fields[field_name] = data_source.get(field_name)
elif isinstance(current_field, DynamicResourceField):
kwargs[field_name] = data_source.get(field_name)
kwargs[field_name + "_type"] = kwargs[field_name]._manager._meta.name
elif isinstance(current_field, DateTimeField):
kwargs[field_name] = datetime.datetime.fromtimestamp(float(data_source.get(field_name)))
# elif isinstance(current_field, ReferenceField):
# ref_kwargs[field_name] = data_source.get(field_name)
else:
kwargs[field_name] = data_source.get(field_name)
# print self.document._fields, self.document._db_field_map
# print kwargs
try:
if or_get:
_instance, created = self._meta.document.objects.get_or_create(**kwargs)
else:
created = False
_instance = self._meta.document(**kwargs).save()
# for k, v in file_fields.iteritems():
# if v:
# getattr(_instance, k).save(generate_random_from_vschar_set(length=30), v)
except ValueError:
import traceback
traceback.print_exc()
raise RestBadRequest()
except NotUniqueError:
raise RestDuplicate()
except ValidationError as e:
import traceback
traceback.print_exc()
raise RestFormInvalid(e.errors.keys()[0])
return _instance, created
