def setUp(self):
super(TestCallbackView, self).setUp()
self.user = AuthUserFactory()
self.external_account = ExternalAccountFactory()
self.institution = InstitutionFactory()
self.provider = MockOAuth2Provider(self.external_account)
self.user.affiliated_institutions.add(self.institution)
app = flask.Flask(__name__)
make_url_map(app)
app.config['SECRET_KEY'] = 'aaaaa'
self.ctx = app.test_request_context()
self.ctx.push()
self.request = RequestFactory().get('/fake_path')
add_session_to_request(self.request)
self.view0 = views.ConnectView()
self.view0 = setup_user_view(self.view0, self.request, user=self.user)
self.view0.kwargs = {
'addon_name': self.external_account.provider,
'institution_id': self.institution.id,
}
self.view = views.CallbackView()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {
'addon_name': self.external_account.provider,
'institution_id': self.institution.id,
}
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
logger.info(
'Initializing the application from process {}, thread {}.'.format(
os.getpid(), thread.get_ident()))
# The settings module
settings = importlib.import_module(settings_module)
init_addons(settings, routes)
with open(
os.path.join(settings.STATIC_FOLDER, 'built',
'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
# default config for flask app, however, this does not affect setting cookie using set_cookie()
app.config['SESSION_COOKIE_SECURE'] = settings.SESSION_COOKIE_SECURE
app.config['SESSION_COOKIE_HTTPONLY'] = settings.SESSION_COOKIE_HTTPONLY
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Deprecated.
:param routes: Whether to set the url map.
"""
# Ensure app initialization only takes place once
if app.config.get('IS_INITIALIZED', False) is True:
return app
setup_django()
# The settings module
settings = importlib.import_module(settings_module)
init_addons(settings, routes)
with open(
os.path.join(settings.STATIC_FOLDER, 'built',
'nodeCategories.json'), 'w') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
app.debug = settings.DEBUG_MODE
# default config for flask app, however, this does not affect setting cookie using set_cookie()
app.config['SESSION_COOKIE_SECURE'] = settings.SESSION_COOKIE_SECURE
app.config['SESSION_COOKIE_HTTPONLY'] = settings.SESSION_COOKIE_HTTPONLY
app.config['SESSION_COOKIE_SAMESITE'] = settings.SESSION_COOKIE_SAMESITE
if routes:
try:
from website.routes import make_url_map
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
apply_middlewares(app, settings)
app.config['IS_INITIALIZED'] = True
return app
def init_app(settings_module='website.settings', set_backends=True, routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
logger.info('Initializing the application from process {}, thread {}.'.format(
os.getpid(), thread.get_ident()
))
# The settings module
settings = importlib.import_module(settings_module)
init_addons(settings, routes)
with open(os.path.join(settings.STATIC_FOLDER, 'built', 'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
# default config for flask app, however, this does not affect setting cookie using set_cookie()
app.config['SESSION_COOKIE_SECURE'] = settings.SESSION_COOKIE_SECURE
app.config['SESSION_COOKIE_HTTPONLY'] = settings.SESSION_COOKIE_HTTPONLY
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
mfr=False,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
build_js_config_files(settings)
app.debug = settings.DEBUG_MODE
if mfr:
init_mfr(app)
if set_backends:
logger.debug('Setting storage backends')
set_up_storage(
website.models.MODELS,
storage.MongoStorage,
addons=settings.ADDONS_AVAILABLE,
)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
apply_middlewares(app, settings)
return app
def init_app(settings_module='website.settings',
set_backends=True,
routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
with open(
os.path.join(settings.STATIC_FOLDER, 'built',
'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def init_app():
from framework.flask import app
try:
make_url_map(app)
except AssertionError:
pass
init_addons(website_settings)
attach_handlers(app, website_settings)
for addon in website_settings.ADDONS_AVAILABLE:
try:
addon.ready()
except AssertionError:
pass
return app
def init_app(settings_module='website.settings', set_backends=True, routes=True, mfr=False,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
build_js_config_files(settings)
app.debug = settings.DEBUG_MODE
if mfr:
init_mfr(app)
if set_backends:
logger.debug('Setting storage backends')
set_up_storage(
website.models.MODELS,
storage.MongoStorage,
addons=settings.ADDONS_AVAILABLE,
)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
apply_middlewares(app, settings)
return app
def init_app(settings_module='website.settings', set_backends=True, routes=True,
attach_request_handlers=True):
"""Initializes the OSF. A sort of pseudo-app factory that allows you to
bind settings, set up routing, and set storage backends, but only acts on
a single app instance (rather than creating multiple instances).
:param settings_module: A string, the settings module to use.
:param set_backends: Whether to set the database storage backends.
:param routes: Whether to set the url map.
"""
# The settings module
settings = importlib.import_module(settings_module)
build_log_templates(settings)
init_addons(settings, routes)
with open(os.path.join(settings.STATIC_FOLDER, 'built', 'nodeCategories.json'), 'wb') as fp:
json.dump(settings.NODE_CATEGORY_MAP, fp)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'api.base.settings')
django.setup()
app.debug = settings.DEBUG_MODE
if set_backends:
do_set_backends(settings)
if routes:
try:
make_url_map(app)
except AssertionError: # Route map has already been created
pass
if attach_request_handlers:
attach_handlers(app, settings)
if app.debug:
logger.info("Sentry disabled; Flask's debug mode enabled")
else:
sentry.init_app(app)
logger.info("Sentry enabled; Flask's debug mode disabled")
if set_backends:
ensure_schemas()
ensure_licenses()
apply_middlewares(app, settings)
return app
def _send_claim_email(self, *args, **kwargs):
""" This avoids needing to reimplement all of the logic in the sender methods.
When v1 is more fully deprecated, those send hooks should be reworked to not
rely upon a flask context and placed in utils (or elsewhere).
:param bool registered: Indicates which sender to call (passed in as keyword)
:param *args: Positional arguments passed to senders
:param **kwargs: Keyword arguments passed to senders
:return: None
"""
from website.app import app
from website.routes import make_url_map
try:
make_url_map(app)
except AssertionError:
# Already mapped
pass
ctx = app.test_request_context()
ctx.push()
if kwargs.pop('registered', False):
send_claim_registered_email(*args, **kwargs)
else:
send_claim_email(*args, **kwargs)
ctx.pop()
def _send_claim_email(self, *args, **kwargs):
""" This avoids needing to reimplement all of the logic in the sender methods.
When v1 is more fully deprecated, those send hooks should be reworked to not
rely upon a flask context and placed in utils (or elsewhere).
:param bool registered: Indicates which sender to call (passed in as keyword)
:param *args: Positional arguments passed to senders
:param **kwargs: Keyword arguments passed to senders
:return: None
"""
from website.app import app
from website.routes import make_url_map
try:
make_url_map(app)
except AssertionError:
# Already mapped
pass
ctx = app.test_request_context()
ctx.push()
if kwargs.pop('registered', False):
send_claim_registered_email(*args, **kwargs)
else:
send_claim_email(*args, **kwargs)
ctx.pop()
class RdmAddonRequestContextMixin(object):
app = flask.Flask(__name__)
make_url_map(app)
app.config['SECRET_KEY'] = str(uuid.uuid4())
ctx_dict = defaultdict(app.test_request_context)
def get_request_context(self, session_id, institution_id, addon_name):
return self.ctx_dict[(session_id, institution_id, addon_name)]
def get_session(self, addon_name):
if addon_name == 'dropbox':
return addons.dropbox.models.session
return osf.models.external.session
def get_callback_url_func(self, addon_name):
"""Get a function that returns the OAuth Callback Admin'sURL """
def web_url_for(view_name, _absolute=False, _internal=False, _guid=False, *args, **kwargs):
path = 'oauth/callback/{}/'.format(addon_name)
return urljoin(website_settings.ADMIN_URL, path)
return web_url_for
