def upload_to_facebook(img_path):
# Takes image path
config = ConfigParser()
config.read('auth.ini')
app_key = config.get('facebook_credentials', 'app_key')
app_key_secret = config.get('facebook_credentials', 'app_key_secret')
user_access_token = config.get('facebook_credentials', 'user_access_token')
page_id = config.get('facebook_credentials', 'page_id')
graph = GraphAPI(user_access_token)
resp = graph.get('me/accounts')
page_access_token = None
for page in resp['data']:
if page['id'] == page_id:
page_access_token = page['access_token']
graph = GraphAPI(page_access_token)
graph = GraphAPI(access_token=access_token, version="3.1")
print('Uploading photo...')
image = open(img_path, 'rb')
graph.put_photo(image, message='Test caption')
def validate(self):
rv = Form.validate(self)
if not rv:
return False
#validate facebook credentials if FB auth is selected
if self.auth_fb.data and AUTH_TYPE_SOCIAL:
fb_appid = self.fb_appid.data or current_app.config['FB_APP_ID']
fb_app_secret = self.fb_app_secret.data or current_app.config[
'FB_APP_SECRET']
try:
access_token = GraphAPI().get_app_access_token(
fb_appid, fb_app_secret)
except:
current_app.logger.exception(
'Exception while trying to get access_token with APP ID:%s Secret:%s'
% (fb_appid, fb_app_secret))
self.fb_app_secret.errors.append(
'Incorrect APP ID or secret configured')
return False
if (self.auth_fb_like.data
or self.auth_fb_post.data) and self.fb_page.data == '':
self.fb_page.errors.append(
'Facebook Social action configured without Page URL')
return False
if self.auth_fb_post.data and self.fb_page.data:
try:
page = GraphAPI(access_token).get_object(self.fb_page.data,
fields='location')
except:
current_app.logger.exception(
'Exception while trying to get page:%s for location' %
(self.fb_page.data))
self.fb_page.errors.append('Incorrect page URL specified')
return False
if not page.get('location'):
self.fb_page.errors.append(
'Given FB Page does not supports checkin')
return False
if self.enable_session_limit.data:
try:
int(self.daily_data_limit.data)
except:
self.daily_data_limit.errors.append(
'Please enter valid value for Session Limit')
return False
try:
int(self.monthly_data_limit.data)
except:
self.monthly_data_limit.errors.append(
'Please enter valid value for Monthly Limit')
return False
try:
int(self.session_timelimit.data)
except:
self.session_timelimit.errors.append(
'Please enter valid value for Session time')
return False
return True
def get_current_user():
"""Set g.user to the currently logged in user.
Called before each request, get_current_user sets the global g.user
variable to the currently logged in user. A currently logged in user is
determined by seeing if it exists in Flask's session dictionary.
If it is the first time the user is logging into this application it will
create the user and insert it into the database. If the user is not logged
in, None will be set to g.user.
"""
# Set the user in the session dictionary as a global g.user and bail out
# of this function early.
if session.get('user'):
g.user = session.get('user')
return
# Attempt to get the short term access token for the current user.
result = get_user_from_cookie(cookies=request.cookies, app_id=FB_APP_ID,
app_secret=FB_APP_SECRET)
# If there is no result, we assume the user is not logged in.
if result:
graph = GraphAPI(result['access_token'])
profile = graph.get_object('me')
if 'link' not in profile:
# Check to see if this user is already in our database.
profile['link'] = ""
user = User(result['uid'], name=profile['name'], profile_url=profile['link'],
access_token=result['access_token'])
user = user.check_user()
if not user:
# Not an existing user so get info
graph = GraphAPI(result['access_token'])
profile = graph.get_object('me')
if 'link' not in profile:
profile['link'] = ""
# Create the user and insert it into the database '
user = User(result['uid'], profile['name'], profile['link'], result['access_token'])
user.create_user()
elif user['access_token'] != result['access_token']:
# If an existing user, update the access token
user['access_token'] = result['access_token']
# Add the user to the current session
session['user'] = dict(name=profile['name'], profile_url=profile['link'],
id=result['uid'], access_token=result['access_token'])
# Commit changes to the database and set the user as a global g.user
g.user = session.get('user', None)
def post_to_fb():
if current_user.fb_token:
current_app.logger.debug('User {} already has token: {}'.format(
current_user.username, current_user.fb_token))
user_graph = GraphAPI(current_user.fb_token, version='2.11')
elif request.args.get('code'):
current_app.logger.debug('Fetching Facebook token for user {}'.format(
current_user.username))
current_app.logger.debug(request.args)
result = get_user_from_cookie(
cookies=request.cookies,
app_id=current_app.config['FB_APP_ID'],
app_secret=current_app.config['FB_APP_SECRET'])
if result:
user_graph = GraphAPI(result['access_token'])
else:
flash(
"Ekki tókst að senda póst á Facebook! Ertu búinn að logga þig inn?"
)
return redirect(url_for('admin.news_index'))
else:
current_app.logger.error(
"Not able to send post to Facebook for user {}".format(
current_user.username))
current_app.logger.error(request.args)
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
accounts = user_graph.get_object('me/accounts')
for d in accounts['data']:
if d['id'] == current_app.config['FB_PAGE_ID']:
page_access_token = d['access_token']
break
else:
current_app.logger.error('Not able to find the page_access_token')
current_app.logger.error(accounts)
current_app.logger.error(current_app.config['FB_PAGE_ID'])
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
lnk = session.pop('link', None)
msg = session.pop('body', None)
page_graph = GraphAPI(page_access_token, version='2.11')
page_graph.put_object(parent_object=current_app.config['FB_PAGE_ID'],
connection_name='feed',
message=msg,
link=lnk)
return redirect(url_for('admin.news_index'))
def facebook_callback(request):
graph = GraphAPI()
# Получаем Long Term Access Token
if request.GET.get('code'):
access_token = graph.get_access_token_from_code(
request.GET.get('code'), host_url('autoposting-facebook-callback'),
settings.FACEBOOK_APP_ID, settings.FACEBOOK_APP_SECRET)
else:
access_token = graph.get_app_access_token(settings.FACEBOOK_APP_ID,
settings.FACEBOOK_APP_SECRET)
graph.access_token = access_token['access_token']
access_token_response = graph.extend_access_token(
settings.FACEBOOK_APP_ID, settings.FACEBOOK_APP_SECRET)
access_token = access_token_response['access_token']
access_token_expires_at = datetime.datetime.now() + datetime.timedelta(
seconds=int(access_token_response.get('expires', 60 * 60 * 24 * 60)))
# Получаем список access_token для каждой из групп, что у нас есть в настройках
graph = GraphAPI(access_token=access_token)
group_access_tokens = {}
after = None
while True:
if after:
objects = graph.get_object('me/accounts', limit=25, after=after)
else:
objects = graph.get_object('me/accounts', limit=25)
for group in objects['data']:
if group['category'] == 'Community':
group_access_tokens[group['id']] = group['access_token']
if objects['paging'].get('next'):
after = objects['paging']['cursors']['after']
else:
break
facebook_autoposting = FacebookAutoposting.objects.all()
for fb_autoposting in facebook_autoposting:
if not group_access_tokens.get(fb_autoposting.page_id):
messages.error(request,
'Access Token for %s not found' % fb_autoposting)
continue
fb_autoposting.access_token = group_access_tokens.get(
fb_autoposting.page_id)
fb_autoposting.access_token_expires_at = access_token_expires_at
fb_autoposting.save()
return redirect(
reverse('admin:autoposting_facebookautoposting_changelist'))
def verify_data(access_token, verification_id):
print('VERIFY {}', verification_id)
VERIFICATION_ATTR = ['first_name', 'last_name', 'email', 'birthday']
graph = GraphAPI(access_token=access_token, version='2.11')
fb_data = graph.get_object(id='me',
fields='first_name,last_name,email,birthday')
verification = Verification.query.filter_by(id=verification_id).first()
result = {}
for attr in VERIFICATION_ATTR:
result[attr] = getattr(verification, attr) == fb_data[attr]
verification.fb_result = json.dumps(result)
verification.fb_data = json.dumps(fb_data)
fb_picture = graph.get_object(id='me/picture', type='large')
filename = '{}/fb_pic_{}.jpg'.format(UPLOAD_FOLDER, verification_id)
with open(filename, 'wb') as f:
f.write(fb_picture['data'])
verification.fb_picture = filename
db.session.add(verification)
db.session.commit()
return verification_id
def signup(request):
if request.method == "POST":
data = json.loads(request.body)
try:
if data['type'] == 'facebook':
try:
access_token = request.META['HTTP_FB_ACCESS_TOKEN']
fb_id = data['fb_id']
g_id = -1
try:
graph = GraphAPI(access_token)
profile = graph.get_object('me', fields='email')
fb_graph_id = profile['id']
except GraphAPIError as e:
return response('error', e)
if fb_id != fb_graph_id:
return response("error", "facebook auth failed", ("error_type", "fb_error"))
return check_and_add_user(data,fb_id,g_id)
except:
return response("error", "Incomplete data sent", ("error_type","Incomplete_data"))
elif data['type'] == 'google':
pass
else:
return response("error", "Invalid signup type")
except:
return response("error", "Invalid signup type")
else:
return response("error", "Not a post request")
def facebook_get_email(access_token): # pragma: no cover
try:
graph = GraphAPI(access_token=access_token)
data = graph.request('/me?fields=email')
return data.get('email')
except GraphAPIError:
return None
def get_url_info(url):
'''
Capture opengraph data from links.
It tries to get everything from Facebook.
TO DO: Have a default image when no image is found
'''
token = settings.FACEBOOK_TOKEN
fb_graph = GraphAPI(access_token=token, version='2.10')
fb_info = fb_graph.get_object(
id=quote(url),
fields=['engagement,og_object{image,description,title,updated_time}'])
if fb_info:
try:
return dict(thumbnail=fb_info['og_object']['image'][0]['url'],
facebook_shares=fb_info['engagement']['share_count'],
title=fb_info['og_object']['title'],
description=fb_info['og_object']['description'],
source=url.split('/')[2])
except KeyError:
from webpreview import web_preview
metadata = web_preview(url)
return dict(thumbnail=metadata[2],
facebook_shares=fb_info['engagement']['share_count'],
title=metadata[0],
description=metadata[1],
source=url.split('/')[2])
else:
return dict(thumbnail='',
facebook_shares=0,
title='',
description='',
source=url.split('/')[2])
def get_friend_event(user, access_token):
graph = GraphAPI(access_token)
events = graph.get_connections(user['id'], 'events')
for event in events['data']:
event = EventActions.create(event, user['id'])
pass
def check_user_logged_in():
if session.get('user'):
g.user = session.get('user')
return
result = get_user_from_cookie(cookies=request.cookies,
app_id=app.config["FB_APP_ID"],
app_secret=app.config["FB_APP_SECRET"])
if result:
user = UserActions.find_by_id(result['uid'])
if not user:
graph = GraphAPI(result['access_token'])
args = {'fields': 'birthday, name, email'}
profile = graph.get_object('me', **args)
UserActions.new_facebook_user(profile, result)
elif user.access_token != result['access_token']:
user.access_token = result['access_token']
user = UserActions.find_by_id(result['uid'])
session['user'] = dict(name=user.name,
profile_url=user.profile_url,
id=user.id,
access_token=user.access_token)
db.session.commit()
g.user = session.get('user', None)
def harvest_facebook_profile(self):
harvest_profile_d = Deferred()
logging.info('Facebook Service - Getting users Facebook Profile')
graph = GraphAPI(self.facebook_access_token_long)
profile = graph.get_object("me")
timestamp = str(datetime.datetime.now().isoformat('T')).split(".")[0]
uniq_id = "facebook_profile_for_me"
object_to_insert = {
"@id": uniq_id,
"app_object": app_id,
"timestamp": timestamp,
"facebook_profile": profile
}
#now need to perform the asnc
def insert_cb(re):
logging.debug(
"Facebook Service - Found Facebook Profile information, Added To INDX {0} profile items"
.format(len(profile)))
harvest_profile_d.callback(True)
def insert_cb_fail(re):
harvest_profile_d.callback(True)
self.insert_object_to_indx(object_to_insert).addCallbacks(
insert_cb, insert_cb_fail)
return harvest_profile_d
def on_authenticate_facebook(self, response):
try:
access_token, expires_in = \
response['accessToken'], response['expiresIn']
signed_request = parse_signed_request(
response['signedRequest'], app.config['FACEBOOK_SECRET'],
expires_in
)
if not signed_request:
return None, None
graph = GraphAPI(access_token)
profile = graph.get_object('me')
user = User.get_by_facebook(profile['id'])
if not user or user.status == User.NOT_REGISTERED_YET:
if not user:
user = User()
user.facebook_account = FacebookAccount()
user.email = profile['email']
user.facebook_account.name = user.nickname = profile['name']
user.facebook_account.uid = profile['id']
user.status = User.NORMAL
db.session.add(user)
db.session.commit()
self.online_users[self] = self.session['user_id'] = user.id
self.facebook_access_token = access_token, signed_request['expires_at']
return None, user.to_json()
except GraphAPIError, e:
return {'_type': 'GraphAPIError', 'msg': str(GraphAPIError)},
def validate_fb_email(email, access_token):
# check if user is has synced fb email
try:
connection = get_rdb_conn()
cursor = rdb.db(TODO_DB).table('user').filter(
rdb.row['fb_email'] == email).run(connection)
except:
return response_msg('error', 'Could not connect to db')
if len(cursor.items) == 0:
return response_msg('error',
'facebook not synced or user not registered')
# if user has already synced fb email
# check whether access token and email is valid
try:
graph = GraphAPI(access_token)
profile = graph.get_object('me', fields='email')
fb_email = profile['email']
except GraphAPIError as e:
return response_msg('error', e)
except:
return response_msg('error', 'Could not connect to facebook')
if fb_email == email:
return response_msg('success', 'OK')
else:
return response_msg('error', 'invalid fb details')
def sync_facebook(name):
#import ipdb; ipdb.set_trace();
try:
form_data = json.loads(request.data)
except:
return response_msg('error', 'data not correct')
try:
graph = GraphAPI(form_data['access_token'])
try:
# #import ipdb; ipdb.set_trace();
email = graph.get_object('me', fields='email')['email']
pic = graph.get_object('me/picture', width='400',
height='400')['url']
print pic
if email != form_data['fb_email']:
return response_msg('error', 'incorrect facebook email')
except:
return response_msg('error', 'data not complete')
except:
return response_msg('error', 'invalid access token')
try:
connection = get_rdb_conn()
cursor = rdb.db(TODO_DB).table('user').filter(
rdb.row['username'] == name).update({
'fb_email': email,
'pic': pic
}).run(connection)
cursor = rdb.db(TODO_DB).table('user').filter(
rdb.row['username'] == name).run(connection)
except:
return response_msg('error', 'Could not connect to db')
return response_msg('success', 'OK', data=cursor.items[0])
def list_fb_pages():
token = config("FB_PYTHON_ACCESSTOKEN", default=None)
if token != None:
graph = GraphAPI(token)
groups = graph.get_object("me/groups")
return groups
return []
def post_fb_page(message):
graph = GraphAPI(config("FB_PYTHON_ACCESSTOKEN", default="TOKKEEEENNNN"))
try:
graph.put_object("PyJobs", "feed", message=message)
except:
pass
return True
def get_current_user():
if not session.get('user'):
result = get_user_from_cookie(cookies=request.cookies,
app_id=FB_APP_ID,
app_secret=FB_APP_SECRET)
if result:
graph = GraphAPI(result['access_token'])
profile = graph.get_object('me', fields='link,name,id')
access_token = graph.extend_access_token(
FB_APP_ID, FB_APP_SECRET)['access_token']
user = User.get_by_id(result['uid'])
if not user:
user = User.create(id=profile['id'],
name=profile['name'],
profile_url=profile['link'],
access_token=access_token)
clear_friends_cache(user)
user.add_default_tag()
g.new_user = True
else:
user.access_token = access_token
user.update()
session['user'] = user.id
g.uid = session.get('user')
g.user = User.get_by_id(g.uid) if g.uid else None
if not g.user:
session['user'] = ''
def load_facebook_events(nodes, token=os.environ.get('FACEBOOK_TOKEN')):
"""
Load events from Facebook pages to the events file.
..important:
In order for this function to work, you need to to provide a valid
Facebook Graph API token. You can get yours easily on
https://developers.facebook.com/tools/explorer
:param nodes: Facebook nodes to load public events from.
:param token: Facebook Graph API token.
"""
graph = GraphAPI(access_token=token)
with open('data/events.yml', 'r') as events_file:
existing_events = yaml.load(events_file)
# Get facebook metadata on existing entries
facebook_ids = {entry.get('facebook_id') for entry in existing_events}
fetched_events = []
for node in nodes:
event_node = "{}/events".format(node)
# XXX: Ideally we would follow subrequests, but a large limit
# should work as a simple solution.
node_events = graph.get_object(event_node, limit=1000)
for event in node_events['data']:
# If event already exists, just ignore
if event['id'] in facebook_ids:
continue
# We need to reshape datetimes to events format
format_date = datetime.strptime(event['start_time'],
'%Y-%m-%dT%H:%M:%S%z')
fetched_events.append({
'name':
event['name'],
'url':
'https://facebook.com/{}'.format(event['id']),
'local':
event.get('place', {}).get('name', ''),
'date':
format_date.strftime('%d-%m-%Y'),
'facebook_id':
str(event['id'])
})
# Pretty print new entries on the events file
with open('data/events.yml', 'a') as events_file:
for entry in fetched_events:
events_file.write('\n')
yaml.dump([entry],
events_file,
default_flow_style=False,
allow_unicode=True)
def login(request):
ret = None
if request.method == 'POST':
form = FacebookConnectForm(request.POST)
if form.is_valid():
try:
token = form.cleaned_data['access_token']
g = GraphAPI(token)
facebook_me = g.get_object("me")
email = valid_email_or_none(facebook_me.get('email'))
social_id = facebook_me['id']
try:
account = FacebookAccount.objects.get(social_id=social_id)
except FacebookAccount.DoesNotExist:
account = FacebookAccount(social_id=social_id)
data = dict(email=email,
facebook_access_token=token,
facebook_me=facebook_me)
# some facebook accounts don't have this data
data.update((k, v) for (k, v) in facebook_me.items()
if k in ['username', 'first_name', 'last_name'])
# Don't save partial/temporary accounts that haven't
# gone through the full signup yet, as there is no
# User attached yet.
if account.pk:
account.sync(data)
ret = complete_social_login(request, data, account)
except (GraphAPIError, IOError):
pass
if not ret:
ret = render_authentication_error(request)
return ret
def get(app_name):
parser = reqparse.RequestParser()
parser.add_argument('id', type=str, location='args', required=True, help='User id cannot be blank')
parser.add_argument('access_token', type=str, location='args', required=True)
values = parser.parse_args(strict=True)
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute("SELECT TOKEN FROM FACEBOOK WHERE USER_ID=%s AND APP=%s;", (values['id'], app_name))
results = cursor.fetchall()
cursor.close()
if results != ():
access_token = results[0]['TOKEN']
try:
graph = GraphAPI(access_token=access_token, version=API_VERSION)
permissions = graph.get_permissions(user_id=values['id'])
except GraphAPIError:
logging.info('Expired access token: {}'.format(access_token))
return error_message('GraphAPI', 'Expired Token', 403), 403
if all(x in ['public_profile', 'user_friends'] for x in permissions):
logging.info('\'user_friends\' permission denied for user with id: {}'.format(values['id']))
return error_message('Permission', 'User Friends permission', 403), 403
friends_call = 'https://graph.facebook.com/' + values['id'] + '/friends'
friends = requests.get(friends_call, params={'access_token': access_token}).json()['data']
logger.info('HTTP GET successfully processed')
return {'ack': 'true',
'msg': friends}, 200
else:
return {'ack': 'false',
'msg': 'Invalid User'}, 200
def scrape_facebook(self, profile_filename=None, posts_filename=None):
"""
Scrape!
"""
logger.info('Scraping Facebook (start time: %s)' % self.run_time)
if profile_filename and posts_filename:
with open(profile_filename) as f:
profile = json.load(f)
with open(posts_filename) as f:
api_posts = json.load(f)
else:
self.graph = GraphAPI(self.access_token)
profile = self.graph.get_object(self.user)
api_posts = self.graph.get_connections(profile['id'], 'posts')
posts = []
for api_post in api_posts['data']:
post = Post(api_post, self.run_time)
posts.append(post)
logger.info('Scraped basic information for %s from Facebook (%s)' %
(post.facebook_id, post.headline))
return posts
def Look_for_comments(vendor):
print(vendor['page_id'])
graph = GraphAPI(access_token=vendor['access_token'])
print('Started at {} ....'.format(last_time_function_ran))
posts = graph.get_connections(
id=vendor['page_id'], connection_name='posts', fields='updated_time,comments{message,created_time}')
data = posts['data']
for post in data:
post_updated_time = datetime.strptime(
post['updated_time'], time_format)
if post_updated_time > last_time_function_ran:
for comment in post['comments']['data']:
comment_created_time = datetime.strptime(
comment['created_time'], time_format)
if not check_for_comments(comment['id'], graph, vendor):
print('Found Comment!')
msg = ask_wit(comment['message'], vendor)
if msg:
graph.put_comment(object_id=comment['id'],
message=msg)
print('Replied to Comment')
print('...Finished at {}'.format(last_time_function_ran))
def post(self, *args, **kwargs):
try:
graph = GraphAPI(access_token=self.request.data['access_token'],
version=settings.FACEBOOK_APP_VERSION)
graph_data = graph.get_object(id='me',
fields='email,first_name,last_name')
except GraphAPIError:
raise ParseError(detail='Invalid Facebook access token')
data = {
**graph_data, 'password':
get_user_model().objects.make_random_password()
}
user, created = get_user_model().objects.get_or_create(
email=data['email'])
signup_ser = SignUpSerializer(instance=user, data=data)
signup_ser.is_valid(raise_exception=True)
user = signup_ser.save(is_active=True)
token_ser = JSONWebTokenSerializer(data={
'email': data['email'],
'password': data['password']
})
token_ser.is_valid(raise_exception=True)
HistoryRecord.objects.create_history_record(
user, None, HISTORY_RECORD_USER_SIGNUP_FACEBOOK)
return Response(
{'token': token_ser.object.get('token')},
status=status.HTTP_201_CREATED if created else status.HTTP_200_OK)
def get_friend_post(user, access_token):
graph = GraphAPI(access_token)
posts = graph.get_connections(user['id'], 'posts')
for post in posts['data']:
post = PostActions.create(post, user['id'])
pass
def index(name="index", *args, **kawrgs):
if request.is_xhr:
return "", 400
if g.user:
# try:
graph = GraphAPI(g.user['access_token'])
args = {'fields': 'birthday, name, email'}
facebook_friends = graph.get_object('me/friends', **args)
user = UserActions.find_by_id(g.user['id'])
for facebook_friend in facebook_friends['data']:
friend = UserActions.new(facebook_friend)
FriendRelationshipActions.create(user, friend)
relations = FriendRelationshipActions.find_by_user(user)
return render_template("index.html",
app_id=app.config["FB_APP_ID"],
user=user,
relations=relations)
# except Exception:
# return redirect(url_for('logout'))
return render_template("login.html", app_id=app.config["FB_APP_ID"])
def add_facebook_token():
"""Add token to db"""
access_token = request.form.get("access_token")
facebook_user_id = request.form.get("facebook_user_id")
graph = GraphAPI(access_token)
app_id = os.environ['FACEBOOK_APP_ID']
app_secret = os.environ['FACEBOOK_APP_SECRET']
extended_token = graph.extend_access_token(app_id, app_secret)
final_token = extended_token['access_token']
facebook_info = FacebookInfo.query.filter_by(
facebook_user_id=facebook_user_id, user_id=session['user_id']).first()
if not facebook_info:
facebook_info = FacebookInfo(user_id=session["user_id"],
access_token=final_token,
facebook_user_id=facebook_user_id)
else:
facebook_info.access_token = access_token
db.session.add(facebook_info)
db.session.commit()
return "success"
def show_post_form_pages():
"""Show posting for for Facebook Pages"""
if 'user_id' not in session:
flash("You need to be logged in for that!")
return redirect('/')
user_id = session["user_id"]
user = User.query.filter_by(user_id=user_id).first()
username = user.username
facebook_info = FacebookInfo.query.filter_by(user_id=user_id).first()
if not facebook_info:
flash("You need to log into Facebook first!")
return redirect('/')
access_token = facebook_info.access_token
api = GraphAPI(access_token)
page_response = api.get_connections("me", "accounts")
return render_template("post_pages.html",
username=username,
pages=page_response["data"])
def signin():
uid = request.args.get('uid', '')
print("uid =", uid)
query = {'id': uid}
user = db.users.find_one(query)
print(user)
if not user:
# Not an existing user so get info
requestAccessToken = request.args.get('access_token', '')
print("token=", requestAccessToken)
graph = GraphAPI(requestAccessToken)
profile = graph.get_object('me')
if 'link' not in profile:
profile['link'] = ""
print(profile)
# Create the user and insert it into the database
db.users.insert({
'id': uid,
'profile_url': profile['link'],
'created_time': datetime.utcnow,
'name': profile['name'],
'access_token': requestAccessToken
})
elif user.access_token != requestAccessToken:
# If an existing user, update the access token
user.access_token = requestAccessToken
response = jsonify({user})
response.status_code = 200
return response
def get_details_for_profile_from_user(self, requesting_user, **kwargs):
'''
For the details, we need:
1. Cover pic
2. Profile pic
3. Location if available
More details about usage from core.models
'''
access_token = self.social_auth.get(
provider="facebook").extra_data.get("access_token")
graph = GraphAPI(access_token)
details_dict = {}
try:
info = graph.get_object("me", fields="picture, cover, location")
details_dict['picture'] = info.get('picture',
{}).get('data',
{}).get('url', None)
details_dict['cover'] = info.get('cover', {}).get('source', None)
details_dict['location'] = info.get('location',
{}).get('name', None)
return details_dict
except:
logger.error(
"accounts.models.BanyanUser:get_details_for_profile_from_user {}{} access_token:{}"
.format(sys.exc_info()[0],
sys.exc_info()[1], access_token))
return []
