def gn_module_deactivate(module_code, activ_front, activ_back):
log.info("Desactivate module")
app = None
try:
app = create_app()
with app.app_context():
module = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code.upper())
.one()
)
module.active_frontend = not activ_front
module.active_backend = not activ_back
DB.session.merge(module)
DB.session.commit()
except NoResultFound:
raise GeoNatureError(
"""The module does not exist.
\n Check the gn_commons.t_module to get the module name"""
)
log.info("Regenerate frontend routes")
try:
frontend_routes_templating(app)
log.info("...%s\n", MSG_OK)
except Exception as e:
raise GeoNatureError(e)
def tsconfig_app_templating(app=None):
if not app:
app = create_app(with_external_mods=False)
with app.app_context():
log.info("Generating tsconfig.app.json")
with open(str(ROOT_DIR / "frontend/src/tsconfig.app.json.sample"),
"r") as input_file:
template = Template(input_file.read())
routes = []
for module in list_frontend_enabled_modules():
module_dir = Path(GN_EXTERNAL_MODULE /
module.module_code.lower())
# test if module have frontend
if (module_dir / "frontend").is_dir():
location = "{}/frontend/app".format(module_dir)
routes.append({"location": location})
# TODO test if two modules with the same name is okay for Angular
route_template = template.render(routes=routes)
with open(str(ROOT_DIR / "frontend/src/tsconfig.app.json"),
"w") as output_file:
output_file.write(route_template)
log.info("...%s\n", MSG_OK)
def gn_module_activate(module_code, activ_front, activ_back):
# TODO utiliser les commande os de python
log.info("Activate module")
app = None
# TODO gestion des erreurs
if not (GN_EXTERNAL_MODULE / module_code).is_dir():
raise GeoNatureError(
"Module {} is not activated (Not in external_module directory)".format(module_code)
)
else:
app = create_app()
with app.app_context():
try:
module = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code.upper())
.one()
)
module.active_frontend = activ_front
module.active_backend = activ_back
DB.session.merge(module)
DB.session.commit()
except NoResultFound:
raise GeoNatureError(
"""The module does not exist.
\n Check the gn_commons.t_module to get the module name"""
)
log.info("Generate frontend routes")
try:
frontend_routes_templating(app)
log.info("...%s\n", MSG_OK)
except Exception:
log.error("Error while generating frontend routing")
raise
def import_jdd_from_mtd(table_name):
"""
Import les JDD et CA (et acters associé) à partir d'une table (ou vue) listant les UUID des JDD dans MTD
"""
app = create_app()
with app.app_context():
from geonature.core.gn_meta.mtd.mtd_utils import import_all_dataset_af_and_actors
import_all_dataset_af_and_actors(table_name)
def pytest_sessionstart(session):
""" before session.main() is called. """
app = create_app()
app.config["TESTING"] = True
# push the app_context
ctx = app.app_context()
ctx.push()
logging.disable(logging.DEBUG)
# setup test data
execute_script("delete_sample_data.sql")
execute_script("sample_data.sql")
def dev_back(host, port):
"""
Lance l'api du backend avec flask
Exemples
- geonature dev_back
- geonature dev_back --port=8080 --port=0.0.0.0
"""
app = create_app()
app.run(host=host, port=int(port), debug=True)
def update_module_configuration(module_code, build):
"""
Génère la config frontend d'un module
Example:
- geonature update_module_configuration occtax
- geonature update_module_configuration --build False --prod False occtax
"""
app = create_app(with_external_mods=False)
with app.app_context():
create_module_config(app, module_code, build=build)
log.info("Pensez à relancer geonature (sudo systemctl restart geonature)")
def update_module_configuration(module_code, build, prod):
"""
Génère la config frontend d'un module
Example:
- geonature update_module_configuration occtax
- geonature update_module_configuration --build False --prod False occtax
"""
if prod:
subprocess.call(["sudo", "supervisorctl", "reload"])
app = create_app(with_external_mods=False)
with app.app_context():
create_module_config(app, module_code, build=build)
def frontend_routes_templating(app=None):
if not app:
app = create_app(with_external_mods=False)
with app.app_context():
log.info("Generating frontend routing")
# recuperation de la configuration
configs_gn = app.config
with open(
str(ROOT_DIR /
"frontend/src/app/routing/app-routing.module.ts.sample"),
"r") as input_file:
template = Template(input_file.read())
routes = []
for module_object in list_frontend_enabled_modules():
module_dir = Path(GN_EXTERNAL_MODULE /
module_object.module_code.lower())
# test if module have frontend
if (module_dir / "frontend").is_dir():
path = module_object.module_path.lstrip("/")
location = "{}/{}#GeonatureModule".format(
module_dir, GN_MODULE_FE_FILE)
routes.append({
"path": path,
"location": location,
"module_code": module_object.module_code
})
# TODO test if two modules with the same name is okay for Angular
route_template = template.render(
routes=routes,
enable_user_management=configs_gn["ACCOUNT_MANAGEMENT"].get(
"ENABLE_USER_MANAGEMENT"),
enable_sign_up=configs_gn["ACCOUNT_MANAGEMENT"].get(
"ENABLE_SIGN_UP"),
)
with open(
str(ROOT_DIR /
"frontend/src/app/routing/app-routing.module.ts"),
"w") as output_file:
output_file.write(route_template)
log.info("...%s\n", MSG_OK)
def update_module_configuration(module_code, build):
"""
Génère la config frontend d'un module
Example:
- geonature update_module_configuration occtax
- geonature update_module_configuration --build False --prod False occtax
"""
app = create_app(with_external_mods=False)
with app.app_context():
create_module_config(app, module_code, build=build)
log.info(
"Si vous avez changé des paramtères de configuration nécessaire au backend, "
"pensez à également relancer ce dernier.")
def app():
app = create_app()
app.testing = True
app.test_client_class = JSONClient
app.config['SERVER_NAME'] = 'test.geonature.fr' # required by url_for
with app.app_context():
"""
Note: This may seem redundant with 'temporary_transaction' fixture.
It is not as 'temporary_transaction' has a function scope.
This nested transaction is useful to rollback class-scoped fixtures.
Note: As we does not have a complex savepoint restart mechanism here,
fixtures must commit their database changes in a nested transaction
(i.e. in a with db.session.begin_nested() block).
"""
transaction = db.session.begin_nested() # execute tests in a savepoint
yield app
transaction.rollback() # rollback all database changes
def app():
app = create_app()
app.config["TESTING"] = True
app.config["WTF_CSRF_ENABLED"] = False
return app
def install_gn_module(module_path, url, conf_file, build, enable_backend):
"""
Installation d'un module gn
"""
try:
# Indique si l'utilisateur est en train de
# réaliser une installation du module
# et non pas une mise à jour
# Permet qu'en cas d'erreur à l'installation de supprimer
# les traces d'installation de ce module
fresh_install = False
# Vérification que le chemin module path soit correct
if not Path(module_path).is_dir():
raise GeoNatureError("dir {} doesn't exists".format(module_path))
# TODO vérifier que l'utilisateur est root ou du groupe geonature
app = create_app(with_external_mods=False)
with app.app_context():
sys.path.append(module_path)
# Vérification de la conformité du module
# Vérification de la présence de certain fichiers
check_gn_module_file(module_path)
# Vérification de la version de geonature par rapport au manifest
module_code = None
module_code = check_manifest(module_path)
try:
# Vérification que le module n'est pas déjà activé
DB.session.query(TModules).filter(
TModules.module_code == module_code).one()
except NoResultFound:
try:
# Si le module n'est pas déjà dans la table gn_commons.t_modules, on l'installe
# sinon on leve une execption et on arrête la commande
# Installation des dépendances python
gn_module_import_requirements(module_path)
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# copie dans external mods:
copy_in_external_mods(module_path, module_code.lower())
# creation du lien symbolique des assets externes
enable_frontend = create_external_assets_symlink(
module_path, module_code.lower())
# ajout du module dans la table gn_commons.t_modules
fresh_install = add_application_db(app, module_code, url,
enable_frontend,
enable_backend)
# Installation du module
run_install_gn_module(app, module_path)
# Enregistrement de la config du module
gn_module_register_config(module_code)
if enable_frontend:
install_frontend_dependencies(module_path)
# generation du fichier tsconfig.app.json
tsconfig_app_templating(app=app)
# generation du routing du frontend
frontend_routes_templating(app=app)
# generation du fichier de configuration du frontend
create_module_config(app, module_code, build=False)
if build and enable_frontend:
# Rebuild the frontend
build_geonature_front(rebuild_sass=True)
# finally restart geonature backend via supervisor
subprocess.call(
["sudo", "supervisorctl", "restart", "geonature2"])
except Exception as e:
log.error("%s", e)
raise GeoNatureError(
"Error during module {} installation".format(
module_code)) # noqa
else:
raise GeoNatureError(
"The module {} is already installed, but maybe not activated"
.format(module_code)) # noqa
except (GNModuleInstallError, GeoNatureError) as ex:
log.critical((
"\n\n\033[91mError while installing GN module \033[0m.The process returned:\n\t{}"
).format(ex))
# S'il y a une erreur lors de l'installation initiale du module
# suppression de ce module
if fresh_install:
remove_application_db(app, module_code)
sys.exit(1)
class ReverseProxied(object):
def __init__(self, app, script_name=None, scheme=None, server=None):
self.app = app
self.script_name = script_name
self.scheme = scheme
self.server = server
def __call__(self, environ, start_response):
script_name = environ.get("HTTP_X_SCRIPT_NAME", "") or self.script_name
if script_name:
environ["SCRIPT_NAME"] = script_name
path_info = environ["PATH_INFO"]
if path_info.startswith(script_name):
environ["PATH_INFO"] = path_info[len(script_name):]
scheme = environ.get("HTTP_X_SCHEME", "") or self.scheme
if scheme:
environ["wsgi.url_scheme"] = scheme
server = environ.get("HTTP_X_FORWARDED_SERVER", "") or self.server
if server:
environ["HTTP_HOST"] = server
return self.app(environ, start_response)
# give the app context from server.py in a app object and filter sqlalchemy warning
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=sa_exc.SAWarning)
app = create_app()
app.wsgi_app = ReverseProxied(app.wsgi_app,
script_name=urlparse(
app.config["API_ENDPOINT"]).path)