def oauthLogin(provider_name):
authomatic = Authomatic(AUTHOMATIC_CONFIG,
'your secret string',
report_errors=True)
response = make_response()
result = authomatic.login(WerkZeug(request, response), provider_name)
if result:
if result.user:
result.user.update()
appuser = dict(username=result.user.username,
email=result.user.email,
password="******")
logging.debug(appuser)
user = User()
uid = user.get_id(appuser['username'])
if uid is not None:
log_user_in(appuser['username'], uid)
else:
# call register user
message = register_user(appuser)
if message is None:
return log_user_in(appuser['username'], uid)
return str(message)
# query db and see if result.user.email is there,
# if the answer is yes, get username and all stuff for this user
# log him in with the data from our database
# if he is not there then add result.user.email, result.user.stuff
# generate password for him and log him in with that
#log_user_in(appuser.username,appuser.uid) #,True,result.user.email)
return redirect(url_for('startpage', n=0))
return response
def login_with(provider_name):
response = make_response()
authomatic = Authomatic(
{
'default': 'google',
'google': {
'class_': 'authomatic.providers.oauth2.Google',
'consumer_key': '426158043393-j1gnqba0dpucop2o5m9lo7m248vr1744'
'.apps.googleusercontent.com',
'consumer_secret': 'd88vSFHyhZJ63O4ug6GrksTB',
'scope': ['profile', 'email'],
'url': 'https://www.googleapis.com/userinfo/v2/me',
},
}, app.secret_key)
result = authomatic.login(
WerkzeugAdapter(request, response),
provider_name,
None,
session=session,
session_saver=lambda: app.save_session(session, response))
if result and result.user and result.user.credentials:
response = result.provider.access(
authomatic.config.get(provider_name).get('url'))
if response.status == 200:
user = User.first_or_new(email=response.data.get('email'))
user.name = response.data.get('name')
user.save()
login_user(user)
return redirect(url_for('index'))
return response
def login_with(provider_name):
"""
The below is login page action using OAuth with Google
:param provider_name: The provider name. google by default
"""
response = make_response()
authomatic = Authomatic(app.config['SOCIAL_LOGIN'], app.secret_key)
result = authomatic.login(
WerkzeugAdapter(request, response),
provider_name,
None,
session=session,
session_saver=lambda: app.save_session(session, response))
if result and result.user and result.user.credentials:
response = result.provider.access(
authomatic.config.get(provider_name).get('url'))
if response.status == 200:
"""
Create a new user if the provided email is
not exists. Otherwise, update the current user
"""
user = User.first_or_new(email=response.data.get('email'))
user.name = response.data.get('name')
user.save()
login_user(user)
return redirect(url_for('index'))
return response
def includeme(config: Configurator) -> None:
"""Pyramid knob."""
settings = config.registry.settings
# Pyramid requires an authorization policy to be active.
config.set_authorization_policy(ACLAuthorizationPolicy())
# Enable JWT authentication.
config.include("pyramid_jwt")
config.set_jwt_authentication_policy(
config.registry.settings["jwt.secret"], auth_type="Token"
)
# Add API routes for auth
config.add_route("user", "/api/user")
config.add_route("login", "/login")
# Add request.user shorthand
config.add_request_method(get_user, "user", reify=True)
# Add request.authomatic shorthand
authomatic = Authomatic(
config={
"github": {
"class_": oauth2.GitHub,
"consumer_key": settings["github.consumer_key"],
"consumer_secret": settings["github.consumer_secret"],
"access_headers": {"User-Agent": "getoffmylawn"},
}
},
secret=settings["jwt.secret"],
)
config.add_request_method(lambda self: authomatic, "authomatic", reify=True)
def init_app(self, app):
if app.config.get("MODULE_USER_ACCOUNT_ENABLE_OAUTH_LOGIN"):
secret = app.config.get("SECRET_KEY")
providers = app.config.get("MODULE_USER_ACCOUNT_OAUTH_PROVIDERS")
config = {}
auth_providers = []
for provider, conf in list(providers.items()):
if hasattr(oauth2, provider):
cls = getattr(oauth2, provider)
conf[
"class_"] = conf["class_"] if "class_" in conf else cls
elif hasattr(oauth1, provider):
cls = getattr(oauth1, provider)
conf[
"class_"] = conf["class_"] if "class_" in conf else cls
else:
continue
conf["id"] = provider_id()
_provider = provider.lower()
auth_providers.append(_provider)
config[_provider] = conf
self.oauth = Authomatic(config=config,
secret=secret,
session=session,
report_errors=True)
Juice.g(OAUTH_PROVIDERS=auth_providers)
def get_authomatic(request):
settings = request.registry.settings
# authomatic social auth
authomatic_conf = {
# callback http://yourapp.com/social_auth/twitter
'twitter': {
'class_': oauth1.Twitter,
'consumer_key': settings.get('authomatic.pr.twitter.key', 'X'),
'consumer_secret': settings.get('authomatic.pr.twitter.secret',
'X'),
},
# callback http://yourapp.com/social_auth/facebook
'facebook': {
'class_': oauth2.Facebook,
'consumer_key': settings.get('authomatic.pr.facebook.app_id', 'X'),
'consumer_secret': settings.get('authomatic.pr.facebook.secret',
'X'),
'scope': ['email'],
},
# callback http://yourapp.com/social_auth/google
'google': {
'class_': oauth2.Google,
'consumer_key': settings.get('authomatic.pr.google.key', 'X'),
'consumer_secret': settings.get('authomatic.pr.google.secret',
'X'),
'scope': ['email'],
}
}
return Authomatic(config=authomatic_conf,
secret=settings['authomatic.secret'])
def __call__(self):
cfg = authomatic_cfg()
if cfg is None:
return "Authomatic is not configured"
if not (
ISiteRoot.providedBy(self.context)
or INavigationRoot.providedBy(self.context)
):
# callback url is expected on either navigationroot or site root
# so bevor going on redirect
root = api.portal.get_navigation_root(self.context)
self.request.response.redirect(
"{0}/authomatic-handler/{1}".format(
root.absolute_url(), getattr(self, 'provider', '')
)
)
return "redirecting"
if not hasattr(self, 'provider'):
return self.template()
if self.provider not in cfg:
return "Provider not supported"
if not self.is_anon:
if self.provider in self._provider_names:
raise ValueError(
'Provider {0} is already connected to current '
'user.'.format(self.provider)
)
# TODO: some sort of CSRF check might be needed, so that
# not an account got connected by CSRF. Research needed.
pass
secret = authomatic_settings().secret
if six.PY2 and isinstance(secret, six.text_type):
secret = secret.encode('utf8')
auth = Authomatic(cfg, secret=secret)
result = auth.login(ZopeRequestAdapter(self), self.provider)
if not result:
logger.info('return from view')
# let authomatic do its work
return
if result.error:
return result.error.message
display = cfg[self.provider].get('display', {})
provider_name = display.get('title', self.provider)
if not self.is_anon:
# now we delegate to PAS plugin to add the identity
self._add_identity(result, provider_name)
self.request.response.redirect(
"{0}".format(self.context.absolute_url())
)
else:
# now we delegate to PAS plugin in order to login
self._remember_identity(result, provider_name)
if api.env.plone_version() < '5.2':
self.request.response.redirect(
"{0}/login_success".format(self.context.absolute_url())
)
else:
self.request.response.redirect(self.context.absolute_url())
return "redirecting"
def authomatic_setup(request):
magpie_secret = get_constant("MAGPIE_SECRET",
request,
settings_name="magpie.secret")
return Authomatic(config=authomatic_config(request),
secret=magpie_secret,
logger=AUTHOMATIC_LOGGER,
report_errors=True,
logging_level=AUTHOMATIC_LOGGER.level)
def login(self, request):
authomatic = Authomatic(self.config, self.key, report_errors=True)
response = make_response()
result = authomatic.login(WerkzeugAdapter(request, response),
self.provider)
return response, result
def setup_authomatic(app):
authomatic = Authomatic(app.config['OAUTH_CONFIG'],
app.config['SECRET_KEY'],
report_errors=True)
def func():
g.authomatic = authomatic
return func
def init_app(app):
if app.config['AUTH_PROVIDERS'] is None:
raise RuntimeError('You must configure the authentication providers. For more info look at the local.conf file')
app.authomatic = Authomatic(
app.config['AUTH_PROVIDERS'],
app.config['APP_SECRET_KEY'],
report_errors=False
)
app.register_blueprint(mod)
def __init__(self):
self.authomatic_config = {
'google': {
'class_': oauth2.Google,
'consumer_key': app.config['GOOGLE_OAUTH_CLIENT_ID'],
'consumer_secret': app.config['GOOGLE_OAUTH_CONSUMER_SECRET'],
'scope': ['profile', 'email']
}
}
self.authomatic = Authomatic(self.authomatic_config,
app.config['AUTHOMATIC_SALT'])
def oauth(request, provider):
response = HttpResponse()
authomatic = Authomatic(get_setting(settings.AUTHOMATIC_CONFIG, request),
get_setting(settings.SECRET_KEY, request))
result = authomatic.login(DjangoAdapter(request, response), provider)
if result:
if result.error:
messages.error(
request, 'There was an error signing you in. Please try again')
return HttpResponseRedirect(reverse('sign_in'))
if result.user:
# Then user is being redirected back from provider with their data
#
# OAuth 2.0 and OAuth 1.0a provide only limited user data on login,
# We need to update the user to get more info.
if not (result.user.name and result.user.id):
result.user.update()
provider = result.provider.name
user = KagisoUser.get_user_from_auth_db(result.user.email)
if user:
_social_login(request, user.email, provider)
return HttpResponseRedirect('/')
else:
gender = result.user.gender
if gender:
# Form constants (region, gender) are in uppercase
gender = gender.upper()
data = {
'provider': provider,
'email': result.user.email,
'first_name': result.user.first_name,
'last_name': result.user.last_name,
'gender': gender,
'birth_date': result.user.birth_date,
}
request.session['oauth_data'] = data
return HttpResponseRedirect(reverse('sign_up'))
# If result.user is None then user will be redirected to provider
# to authenticate themselves, prior to being redirected back to this view.
return response
def view_authomatic_(self, config, e):
response = Response()
provider_name = e.context.name
logger.info('using provider %r' % provider_name)
if not provider_name in config:
msg = 'I got to the URL for provider %r even though it is not in the config.' % provider_name
raise ValueError(msg)
authomatic = Authomatic(config=config, secret='some random secret string')
url_base_public = self.options.url_base_public
url_base_internal = self.options.url_base_internal
if not ((url_base_public is None) == (url_base_public is None)):
msg = 'Only one of url_base_public and url_base_internal is specified.'
raise Exception(msg)
result = authomatic.login(
MyWebObAdapter(e.request, response, url_base_internal,
url_base_public), provider_name)
if not result:
return response
# If there is result, the login procedure is over and we can write to response.
response.write('<a href="..">Home</a>')
if result.error:
# Login procedure finished with an error.
msg = result.error.message
return self.show_error(e, msg, status=500)
elif result.user:
# OAuth 2.0 and OAuth 1.0a provide only limited user data on login,
# We need to update the user to get more info.
# if not (result.user.name and result.user.id):
result.user.update()
s = "user info: \n"
for k, v in result.user.__dict__.items():
s += '\n %s : %s' % (k, v)
logger.debug(s)
next_location = config.get('next_location', e.root)
handle_auth_success(self, e, provider_name, result, next_location)
#
# response.write('<pre>'+s+'</pre>')
# # Welcome the user.
# response.write(u'<h1>Hi {0}</h1>'.format(result.user.name))
# response.write(u'<h2>Your id is: {0}</h2>'.format(result.user.id))
# response.write(u'<h2>Your email is: {0}</h2>'.format(result.user.email))
# just regular login
return response
def login_view(self):
log.debug('login_view')
response = Response()
dpconf = dict(class_=oauth2.Dataporten,
consumer_key=self.settings.get('oauth_client_id', ''),
consumer_secret=self.settings.get(
'oauth_client_secret', ''))
authomatic = Authomatic(config=dict(dp=dpconf), secret='mumbojumbo')
result = authomatic.login(WebObAdapter(self.request, response), 'dp')
if result:
# The login procedure is over
log.debug('login_view - login complete')
return self.login_complete(result)
else:
log.debug('login_view - login not complete')
return response
async def redirect_login_record_session_google(request):
success_cb, error_cb, adapter, first_response = oauth_init(request)
if adapter is None:
return first_response
authomatic = Authomatic(config=CONFIG, secret=SECRET_SALT)
result = authomatic.login(adapter, 'fb',
# session=session['authomatic'],
session_saver=lambda: None)
if result:
if result.error:
warning("FB login error", result.error)
return response.redirect('%s?error=%s' % (error_cb, result.error))
elif result.user:
debug("FB login success", result.user)
result.user.update()
user_dict = result.user.__dict__
debug("FB retrieving email", user_dict)
rea = authomatic.access(result.user.credentials,
'https://graph.facebook.com/' + result.user.id + '?fields=email')
user_email = json.loads(rea.read().decode('utf-8'))["email"]
debug("FB login update success", result.user)
return upsert_login_redirect(request, "facebook:" + user_email,
{'email': user_email,
'id': user_dict['id'],
'username': user_dict['username'],
'name': user_dict['name'],
'first_name': user_dict['first_name'],
'last_name': user_dict['last_name'],
'nickname': user_dict['nickname'],
'link': user_dict['link'],
'gender': user_dict['gender'],
'timezone': user_dict['timezone'],
'locale': user_dict['locale'],
'birth_date': user_dict['birth_date'],
'country': user_dict['country'],
'city': user_dict['city'],
'location': user_dict['location'],
'postal_code': user_dict['postal_code'],
'picture': user_dict['picture'],
'phone': user_dict['phone'],
}, success_cb, adapter)
return adapter.response
def setup_authomatic(app):
authomatic = Authomatic(
{
'fb': {
'consumer_key': app.config['CONSUMER_KEY'],
'consumer_secret': app.config['CONSUMER_SECRET'],
'class_': oauth2.Facebook,
'scope': [],
}
},
app.config['SECRET_KEY'],
report_errors=False)
def func():
g.authomatic = authomatic
return func
def configure_oauth(settings): # pragma: no cover
CONFIG = {
'fb': {
'class_': oauth2.Facebook,
'consumer_key': settings['facebook.key'],
'consumer_secret': settings['facebook.secret'],
'scope': ['email']
},
'google': {
'class_': oauth2.Google,
'consumer_key': settings['google.key'],
'consumer_secret': settings['google.secret'],
'scope': ['email']
}
}
authomatic = Authomatic(config=CONFIG, secret="giftpacito")
return authomatic
def get_authomatic(request):
settings = request.registry.settings
# authomatic social auth
authomatic_conf = {
# callback http://yourapp.com/social_auth/twitter
'twitter': {
'class_': oauth1.Twitter,
'consumer_key': settings.get('authomatic.pr.twitter.key', ''),
'consumer_secret': settings.get('authomatic.pr.twitter.secret',
''),
},
# callback http://yourapp.com/social_auth/facebook
'facebook': {
'class_': oauth2.Facebook,
'consumer_key': settings.get('authomatic.pr.facebook.app_id', ''),
'consumer_secret': settings.get('authomatic.pr.facebook.secret',
''),
'scope': ['email'],
},
# callback http://yourapp.com/social_auth/google
'google': {
'class_': oauth2.Google,
'consumer_key': settings.get('authomatic.pr.google.key', ''),
'consumer_secret': settings.get('authomatic.pr.google.secret', ''),
'scope': ['profile', 'email'],
},
'github': {
'class_': oauth2.GitHub,
'consumer_key': settings.get('authomatic.pr.github.key', ''),
'consumer_secret': settings.get('authomatic.pr.github.secret', ''),
'scope': ['repo', 'public_repo', 'user:email'],
'access_headers': {
'User-Agent': 'AppEnlight'
},
},
'bitbucket': {
'class_': oauth1.Bitbucket,
'consumer_key': settings.get('authomatic.pr.bitbucket.key', ''),
'consumer_secret': settings.get('authomatic.pr.bitbucket.secret',
'')
}
}
return Authomatic(config=authomatic_conf,
secret=settings['authomatic.secret'])
def __call__(self):
cfg = authomatic_cfg()
if cfg is None:
return "Authomatic is not configured"
if not (ISiteRoot.providedBy(self.context)
or INavigationRoot.providedBy(self.context)):
# callback url is expected on either navigationroot or site root
# so bevor going on redirect
root = api.portal.get_navigation_root(self.context)
self.request.response.redirect("{}/authomatic-handler/{}".format(
root.absolute_url(), getattr(self, "provider", "")))
return "redirecting"
if not getattr(self, "provider", None):
return self.template()
if self.provider not in cfg:
return "Provider not supported"
if not self.is_anon:
if self.provider in self._provider_names:
logger.warn(
"Provider %s is already connected to current "
"user.", self.provider)
return self._redirect()
# TODO: some sort of CSRF check might be needed, so that
# not an account got connected by CSRF. Research needed.
pass
secret = authomatic_settings().secret
auth = Authomatic(cfg, secret=secret)
result = auth.login(ZopeRequestAdapter(self), self.provider)
if not result:
logger.info("return from view")
# let authomatic do its work
return
if result.error:
return result.error.message
display = cfg[self.provider].get("display", {})
provider_name = display.get("title", self.provider)
if not self.is_anon:
# now we delegate to PAS plugin to add the identity
self._add_identity(result, provider_name)
else:
# now we delegate to PAS plugin in order to login
self._remember_identity(result, provider_name)
return self._redirect()
def __init__(self):
print("Start server")
self.printers = []
self.printer_class = {}
self.db = pymongo.MongoClient('localhost', 27017)['SunAlert']
self.authomatic = Authomatic(CONFIG,
'your secret string',
report_errors=False)
self.app = Flask('SunAlert')
self.start()
self.app.config['TEMPLATES_AUTO_RELOAD'] = True
self.app.config['TESTING'] = True
self.app.config['DEBUG'] = True
self.app.config['ENV'] = "development"
self.app.run(host="0.0.0.0", port=9999)
def init_app(self, app):
if self._authomatic:
return
self._authomatic = Authomatic(config={
'facebook': {
'class_': oauth2.Facebook,
'consumer_key': app.config['FB_CONSUMER_KEY'],
'consumer_secret': app.config['FB_CONSUMER_SECRET'],
'scope': ['public_profile', 'email'],
},
'google': {
'class_': oauth2.Google,
'consumer_key': app.config['GOOGLE_CONSUMER_KEY'],
'consumer_secret': app.config['GOOGLE_CONSUMER_SECRET'],
'scope': ['profile', 'email'],
},
},
secret=app.config['SECRET_KEY'],
debug=True,
logger=app.logger)
def includeme(config):
"""
The authomatic config should look something like this:
'fb': {
'class_': authomatic.providers.oauth2.Facebook,
# Facebook is an AuthorizationProvider too.
'consumer_key': '########################',
'consumer_secret': '########################',
# But it is also an OAuth 2.0 provider and it needs scope.
'scope': ['user_about_me', 'email', 'publish_stream'],
},
So we need to resolve the 'class_' part for whatever we have configured.
For this project we'll also keep the secret within this file
"""
authomatic_file = config.registry.settings.get('kedja.authomatic', '')
if authomatic_file:
with open(authomatic_file, 'r') as f:
auth_config = yaml.safe_load(f)
secret = auth_config.pop('secret', None)
if secret is None:
logger.warning("'secret' is missing within the automatic configuration. A random secret will be used.")
secret = str(uuid4())
# Fix all class names within the configuration
for k, section in auth_config.items():
if 'class_' in section:
section['class_'] = config.maybe_dotted(section['class_'])
else:
raise ConfigurationError("The section '%s' lacks the 'class_' key which is required." % k)
authomatic = Authomatic(config=auth_config, secret=secret)
config.registry.registerUtility(authomatic, IAuthomatic)
logger.debug("Registered authomatic with providers: '%s'" % ", ".join(auth_config.keys()))
else:
logger.warning("'kedja.authomatic' is missing in the paster.ini file. "
"It should point to a yaml file with Authomatic configuration. "
"Login with authomatic will be disabled!")
def login(provider_name):
"""
Login handler, must accept both GET and POST to be able to use OpenID.
"""
authomatic = Authomatic(current_app.config['AUTHOMATIC'],
current_app.config['SECRET_KEY'],
report_errors=False)
# We need response object for the WerkzeugAdapter.
response = make_response()
# Log the user in, pass it the adapter and the provider name.
result = authomatic.login(WerkzeugAdapter(request, response),
provider_name)
# If there is no LoginResult object, the login procedure is still pending.
if result:
if result.user:
if not (result.user.first_name and result.user.last_name
and result.user.id and result.user.email):
# We need to update the user to get more info.
result.user.update()
if not result.user.email.endswith("@thenewmotion.com"):
return current_app.login_manager.unauthorized()
user = User.query.filter_by(email=result.user.email).first()
if not user:
user = User(result.user.email,
first_name=result.user.first_name,
last_name=result.user.last_name,
active=True)
db.session.add(user)
db.session.commit()
login_user(user)
flash("Logged in successfully.", category="success")
# The rest happens inside the template.
return redirect(request.args.get('next') or url_for('public.home'))
# Don't forget to return the response.
return response
def __init__(self,
app,
datastore,
geoip=None,
celery=None,
message_cls=None,
authomatic=None,
views=None,
schemas=None,
add_api_routes=True):
self.app = app
self.datastore = datastore
self.config = config = self.config_cls(app.config)
self.request_utils = self.request_utils_cls(config, geoip)
self.emails = self.emails_cls(config, message_cls, celery)
self.authomatic = authomatic or Authomatic(
config['AUTHOMATIC_CONFIG'], config['AUTHOMATIC_SECRET_KEY'])
self.schemas = schemas or self.schemas
self.views = views or self.views
self.blueprint = Blueprint('userflow',
'flask_userflow',
url_prefix=config['URL_PREFIX'],
subdomain=config['SUBDOMAIN'],
template_folder='templates')
if add_api_routes:
_add_api_routes(config, self.views, self.blueprint)
app.register_blueprint(self.blueprint)
self._init_login_manager()
self._init_principal()
self.auth_token_serializer = self._create_serializer('auth_token')
self.register_confirm_serializer = self._create_serializer(
'register_confirm')
self.restore_confirm_serializer = \
self._create_serializer('restore_confirm')
async def redirect_login_record_session_google(request):
success_cb, error_cb, adapter, first_response = oauth_init(request)
if adapter is None:
return first_response
authomatic = Authomatic(config=CONFIG, secret=SECRET_SALT)
result = authomatic.login(adapter, 'google',
# session=session['authomatic'],
session_saver=lambda: None)
if result:
if result.error:
warning("Google login error", result.error)
return response.redirect('%s?error=%s' % (error_cb, result.error))
elif result.user:
debug("Google login success", result.user)
result.user.update()
debug("Google login update success", result.user)
userdict = result.user.to_dict()
return upsert_login_redirect(request, "google:" + userdict['email'], result.user.to_dict(), success_cb, adapter)
return adapter.response
def get_authomatic(request):
settings = request.registry.settings
# authomatic social auth
authomatic_conf = {
# callback http://yourapp.com/social_auth/twitter
"twitter": {
"class_": oauth1.Twitter,
"consumer_key": settings.get("authomatic.pr.twitter.key", ""),
"consumer_secret": settings.get("authomatic.pr.twitter.secret", ""),
},
# callback http://yourapp.com/social_auth/facebook
"facebook": {
"class_": oauth2.Facebook,
"consumer_key": settings.get("authomatic.pr.facebook.app_id", ""),
"consumer_secret": settings.get("authomatic.pr.facebook.secret", ""),
"scope": ["email"],
},
# callback http://yourapp.com/social_auth/google
"google": {
"class_": oauth2.Google,
"consumer_key": settings.get("authomatic.pr.google.key", ""),
"consumer_secret": settings.get("authomatic.pr.google.secret", ""),
"scope": ["profile", "email"],
},
"github": {
"class_": oauth2.GitHub,
"consumer_key": settings.get("authomatic.pr.github.key", ""),
"consumer_secret": settings.get("authomatic.pr.github.secret", ""),
"scope": ["repo", "public_repo", "user:email"],
"access_headers": {"User-Agent": "AppEnlight"},
},
"bitbucket": {
"class_": oauth1.Bitbucket,
"consumer_key": settings.get("authomatic.pr.bitbucket.key", ""),
"consumer_secret": settings.get("authomatic.pr.bitbucket.secret", ""),
},
}
return Authomatic(config=authomatic_conf, secret=settings["authomatic.secret"])
def facebook_login_view(request):
from pyramid.response import Response
from authomatic.providers import oauth2
from authomatic.adapters import WebObAdapter
from authomatic import Authomatic
CONFIG = {
'fb': {
'class_': oauth2.Facebook,
'consumer_key': request.registry.settings['facebook.key'],
'consumer_secret': request.registry.settings['facebook.secret'],
'scope': ['public_profile', 'email']
}
}
authomatic = Authomatic(config=CONFIG, secret='mysecret')
response = Response()
result = authomatic.login(WebObAdapter(request, response), 'fb')
if result:
if result.error:
response.write(result.error.message)
elif result.user:
if result.user.credentials:
url = 'https://graph.facebook.com/me?fields=id,name,email,first_name,last_name'
fb_response = result.provider.access(url)
if fb_response.status == 200:
data = fb_response.data
response.write('facebook id: {} <br />'.format(data['id']))
response.write('facebook name: {} <br />'.format(
data['name']))
response.write('facebook first name: {} <br />'.format(
data['first_name']))
response.write('facebook last name: {} <br />'.format(
data['last_name']))
response.write('facebook email: {} <br />'.format(
data['email']))
return response
'class_':
oauth2.Google,
'consumer_key':
os.environ.get('GOOGLE_OAUTH_CLIENT_ID'),
'consumer_secret':
os.environ.get('GOOGLE_OAUTH_CONSUMER_SECRET'),
'scope': [
'https://www.googleapis.com/auth/drive',
'https://www.googleapis.com/auth/userinfo.email'
],
'offline':
True,
},
}
authomatic = Authomatic(authomatic_config, os.environ.get('AUTHOMATIC_SALT'))
"""
Logging
"""
LOG_FORMAT = '%(levelname)s:%(name)s:%(asctime)s: %(message)s'
"""
Utilities
"""
def get_secrets():
"""
A method for accessing our secrets.
"""
secrets_dict = {}
js = Bundle(
#NOTE that these js files have to be loaded in a specific order.
'js/vendor/*.js',
'js/jquery/*.js',
'js/foundation.min.js',
'js/custom.js',
filters='jsmin',
output='gen/packed.js')
assets.register('js_all', js)
css = Bundle('css/*.css', filters='yui_css', output='gen/packed.css')
assets.register('css_all', css)
#########################################################################
authomatic = Authomatic(CONFIG, 'random secret string for session signing')
@app.route('/login/<provider_name>/', methods=['GET', 'POST'])
def login(provider_name):
response = make_response()
result = authomatic.login(WerkzeugAdapter(request, response),
provider_name)
if result:
print "found result"
# procedure is complete
if result.user:
print "found result user"
# ensure that the user is up to date....
result.user.update()
if (result.user.name and result.user.id):
