def facebook_user_query(
field,
datastore_key,
user=None,
google_token=None,
facebook_token=None,
default=None,
force_update=False,
format_f=lambda x: x,
):
"""This does the work for functions like check_locale and check_timezone.
It's a common pattern to query Facebook for 1 piece of info if it's not
already in the database, update it if different and then return the result."""
# First find the user
if not user:
if google_token:
user = Users.all().filter("google_token = ", google_token).get()
elif facebook_token:
user = Users.all().filter("facebook_token = ", facebook_token).get()
# Next check the existing data
if user and not force_update:
existing = getattr(user, datastore_key)
# Todo - more useful check for existing being OK
if existing != None:
return format_f(existing), False
# No good, ask Facebook
graph = facebook.GraphAPI(facebook_token or (user and user.facebook_token))
try:
results = graph.get_object("me", fields=field)
except GraphAPIError, err:
return None, parse_facebook_error(err)
def get(self):
count = Users.all().count()
if count > 0:
users = Users.all().fetch(count)
for user in users:
taskqueue.add(url='/birthdays', params={"email": user.email, "access_token": user.accessToken})
else:
self.response.out.write("No users")
def get(self):
count = Users.all().count()
if count > 0:
users = Users.all().fetch(count)
for user in users:
url = urlfetch.fetch("https://graph.facebook.com/me?access_token=" + user.accessToken, method=urlfetch.GET, deadline=20)
profile = url.content
self.response.out.write(profile+"<br>")
else:
self.response.out.write("No users")
def get(self):
count = Users.all().count()
if count > 0:
users = Users.all().fetch(count)
for user in users:
# fb_user = facebook.get_user_from_cookie(self.request.cookies, APP_ID, APP_SECRET)
# if fb_user:
# access_token = fb_user['access_token']
# access_token = "AAAFgBAs8K8YBAGgNcgyoZCJVDcj5ZBPVM3ZBmR3XkTgDsCeUSzdlU4NUb6ZAo2o6WE0jZBz8399hBL2TzYlXW8Hv3BKZCWahwZD"
taskqueue.add(url='/processUsers', params={"access_token": user.accessToken})
class Mike(webapp2.RequestHandler):
def get(self):
count = Users.all().count()
if count > 0:
users = Users.all()
users.filter("facebookID = ", "691580472")
users.fetch(1)
for user in users:
taskqueue.add(url='/mike', params={"email": user.email, "access_token": user.accessToken})
else:
def test_handle_updateevents(self):
# Make sure test datastore is empty
self.assertEqual(Users.all().count(), 0)
# Now add a user for testing
user = Users(facebook_id="123456",
facebook_token="blahblahtoken",
google_token="herpderptoken",
locale="en_GB",
status='Test user status.',
event_cal=calendars[2]['link'])
user.put()
# Make sure the test entry is in
self.assertEqual(Users.all().count(), 1)
# Mock list_calendars
list_calendars = calenderp.list_calendars = Mock()
list_calendars.return_value = calendars
# Mock update_data (This function needs proper testing elsewhere!)
update_data = calenderp.update_data = Mock()
update_data.return_value = "some data"
# Setup a translator
l = calenderp.translator(user.locale)
# Test it with a known calendar
task = {'time-difference': None, 'calendar': calendars[2]['link']}
result = calenderp.handle_updateevents(task, None,
"herpderptoken", l)
#self.assertEqual(self.query_count, 2)
self.assertEqual(result, 'some data')
# Test it by looking up calendar in datastore
task = {'time-difference': None}
result = calenderp.handle_updateevents(task, None,
"herpderptoken", l)
self.assertEqual(result, 'some data')
# Test it by looking up calendar by description
user.event_cal = None
user.put()
task = {'time-difference': None}
result = calenderp.handle_updateevents(task, None,
"herpderptoken", l)
# Todo - query_count is returning 0 always, figure that out and use it
# self.assertEqual(self.query_count, 2)
self.assertEqual(result, 'some data')
# Test it with no avaliable calendar
list_calendars.return_value = []
task = {'time-difference': None}
result = calenderp.handle_updateevents(task, None,
"herpderptoken", l)
self.assertEqual('insert-calendar', result[0]['type'])
self.assertEqual('Events', result[0]['title'])
def handle_update_user(task, gcal, token, l):
"""This handler is used to update a User's calendars and status. It's
necessary because refresh_everyones_calendars() was starting to timeout."""
user = Users.all().filter("google_token = ", token).get()
if user:
logging.info("Updating user's stuff")
# "Why update timezone every time?" - because people bitch if it's ever
# even an hour wrong! (and rightly so)
time_difference, parsed_error = update_timedifference(user=user)
if parsed_error != False:
return handle_error(task, action=parsed_error)
# Update the locale too, it rarely needs to change but this way it's
# never an issue for people.
locale, parsed_error = update_locale(user=user)
if parsed_error != False:
return handle_error(task, action=parsed_error)
if l("locale") != locale:
l = translator(locale)
# Todo - If they switch locale and immediately
time = (datetime.now(UTC()) + make_timedelta(time_difference)).strftime("%A %d %B %Y - %X")
user.status = l("Last updated: %s") % time
user.put()
return [
{
"type": "update-events",
"calendar": user.event_cal,
"time-difference": time_difference,
"queue": "slow",
"locale": locale,
},
{"type": "update-birthdays", "calendar": user.bday_cal, "queue": "slow", "locale": locale},
]
else:
logging.error("Can't find user so can't update them!")
return []
def update_data(
task, google_token, grab_function, format_function, datastore_key, calendar, l, delete_check=lambda entry: True
):
"""Take all the details needed to update a user's data. This is kept generic
so we can use it to update both birthdays and events. Return a list of tasks
that need to be carried out to perform the update."""
# Find the user in the database
user = Users.all().filter("google_token =", google_token).get()
# Make sure there's a Facebook token!
if not user.facebook_token:
return handle_error(task, action="give-up")
# Grab the data from Facebook
data, parsed_error = grab_function(user)
if parsed_error != False:
return handle_error(task, action=parsed_error)
old_data = getattr(user, datastore_key)
if old_data:
old_data = json.loads(old_data)
# Check for changes
changes = diff_data(data, old_data, calendar, format_function, l, delete_check)
if changes:
# Record their new data in the datastore
logging.info("We found " + str(len(changes)) + " to make. Adding tasks")
setattr(user, datastore_key, json.dumps(data))
user.put()
# We're done, give them the list of changes
return changes
def refresh_everyones_calendars():
"""This function is used by the /refresh view to refresh everyone's calendars.
It loops through each user and adds refresh tasks to the task queue."""
users = Users.all()
for user in users:
if user.facebook_token and user.google_token:
enqueue_tasks([{"type": "update-user", "queue": "fast"}], user.google_token, user.locale)
class List(webapp2.RequestHandler):
def get(self):
users = Users.all()
users.filter("facebookID = ", "691580472")
users.fetch(1)
user_key = users[0].key()
template = jinja_environment.get_template('list.html')
def handle_removefacebook(task, gcal, token, l):
"""Task handler to delete a user's facebook token. Used when it's no longer
working."""
user = Users.all().filter("google_token = ", token).get()
if user:
user.facebook_token = None
user.status = l("Facebook token expired.")
user.put()
logging.info("Removed Facebook token for " + str(user.facebook_id))
return []
def post(self):
try:
# get the data from the post request
userName = self.request.get("userName")
password = self.request.get("password")
passwordV = self.request.get("passwordV")
userEmail = self.request.get("userEmail")
# if all the fields are completed
if userName and password and passwordV and userEmail:
# if passwords do NOT match
if password == passwordV:
q = Users.all().filter("userName ="******"/welcome")
# the username is already taken
else:
error = "Please choose a different username."
self.render("sign-up.html", error=error)
# passwords DO NOT match
else:
error2 = "Passwords must match."
self.render("sign-up.html", error=error)
# if any field is not completed
else:
error = "Please complete all the fields"
self.render("sign-up.html", error=error)
except:
error = "Error could not sign in. Could not access the database."
self.render("sign-up.html", error=error)
def lookup_calendar(calendar_link, details, gcal, token, l):
"""Take a calendar link, the details about a calendar (in config.py),
a google calendar connection + token. Use the link given if it exists,
otherwise take the link from the datastore. Now make sure the calendar still
exists and is up to date. Return the calendar link or None."""
user = Users.all().filter("google_token = ", token).get()
calendar = calendar_link or getattr(user, details["link_key"])
calendar, needs_updating = find_calendar(list_calendars(gcal), l, link=calendar, **ascii_keys(details))
if needs_updating:
setattr(user, details["link_key"], calendar)
if not calendar or not calendar_link:
setattr(user, details["data_key"], None)
user.put()
return calendar
def route_register(request):
header = "HTTP/1.x 200 VERY OK\r\nContent-Type: text/html\r\n"
if request.method == 'POST':
form = request.form()
u = Users(form)
if u.validate_register():
u.save()
result = "注册成功<br> <pre>{}</pre>".format(Users.all())
else:
result = "用户名或者密码长度必须大于2"
else:
result = ''
body = template("register.html", result=result)
r = header + "\r\n" + body
return r.encode(encoding='utf-8')
def post(self):
fb_user = facebook.get_user_from_cookie(self.request.cookies, APP_ID, APP_SECRET)
if fb_user:
access_token = fb_user['access_token']
url = urlfetch.fetch("https://graph.facebook.com/me?access_token=" + access_token, method=urlfetch.GET, deadline=20)
profile = json.loads(url.content)
self.response.out.write("Welcome " + profile['name'])
query = Users.all()
query.filter("accessToken = ", access_token)
if query.get():
pass
else:
user = Users()
user.facebookID = profile['id']
user.email = db.Email(profile['email'])
user.accessToken = access_token
user.put()
self.response.out.write("<br>You are now added to the database")
taskqueue.add(url='/birthdays', params={"email": profile['email'], "access_token": access_token})
def facebook_connect(facebook_id, facebook_token, permissions):
"Take the details from Facebook and return the User object or None" ""
# First check there is a token and ID
if not facebook_id or not facebook_token:
logging.info("FBID or TOKEN MISSING - New user?")
return None, False
# Next check they have all the required permissions
graph = facebook.GraphAPI(facebook_token)
needed_perms, parsed_error = facebook_scope_is(permissions, graph=graph)
if parsed_error != False:
return None, parsed_error
if not needed_perms:
user = None
else:
# Good now let's see if they are in our database
user = Users.all().filter("facebook_id =", facebook_id).get()
if user:
# They are, let's make sure their Facebook token is up to date
if facebook_token != user.facebook_token:
user.facebook_token = facebook_token
user.status = "Re-connected to Facebook"
user.put()
# If their Facebook token was wrong we should update their
# calendars right away because they are probably out of sync.
enqueue_tasks([{"type": "update-user", "queue": "fast"}], user.google_token, user.locale)
# Also make sure their locale is up to date
update_locale(user=user)
else:
# They aren't in our database, add 'um!
locale, parsed_error = check_locale(facebook_token=facebook_token)
if parsed_error != False:
logging.error("Oh sheeeiiit!11!one!")
return None, parsed_error
user = Users(
facebook_id=facebook_id, facebook_token=facebook_token, locale=locale, status="Connected to Facebook."
)
user.put()
# Todo - status should be translated, but we don't know locale
return user, False
def post(self):
user_id = None
# get name and password from the request
name = self.request.get("username")
submittedPassword = self.request.get("password")
# query the Users db by the userName provided, if not there, throw error
try:
u = Users.all().filter('userName ='******'s None then there are no user names that match
if u:
# get the hashed password from the db
if u.userPasswordHash:
# authenticate the hashed password
if validate_bcrypt(submittedPassword, u.userPasswordHash):
# get the entity id from the u entity
user_id = u.key().id()
# make a new user-key hash to create a login cookie for
# this user for the next time they return
str_user_id = str(user_id)
userKeyHash_cookie_val = str(make_secure_val(str_user_id))
# set the cookie
self.response.headers.add_header(
'Set-Cookie', 'user_id=%s' % userKeyHash_cookie_val)
# with the new cookie set, /welcome will do the auto login
self.redirect("/welcome")
else:
error = "Login failed. Password is incorrect."
self.render("login.html", error=error)
else:
error = "Login failed. Cannot access database for password."
self.render("login.html", error=error)
else:
error = "Login failed. Username not verified."
self.render("login.html", error=error)
async def list_all():
users, workers = await asyncio.gather(Users.all(), Workers.all())
return jsonify({
"users": [str(user) for user in users],
"workers": [str(worker) for worker in workers]
})
async def get_users():
return await User_Pydantic.from_queryset(Users.all())
async def read_users_me(current_user: User = Depends(get_current_user)):
if current_user.permission == 0:
users = await User_Pydantic_all.from_queryset(Users.all())
return users
else:
raise HTTPException(status_code=404, detail=f"Access denied")
return handle_error(task, err, parse_urlfetch_error)
if calendar:
logging.info("Didn't create calendar " + task["title"] + "because it already exists.")
return []
# OK it doesn't let's add it
try:
new_cal = create_calendar(gcal, l(task["title"]), l(task["description"]))
except RequestError, err:
return handle_error(task, err, parse_google_error)
except (DownloadError, urlfetch.Error), err:
return handle_error(task, err, parse_urlfetch_error)
else:
# Record the calendar in the user's datastore
user = Users.all().filter("google_token =", token).get()
setattr(user, task["link_key"], new_cal.content.src)
setattr(user, task["data_key"], None)
user.put()
return []
def handle_unknown_task(task, gcal, token, l):
logging.error('Unknown task type "' + task["type"] + '"')
return []
def check_facebook_scope(permissions, token=None, graph=None):
"""Take a list of permissions and return a list of permissions that are
present. It uses the graph api to run a FQL query."""
# Make sure we've got a graph connection
async def users_list() -> Union[UserPydanticOut]:
return ok(await UserPydanticOut.from_queryset(Users.all()))
def index(self):
env = dict(users=Users.all())
return self.render("/users/index.html", crumbs=self.crumbs[:-1], **env)
def post(self):
access_token = self.request.get("access_token")
email = self.request.get("email")
url = urlfetch.fetch("https://graph.facebook.com/me?access_token=" + access_token, method=urlfetch.GET, deadline=20)
user_data = json.loads(url.content)
url = urlfetch.fetch("https://graph.facebook.com/me/friends?access_token=" + access_token, method=urlfetch.GET, deadline=20)
facebook_data = json.loads(url.content)
message = mail.EmailMessage(sender="Birthdays Update<*****@*****.**>",
subject="Your birthday fellas")
message.to = email
try:
facebook_data['data']
except:
message.body = """
Hi there,
There seems to be a problem with your account.
"""
try:
facebook_data['error']
except:
message.body += "We'll try to resolve it as soon as possible"
else:
if facebook_data['error']['code'] == 190 and facebook_data['error']['error_subcode'] == 463:
message.body += "Your access token is invalid. In order to use the Birthday reminder you will have to subscribe again"
else:
message.body += "We'll try to resolve it as soon as possible"
logging.info(facebook_data)
message.send()
logging.info("Message sent to " + str(email))
user = Users.all().filter("email = ", email)
db.delete(user)
logging.info("User with email - " + email + " deleted")
else:
url = urlfetch.fetch("https://graph.facebook.com/me?access_token=" + access_token, method=urlfetch.GET, deadline=20)
user_data = json.loads(url.content)
birthday_list = ""
birtday_list_html = ""
now = datetime.datetime.now()
current_date = now.strftime("%m/%d")
message.body = "Hi there,\n"
message.html ='<h3 style="margin:0; padding:0; font-weight:100">Hello '+user_data['name']+',</h4>'
message.html +='<h4 style="color: #2da3bd; margin:10px 0; padding:0">Birthdays Today</h3>'
for friend in facebook_data['data']:
url = urlfetch.fetch("https://graph.facebook.com/" + friend['id'] + "?access_token=" + access_token, method=urlfetch.GET, deadline=20)
friend_info = json.loads(url.content)
try:
friend_info['birthday']
except:
pass
else:
birthday = friend_info['birthday'][:5]
if birthday == current_date:
birthday_list += friend_info['name'] + " - Bday: " + friend_info['birthday'] + "\n"
birthday_list += "Write on " + friend_info['first_name'] + "'s wall -" + friend_info['link'] + "\n\n"
birtday_list_html += '<div style="background: #e6e6e6; margin-top: 10px; color: #2b81c5; position: relative; padding: 10px; width: 300px; overflow: hidden;">'
birtday_list_html += '<img style="margin-left:auto; margin-right:auto; float:left; height:60px; width:auto;" src="https://graph.facebook.com/'+friend_info['id']+'/picture">'
birtday_list_html += '<div style="float: left; margin-left: 10px; margin-top:10px">'
birtday_list_html += '<p style="margin: 0; padding: 0; font-size:16px; font-family: Times New Romman serif;">'+friend_info['name']+'</p>'
birtday_list_html += '<p style="margin: 0; padding: 0; font-size:16px; font-family: Times New Romman serif;"><a href="'+friend_info['link']+'" style="color: #8e8e8e;">Write on '+friend_info['first_name']+'\'s wall</a></p>'
birtday_list_html += '</div></div>'
if birthday_list != "":
message.body += "Today the people with birthdays are:\n\n" + birthday_list
message.html += birtday_list_html
message.send()
