def get_token(self, code):
""" Get live access token
:type code: str
:param code:
:rtype: str
:return: access token and uid
"""
# live need post a form to get token
headers = {'Content-type': 'application/x-www-form-urlencoded'}
data = {
'client_id': get_config('login.live.client_id'),
'client_secret': get_config('login.live.client_secret'),
'redirect_uri': get_config('login.live.redirect_uri'),
'grant_type': 'authorization_code',
'code': code
}
# Following is use urllib to post request
url = get_config('login.live.access_token_url')
r = requests.post(url, data=data, headers=headers)
resp = r.json()
if resp.get("error") is not None:
raise Exception(resp)
return resp["access_token"]
def __init__(self, app):
"""Initialize APScheduler
:type app: Flask
:param app: the Flask app
"""
self.app = app
self.__apscheduler = None
# NOT instantiate while in flask DEBUG mode or in the main thread
# It's to avoid APScheduler being instantiated twice
if not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
self.__apscheduler = BackgroundScheduler(timezone=utc)
# add MySQL job store
job_store_type = safe_get_config("scheduler.job_store", "memory")
if job_store_type == "mysql":
log.debug("add aps_cheduler job store based on mysql")
self.__apscheduler.add_jobstore('sqlalchemy',
alias=self.jobstore,
url=get_config("scheduler.job_store_url"))
elif job_store_type == "mongodb":
log.debug("add aps_cheduler job store based on mongodb")
self.__apscheduler.add_jobstore('mongodb',
alias=self.jobstore,
database=safe_get_config("scheduler.database", "apscheduler"),
collection=safe_get_config("scheduler.collection", "jobs"),
host=safe_get_config("scheduler.host", "localhost"),
port=safe_get_config("scheduler.port", 27017))
# add event listener
self.__apscheduler.add_listener(scheduler_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR | EVENT_JOB_ADDED)
log.info("APScheduler loaded")
self.__apscheduler.start()
def __init__(self, app):
"""Initialize APScheduler
:type app: Flask
:param app: the Flask app
"""
self.app = app
self.__apscheduler = None
# NOT instantiate while in flask DEBUG mode or in the main thread
# It's to avoid APScheduler being instantiated twice
if not app.debug or os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
self.__apscheduler = BackgroundScheduler(timezone=utc)
# add MySQL job store
if safe_get_config("scheduler.job_store", "memory") == "mysql":
log.debug("add aps_cheduler job store based on mysql")
self.__apscheduler.add_jobstore('sqlalchemy',
alias=self.jobstore,
url=get_config("scheduler.job_store_url"))
# add event listener
self.__apscheduler.add_listener(scheduler_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
log.info("APScheduler loaded")
self.__apscheduler.start()
def get_user_info(self, token, uid):
"""Get weibo user info
:type token: str
:param token:
:type uid: str
:param uid:
:rtype: dict
:return:
{"id":2330622122,"idstr":"2330622122","class":1,"screen_name":"test name","name":"test name",
"province":"31","city":"10","location":"shanghai yangpu","description":"","url":"",
"profile_image_url":"http://tp3.sinaimg.cn/2330622122/50/5629035320/1",
"profile_url":"u/2330622122","domain":"","weihao":"","gender":"m","followers_count":34,
"friends_count":42,"pagefriends_count":0,"statuses_count":0,"favourites_count":1,
"created_at":"Mon Aug 22 17:58:15 +0800 2011","following":false,"allow_all_act_msg":false,
"geo_enabled":true,"verified":false,"verified_type":-1,"remark":"","ptype":0,"allow_all_comment":true,
"avatar_large":"http://tp3.sinaimg.cn/2330622122/180/5629035320/1","avatar_hd":"http://tp3.sinaimg.cn/2330622122/180/5629035320/1",
"verified_reason":"","verified_trade":"","verified_reason_url":"","verified_source":"","verified_source_url":"",
"follow_me":false,"online_status":0,"bi_followers_count":8,"lang":"zh-cn","star":0,"mbtype":0,"mbrank":0,
"block_word":0,"block_app":0,"credit_score":80,"urank":6}
"""
# https://api.weibo.com/2/users/show.json?access_token=2.005RDjXC0rYD8d39ca83156aLZWgZE&uid=1404376560
user_info_resp = get_remote(
get_config('login.weibo.user_info_url') + token + "&uid=" + uid)
user_info = json.loads(user_info_resp)
if user_info.get("error") is not None:
raise Exception(user_info)
return user_info
def get_user_info(self, token):
"""Get qq user info
:type token: str
:param token:
:rtype: dict
:return:
"url":"https://api.github.com/users/juniwang","html_url":"https://github.com/juniwang",
"followers_url":"https://api.github.com/users/juniwang/followers", self.log.debug("get admin user info from " + provider + " : " + user_info_resp + '\n' )
"following_url":"https://api.github.com/users/juniwang/following{/other_user}",
"starred_url":"https://api.github.com/users/juniwang/starred{/owner}{/repo}",
"gists_url":"https://api.github.com/users/juniwang/gists{/gist_id}",
"events_url":"https://api.github.com/users/juniwang/events{/privacy}",
{"login":"******","id":8814383,"avatar_url":"https://avatars.githubusercontent.com/u/8814383?v=3","gravatar_id":"",
"subscriptions_url":"https://api.github.com/users/juniwang/subscriptions",
"received_events_url":"https://api.github.com/users/juniwang/received_events","type":"User","site_admin":false,
"name":"Junbo Wang","company":"","blog":"","location":"Shanghai China",
"organizations_url":"https://api.github.com/users/juniwang/orgs","repos_url":"https://api.github.com/users/juniwang/repos",
"email":"*****@*****.**","hireable":false,"bio":null,"public_repos":12,"public_gists":0,"followers":0,
"following":1,"created_at":"2014-09-18T01:30:30Z","updated_at":"2014-11-25T09:00:37Z","private_gists":0,
"plan":{"name":"free","space":307200,"collaborators":0,"private_repos":0}}
"total_private_repos":0,"owned_private_repos":0,"disk_usage":14179,"collaborators":0,
"""
user_info_url = get_config('login.github.user_info_url')
headers = {
"Authorization": "token %s" % token,
"Accept": "application/json"
}
user_info_resp = get_remote(user_info_url, headers)
user_info = json.loads(user_info_resp)
if user_info.get("message") is not None:
raise Exception(user_info)
return user_info
def __init__(self, app):
"""Initialize APScheduler
:type app: Flask
:param app: the Flask app
"""
self.app = app
self.__apscheduler = None
# NOT instantiate while in flask DEBUG mode or in the main thread
# It's to avoid APScheduler being instantiated twice
if not app.debug or os.environ.get('WERKZEUG_RUN_MAIN') == 'true':
self.__apscheduler = BackgroundScheduler(timezone=utc)
# add MySQL job store
if safe_get_config("scheduler.job_store", "memory") == "mysql":
self.jobstore = 'sqlalchemy'
self.__apscheduler.add_jobstore(
self.jobstore, url=get_config("scheduler.job_store_url"))
# add event listener
self.__apscheduler.add_listener(
scheduler_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
log.info("APScheduler loaded")
self.__apscheduler.start()
def get_user_info(self, access_token, openid):
"""get user info from wx-api
this is the final step to login with wechat
:type access_token: str
:param access_token: the access token get from wx
:type openid: str
:param openid: the openid get from wx to specified user
:rtype: dict
:return: then user info accessed from wechat
"""
url = get_config("login.wechat.user_info_url") % (access_token, openid)
return self._access_wxapi_or_raise(url)
def get_access_token(self, code):
"""get access token from wx-api
this is the second step to login with wechat after the
client get the code
:type code: str
:param code: code get from wx
:rtype: tuple
:return: then access token and user open id in a tuple
"""
url = get_config("login.wechat.access_token_url") % code
r = self._access_wxapi_or_raise(url)
return (r["access_token"], r["openid"])
def get_emails(self, token):
"""Get user primary email
:type token: str
:param token:
:rtype: dict
:return: emails
"""
user_email_url = get_config('login.github.emails_info_url')
headers = {"Authorization": "token %s" % token}
email_info_resp = get_remote(user_email_url, headers)
email_list = json.loads(email_info_resp)
return email_list
def get_token(self, code):
""" Get github access token
:type code: str
:param code:
:rtype: str
:return: access token
"""
token_url = get_config('login.github.access_token_url')
data_to_post = {
"client_id": get_config("login.github.client_id"),
"client_secret": get_config("login.github.client_secret"),
"code": str(code)
}
headers = {"Accept": "application/json"}
token_resp = post_to_remote(token_url, data_to_post, headers)
if token_resp.get("error") is not None:
raise Exception(json.dumps(token_resp))
return str(token_resp.get(b'access_token'), encoding="utf-8")
def get_email(self, token, uid):
"""Get weibo user info
:type token: str
:param token:
:rtype: str
:return : email
"""
email_info_resp = get_remote(
get_config('login.weibo.email_info_url') + token)
email_info_resp_json = json.loads(email_info_resp)
if email_info_resp_json.get("error") is not None:
raise Exception(email_info_resp_json)
return email_info_resp_json['email']
def get_info(self, token):
""" Get qq open id
:type token: str
:param token:
:rtype: dict
:return: info
"""
openid_resp = get_remote(get_config("login.qq.openid_url") + token)
self.log.debug("get access_token from qq:" + token)
info = json.loads(openid_resp[10:-4])
if info.get("error") is not None:
raise Exception(info)
return info
def get_token(self, code, redirect_uri):
""" Get weibo access token
:type code: str
:param code:
:type redirect_uri: str
:param redirect_uri:
:rtype: dict
:return: access token and uid
"""
token_resp = post_to_remote(
get_config('login.weibo.access_token_url') % (redirect_uri, code),
{})
if token_resp.get("error") is not None:
raise Exception(token_resp)
return token_resp
def get_token(self, code, redirect_uri):
""" Get qq access token
:type code: str
:param code: authorization code
:type redirect_uri: str
:param redirect_uri: redirect uri for oauth
:rtype: str
:return: access token
"""
token_resp = get_remote(
get_config("login.qq.access_token_url") % (redirect_uri, code))
if token_resp.find('callback') == 0:
error = json.loads(token_resp[10:-4])
raise Exception(error)
query = qs_dict(token_resp)
return query["access_token"]
def get_user_info(self, token, openid, client_id):
"""Get qq user info
:type token: str
:param token:
:type openid: str
:param openid:
:type client_id: str
:param client_id:
:rtype: dict
:return: user info
"""
url = get_config("login.qq.user_info_url") % (token, client_id, openid)
user_info_resp = get_remote(url)
user_info = convert(json.loads(user_info_resp))
if user_info.get("ret") != 0:
raise Exception(user_info)
return user_info
def __init__(self, app):
"""Initialize APScheduler
:type app: Flask
:param app: the Flask app
"""
self.app = app
self.__apscheduler = None
# NOT instantiate while in flask DEBUG mode or in the main thread
# It's to avoid APScheduler being instantiated twice
if not app.debug or os.environ.get("WERKZEUG_RUN_MAIN") == "true":
self.__apscheduler = BackgroundScheduler(timezone=utc)
# add MySQL job store
job_store_type = safe_get_config("scheduler.job_store", "memory")
if job_store_type == "mysql":
log.debug("add aps_cheduler job store based on mysql")
self.__apscheduler.add_jobstore(
'sqlalchemy',
alias=self.jobstore,
url=get_config("scheduler.job_store_url"))
elif job_store_type == "mongodb":
log.debug("add aps_cheduler job store based on mongodb")
self.__apscheduler.add_jobstore(
'mongodb',
alias=self.jobstore,
database=safe_get_config("scheduler.database",
"apscheduler"),
collection=safe_get_config("scheduler.collection", "jobs"),
host=safe_get_config("scheduler.host", "localhost"),
port=safe_get_config("scheduler.port", 27017))
# add event listener
self.__apscheduler.add_listener(
scheduler_listener,
EVENT_JOB_EXECUTED | EVENT_JOB_ERROR | EVENT_JOB_ADDED)
log.info("APScheduler loaded")
self.__apscheduler.start()
def get_user_info(self, token):
"""Get live user info
:type token: str
:param token:
:rtype: dict
:return:
{'first_name': 'Ice', 'last_name': 'Shi', 'name': 'Ice Shi', 'locale': 'en_US',
'gender': None,
'emails': {'personal': None, 'account': '*****@*****.**', 'business': None, 'preferred': '*****@*****.**'},
'link': 'https://profile.live.com/',
'updated_time': '2015-05-13T02:28:32+0000',
'id': '655c03b1b314b5ee'}
"""
user_info_resp = get_remote(
get_config('login.live.user_info_url') + token)
user_info = json.loads(user_info_resp)
if user_info.get("error") is not None:
raise Exception(user_info)
return user_info
def authing(self, context):
token = context.token
username = context.username
if not token or not username:
self.log.info(
"Unable to handle authing login request. Either token or username is empty. username: "******"Unable to handle authing login request. Either token or username is empty"
)
# validate access token
self.log.info("Validate authing token for user %s" % username)
validate_url = get_config("login.authing.validate_token_url") + token
validate_raw_resp = get_remote(validate_url)
validate_resp = json.loads(validate_raw_resp)
if int(validate_resp["code"]) != 200 or not bool(
validate_resp["status"]):
self.log.info("Token invalid: %s" % validate_raw_resp)
return unauthorized("Token invalid: %s" % validate_raw_resp)
authing_id = context._id
open_id = context.unionid
provider = context.registerMethod
if "oauth" in provider:
# OAuth like github. registerMethod example: "oauth:github"
provider = provider[6:]
else:
# Authing user: using authing_id as open_id
open_id = authing_id
email_list = [{
"email": context.get("email", ""),
"primary": True,
"verified": bool(context.get("emailVerified", False))
}]
user = self.__get_existing_user(open_id, provider)
if user is not None:
nickname = context.get("nickname", user.nickname)
if not nickname:
nickname = user.name
user.update(name=context.get("username", user.name),
nickname=nickname,
access_token=context.get("token", user.access_token),
avatar_url=context.get("photo", user.avatar_url),
authing_id=authing_id,
last_login_time=self.util.get_now(),
login_times=user.login_times + 1,
online=True)
list(
map(lambda x: self.__create_or_update_email(user, x),
email_list))
else:
user = User(openid=open_id,
name=username,
provider=provider,
authing_id=authing_id,
nickname=context.nickname,
access_token=token,
avatar_url=context.get("photo", ""),
login_times=int(context.get("loginsCount", "1")),
online=True)
try:
user.save()
except ValidationError as e:
self.log.error(e)
return internal_server_error("create user fail.")
list(
map(lambda x: self.__create_or_update_email(user, x),
email_list))
# save API token
token_expire_date = self.util.get_now() + timedelta(hours=1)
if "tokenExpiredAt" in context:
try:
token_expire_date = datetime.strptime(
context.tokenExpiredAt, '%a %b %d %Y %H:%M:%S GMT%z (CST)')
except Exception as e:
self.log.warn(
"Unable to parse tokenExpiredAt: %s. Will use 1 hour as expiry."
% context.tokenExpiredAt)
else:
self.log.info(
"tokenExpiredAt not included in authing response. Will use 1 hour as expiry."
)
user_token = UserToken(token=token,
user=user,
expire_date=token_expire_date)
user_token.save()
# resp = {
# "token": user_token.dic(),
# "user": user.dic()
# }
resp = context.to_dict()
resp.update(user.dic())
return resp
