def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = ResetPasswordConfig.init_config(ns='webapp', app_name=name, test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: ResetPasswordConfig = cast(ResetPasswordConfig, self.config) # type: ignore
# Register views
from eduid_webapp.reset_password.views.reset_password import reset_password_views
from eduid_webapp.reset_password.views.change_password import change_password_views
self.register_blueprint(change_password_views)
self.register_blueprint(reset_password_views)
# Register view path that should not be authorized
no_authn_views(self, [r'/reset.*', r'/new-password/?'])
# Init celery
msg.init_relay(self)
am.init_relay(self, 'eduid_reset_password')
mail_relay.init_relay(self)
translation.init_babel(self)
# Init dbs
self.private_userdb = ResetPasswordUserDB(self.config.mongo_uri)
self.password_reset_state_db = ResetPasswordStateDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
self.authninfo_db = AuthnInfoDB(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = SecurityConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: SecurityConfig = cast(SecurityConfig,
self.config) # type: ignore
from eduid_webapp.security.views.security import security_views
from eduid_webapp.security.views.u2f import u2f_views
from eduid_webapp.security.views.webauthn import webauthn_views
from eduid_webapp.security.views.reset_password import reset_password_views
self.register_blueprint(security_views)
self.register_blueprint(u2f_views)
self.register_blueprint(webauthn_views)
self.register_blueprint(reset_password_views)
# Register view path that should not be authorized
no_authn_views(self, ['/reset-password.*'])
am.init_relay(self, f'eduid_{name}')
msg.init_relay(self)
mail_relay.init_relay(self)
translation.init_babel(self)
self.private_userdb = SecurityUserDB(self.config.mongo_uri)
self.authninfo_db = AuthnInfoDB(self.config.mongo_uri)
self.password_reset_state_db = PasswordResetStateDB(
self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = OIDCProofingConfig.init_config(ns='webapp', app_name=name, test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: OIDCProofingConfig = cast(OIDCProofingConfig, self.config) # type: ignore
from eduid_webapp.oidc_proofing.views import oidc_proofing_views
self.register_blueprint(oidc_proofing_views)
# Register view path that should not be authorized
no_authn_views(self, ['/authorization-response'])
# Initialize the oidc_client after views to be able to set correct redirect_uris
oidc.init_client(self)
# Init celery
msg.init_relay(self)
am.init_relay(self, 'eduid_oidc_proofing')
mail_relay.init_relay(self)
# Init babel
translation.init_babel(self)
# Initialize db
self.private_userdb = OidcProofingUserDB(self.config.mongo_uri)
self.proofing_statedb = OidcProofingStateDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = OrcidConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: OrcidConfig = cast(OrcidConfig,
self.config) # type: ignore
# Register views
from eduid_webapp.orcid.views import orcid_views
self.register_blueprint(orcid_views)
# Init dbs
self.private_userdb = OrcidProofingUserDB(self.config.mongo_uri)
self.proofing_statedb = OrcidProofingStateDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
# Init celery
am.init_relay(self, 'eduid_orcid')
# Initialize the oidc_client
oidc.init_client(self)
def pd_init_app(name, config):
"""
Create an instance of an eduid personal data app.
First, it will load the configuration from personal_data.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.personal_data.views import pd_views
app.register_blueprint(pd_views)
app = am.init_relay(app, 'eduid_personal_data')
app.private_userdb = PersonalDataUserDB(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def init_lookup_mobile_proofing_app(name, config=None):
"""
:param name: The name of the instance, it will affect the configuration loaded.
:param config: any additional configuration settings. Specially useful
in test cases
:type name: str
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
# Register views
from eduid_webapp.lookup_mobile_proofing.views import mobile_proofing_views
app.register_blueprint(mobile_proofing_views)
# Init dbs
app.private_userdb = LookupMobileProofingUserDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
# Init celery
app = lookup_mobile_relay.init_relay(app)
app = msg.init_relay(app)
app = am.init_relay(app, 'eduid_lookup_mobile_proofing')
app.logger.info('{!s} initialized'.format(name))
return app
def init_orcid_app(name, config=None):
"""
:param name: The name of the instance, it will affect the configuration loaded.
:param config: any additional configuration settings. Specially useful
in test cases
:type name: str
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
# Register views
from eduid_webapp.orcid.views import orcid_views
app.register_blueprint(orcid_views)
# Init dbs
app.private_userdb = OrcidProofingUserDB(app.config['MONGO_URI'])
app.proofing_statedb = OrcidProofingStateDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
# Init celery
app = am.init_relay(app, 'eduid_orcid')
# Initialize the oidc_client
app = oidc.init_client(app)
app.logger.info('{!s} initialized'.format(name))
return app
def init_letter_proofing_app(name, config=None):
"""
:param name: The name of the instance, it will affect the configuration loaded.
:param config: any additional configuration settings. Specially useful
in test cases
:type name: str
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
# Register views
from eduid_webapp.letter_proofing.views import letter_proofing_views
app.register_blueprint(letter_proofing_views,
url_prefix=app.config.get('APPLICATION_ROOT', None))
# Init dbs
app.proofing_statedb = LetterProofingStateDB(app.config['MONGO_URI'])
app.proofing_userdb = LetterProofingUserDB(app.config['MONGO_URI'])
# Init celery
app = msg.init_relay(app)
app = am.init_relay(app, 'eduid_letter_proofing')
# Initiate external modules
app.ekopost = Ekopost(app)
app.logger.info('{!s} initialized'.format(name))
return app
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = PhoneConfig.init_config(ns='webapp', app_name=name, test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: PhoneConfig = cast(PhoneConfig, self.config) # type: ignore
from eduid_webapp.phone.views import phone_views
self.register_blueprint(phone_views)
am.init_relay(self, 'eduid_phone')
msg.init_relay(self)
self.private_userdb = PhoneProofingUserDB(self.config.mongo_uri)
self.proofing_statedb = PhoneProofingStateDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = FlaskConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: FlaskConfig = cast(FlaskConfig,
self.config) # type: ignore
from eduid_webapp.personal_data.views import pd_views
self.register_blueprint(pd_views)
am.init_relay(self, 'eduid_personal_data')
self.private_userdb = PersonalDataUserDB(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = SignupConfig.init_config(ns='webapp', app_name=name, test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: SignupConfig = cast(SignupConfig, self.config) # type: ignore
from eduid_webapp.signup.views import signup_views
self.register_blueprint(signup_views)
am.init_relay(self, 'eduid_signup')
mail_relay.init_relay(self)
translation.init_babel(self)
self.private_userdb = SignupUserDB(self.config.mongo_uri, 'eduid_signup')
self.proofing_log = ProofingLog(self.config.mongo_uri)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = MobileProofingConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: MobileProofingConfig = cast(MobileProofingConfig,
self.config) # type: ignore
# Register views
from eduid_webapp.lookup_mobile_proofing.views import mobile_proofing_views
self.register_blueprint(mobile_proofing_views)
# Init dbs
self.private_userdb = LookupMobileProofingUserDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
# Init celery
lookup_mobile_relay.init_relay(self)
msg.init_relay(self)
am.init_relay(self, 'eduid_lookup_mobile_proofing')
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = ActionsConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: ActionsConfig = cast(ActionsConfig,
self.config) # type: ignore
from eduid_webapp.actions.views import actions_views
self.register_blueprint(actions_views)
am.init_relay(self, f'eduid_{name}')
self.actions_db = ActionDB(self.config.mongo_uri)
self.plugins = PluginsRegistry(self)
for plugin in self.plugins.values():
plugin.includeme(self)
self.get_tous = types.MethodType(_get_tous, self)
def security_init_app(name, config):
"""
Create an instance of an eduid security (passwords) app.
First, it will load the configuration from security.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.security.views.security import security_views
from eduid_webapp.security.views.u2f import u2f_views
from eduid_webapp.security.views.webauthn import webauthn_views
from eduid_webapp.security.views.reset_password import reset_password_views
app.register_blueprint(security_views)
app.register_blueprint(u2f_views)
app.register_blueprint(webauthn_views)
app.register_blueprint(reset_password_views)
# Register view path that should not be authorized
app = no_authn_views(app, ['/reset-password.*'])
app = am.init_relay(app, 'eduid_security')
app = msg.init_relay(app)
app = mail_relay.init_relay(app)
app = translation.init_babel(app)
app.private_userdb = SecurityUserDB(app.config['MONGO_URI'])
app.authninfo_db = AuthnInfoDB(app.config['MONGO_URI'])
app.password_reset_state_db = PasswordResetStateDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def __init__(self, name: str, config: dict, **kwargs):
# Load acs actions on app init
from . import acs_actions
# Make sure pycharm doesn't think the import above is unused and removes it
if acs_actions.__author__:
pass
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = EidasConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: EidasConfig = cast(EidasConfig,
self.config) # type: ignore
self.saml2_config = get_saml2_config(self.config.saml2_settings_module)
# Register views
from eduid_webapp.eidas.views import eidas_views
self.register_blueprint(eidas_views)
# Register view path that should not be authorized
no_authn_views(
self, ['/saml2-metadata', '/saml2-acs', '/mfa-authentication'])
# Init dbs
self.private_userdb = EidasProofingUserDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
# Init celery
am.init_relay(self, 'eduid_eidas')
msg.init_relay(self)
def __init__(self, name: str, config: dict, **kwargs):
# Initialise type of self.config before any parent class sets a precedent to mypy
self.config = LetterProofingConfig.init_config(ns='webapp',
app_name=name,
test_config=config)
super().__init__(name, **kwargs)
# cast self.config because sometimes mypy thinks it is a FlaskConfig after super().__init__()
self.config: LetterProofingConfig = cast(LetterProofingConfig,
self.config) # type: ignore
# Register views
from eduid_webapp.letter_proofing.views import letter_proofing_views
self.register_blueprint(letter_proofing_views)
# Init dbs
self.private_userdb = LetterProofingUserDB(self.config.mongo_uri)
self.proofing_statedb = LetterProofingStateDB(self.config.mongo_uri)
self.proofing_log = ProofingLog(self.config.mongo_uri)
# Init celery
msg.init_relay(self)
am.init_relay(self, 'eduid_letter_proofing')
# Initiate external modules
self.ekopost = Ekopost(self)
def init_oidc_proofing_app(name, config):
"""
Create an instance of an oidc proofing app.
First, it will load the configuration from oidc_proofing.settings.common then any settings
given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
and finally all needed blueprints will be registered with it.
:param name: The name of the instance, it will affect the configuration loaded.
:param config: any additional configuration settings. Specially useful
in test cases
:type name: str
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.oidc_proofing.views import oidc_proofing_views
app.register_blueprint(oidc_proofing_views)
# Register view path that should not be authorized
app = no_authn_views(app, ['/authorization-response'])
# Initialize the oidc_client after views to be able to set correct redirect_uris
app.oidc_client = init_oidc_client(app)
# Init celery
app = msg.init_relay(app)
app = am.init_relay(app, 'eduid_oidc_proofing')
app = mail_relay.init_relay(app)
# Init babel
app = translation.init_babel(app)
# Initialize db
app.private_userdb = OidcProofingUserDB(app.config['MONGO_URI'])
app.proofing_statedb = OidcProofingStateDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
return app
def security_init_app(name, config):
"""
Create an instance of an eduid security (passwords) app.
First, it will load the configuration from security.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.security.views.security import security_views
from eduid_webapp.security.views.u2f import u2f_views
from eduid_webapp.security.views.reset_password import reset_password_views
app.register_blueprint(security_views)
app.register_blueprint(u2f_views)
app.register_blueprint(reset_password_views)
# Register view path that should not be authorized
app = no_authn_views(app, ['/reset-password.*'])
app = am.init_relay(app, 'eduid_security')
app = msg.init_relay(app)
app = mail_relay.init_relay(app)
app = translation.init_babel(app)
app.private_userdb = SecurityUserDB(app.config['MONGO_URI'])
app.authninfo_db = AuthnInfoDB(app.config['MONGO_URI'])
app.password_reset_state_db = PasswordResetStateDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def actions_init_app(name, config):
"""
Create an instance of an eduid actions app.
First, it will load the configuration from actions.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
Note that we use UnAuthnApp as the class for the Flask app,
since the actions app is used unauthenticated.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config, app_class=Flask)
app.config.update(config)
from eduid_webapp.actions.views import actions_views
app.register_blueprint(actions_views)
app = am.init_relay(app, 'eduid_actions')
app.actions_db = ActionDB(app.config['MONGO_URI'])
app.plugins = PluginsRegistry(app)
for plugin in app.plugins.values():
plugin.includeme(app)
app.get_tous = types.MethodType(_get_tous, app)
app.logger.info('Init {} app...'.format(name))
return app
def actions_init_app(name, config):
"""
Create an instance of an eduid actions app.
First, it will load the configuration from actions.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
Note that we use UnAuthnApp as the class for the Flask app,
since the actions app is used unauthenticated.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config, app_class=UnAuthnApp)
app.config.update(config)
app.config['CELERY_CONFIG']['MONGO_URI'] = app.config['MONGO_URI']
from eduid_webapp.actions.views import actions_views
app.register_blueprint(actions_views)
app = am.init_relay(app, 'eduid_actions')
app.actions_db = ActionDB(app.config['MONGO_URI'])
app.plugins = PluginsRegistry(app)
for plugin in app.plugins.values():
plugin.includeme(app)
app.logger.info('Init {} app...'.format(name))
return app
def signup_init_app(name, config):
"""
Create an instance of an eduid signup app.
First, it will load the configuration from signup.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
Note that we use UnAuthnApp as the class for the Flask app,
since obviously the signup app is used unauthenticated.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config, app_class=Flask)
app.config.update(config)
from eduid_webapp.signup.views import signup_views
app.register_blueprint(signup_views)
app = am.init_relay(app, 'eduid_signup')
app = mail_relay.init_relay(app)
app = translation.init_babel(app)
app.private_userdb = SignupUserDB(app.config['MONGO_URI'], 'eduid_signup')
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def email_init_app(name, config):
"""
Create an instance of an eduid email app.
First, it will load the configuration from email.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.email.views import email_views
app.register_blueprint(email_views)
app = am.init_relay(app, 'eduid_email')
app = mail_relay.init_relay(app)
app = translation.init_babel(app)
app.private_userdb = EmailProofingUserDB(app.config['MONGO_URI'])
app.proofing_statedb = EmailProofingStateDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def pd_init_app(name, config):
"""
Create an instance of an eduid personal data app.
First, it will load the configuration from personal_data.settings.common
then any settings given in the `config` param.
Then, the app instance will be updated with common stuff by `eduid_init_app`,
all needed blueprints will be registered with it,
and finally the app is configured with the necessary db connections.
:param name: The name of the instance, it will affect the configuration loaded.
:type name: str
:param config: any additional configuration settings. Specially useful
in test cases
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
app = eduid_init_app(name, config)
app.config.update(config)
from eduid_webapp.personal_data.views import pd_views
app.register_blueprint(pd_views,
url_prefix=app.config.get('APPLICATION_ROOT', None))
# XXX: Maybe we should extend eduid-dashboard or write a new amp to be able to narrow the
# XXX: attributes that can be changed by a sync call
app = am.init_relay(app, 'eduid_dashboard')
app.dashboard_userdb = DashboardUserDB(app.config['MONGO_URI'])
app.logger.info('Init {} app...'.format(name))
return app
def init_eidas_app(name, config=None):
"""
:param name: The name of the instance, it will affect the configuration loaded.
:param config: any additional configuration settings. Specially useful
in test cases
:type name: str
:type config: dict
:return: the flask app
:rtype: flask.Flask
"""
# Load acs actions on app init
from . import acs_actions
app = eduid_init_app(name, config)
app.saml2_config = get_saml2_config(app.config['SAML2_SETTINGS_MODULE'])
app.config['SAML2_CONFIG'] = app.saml2_config
# Register views
from eduid_webapp.eidas.views import eidas_views
app.register_blueprint(eidas_views)
# Register view path that should not be authorized
app = no_authn_views(app, ['/saml2-metadata', '/saml2-acs', '/mfa-authentication'])
# Init dbs
app.private_userdb = EidasProofingUserDB(app.config['MONGO_URI'])
app.proofing_log = ProofingLog(app.config['MONGO_URI'])
# Init celery
app = am.init_relay(app, 'eduid_eidas')
app = msg.init_relay(app)
app.logger.info('{!s} initialized'.format(name))
return app
