def gn_module_activate(module_code, activ_front, activ_back):
from geonature.core.gn_commons.models import TModules
# 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 = get_app_for_cmd(DEFAULT_CONFIG_FILE)
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 gn_module_deactivate(module_code, activ_front, activ_back):
log.info("Desactivate module")
from geonature.core.gn_commons.models import TModules
app = None
try:
app = get_app_for_cmd(DEFAULT_CONFIG_FILE)
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 gn_module_deactivate(module_code, activ_front, activ_back):
log.info("Desactivate module")
from geonature.core.gn_commons.models import TModules
app = None
try:
app = get_app_for_cmd(DEFAULT_CONFIG_FILE)
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 gn_module_activate(module_name, activ_front, activ_back):
# TODO utiliser les commande os de python
log.info("Activate module")
# TODO gestion des erreurs
if not (GN_EXTERNAL_MODULE / module_name).is_dir():
raise GeoNatureError(
"Module {} is not activated (Not in external_module directory)".
format(module_name))
else:
app = get_app_for_cmd(DEFAULT_CONFIG_FIlE)
with app.app_context():
try:
module = DB.session.query(TModules).filter(
TModules.module_name == module_name).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()
log.info("...ok\n")
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 = get_app_for_cmd()
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 add_application_db(module_name, url, module_id=None):
log.info('Register the module in t_application ... \n')
app_conf = load_config(DEFAULT_CONFIG_FIlE)
id_application_geonature = app_conf['ID_APPLICATION_GEONATURE']
app = get_app_for_cmd(DEFAULT_CONFIG_FIlE)
try:
with app.app_context():
# if module_id: try to insert in t_application
# check if the module in TApplications
if module_id is None:
try:
exist_app = None
exist_app = DB.session.query(TApplications).filter(
TApplications.nom_application == module_name).one()
except NoResultFound:
# if no result, write in TApplication
new_application = TApplications(
nom_application=module_name,
id_parent=id_application_geonature)
DB.session.add(new_application)
DB.session.commit()
DB.session.flush()
module_id = new_application.id_application
else:
log.info('the module is already in t_application')
finally:
module_id = module_id if module_id is not None else exist_app.id_application
# try to write in gn_commons.t_module if not exist
try:
module = DB.session.query(TModules).filter(
TModules.module_name == module_name).one()
except NoResultFound:
update_url = "{}/#/{}".format(app_conf['URL_APPLICATION'], url)
new_module = TModules(id_module=module_id,
module_name=module_name,
module_label=module_name.title(),
module_url=update_url,
module_target="_self",
module_picto="extension",
active_frontend=True,
active_backend=True)
DB.session.add(new_module)
DB.session.commit()
else:
log.info('the module is already in t_module, reactivate it')
module.active = True
DB.session.merge(module)
DB.session.commit()
except Exception as e:
raise GeoNatureError(e)
log.info('... ok \n')
return module_id
def dev_back(host, port, conf_file):
"""
Lance l'api du backend avec flask
Exemples
- geonature dev_back
- geonature dev_back --port=8080 --port=0.0.0.0
"""
app = get_app_for_cmd(conf_file)
app.run(host=host, port=int(port), debug=True)
def dev_back(host, port, conf_file):
"""
Lance l'api du backend avec flask
Exemples
- geonature dev_back
- geonature dev_back --port=8080 --port=0.0.0.0
"""
app = get_app_for_cmd(conf_file)
app.run(host=host, port=int(port), debug=True)
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 = get_app_for_cmd(with_external_mods=False)
create_module_config(app, module_code.lower(), build=build)
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 = get_app_for_cmd(with_external_mods=False)
create_module_config(app, module_code.lower(), build=build)
def gn_module_deactivate(module_name, activ_front, activ_back):
log.info('Desactivate module')
try:
app = get_app_for_cmd(DEFAULT_CONFIG_FIlE)
with app.app_context():
module = DB.session.query(TModules).filter(
TModules.module_name == module_name).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()
log.info("...ok\n")
except Exception as e:
raise GeoNatureError(e)
def gn_module_activate(module_code, activ_front, activ_back):
from geonature.core.gn_commons.models import TModules
# 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 = get_app_for_cmd(DEFAULT_CONFIG_FILE)
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 list_frontend_enabled_modules(mod_path=GN_EXTERNAL_MODULE):
"""
Get all the module frontend enabled from gn_commons.t_modules
"""
from geonature.utils.command import get_app_for_cmd
from geonature.core.gn_commons.models import TModules
app = get_app_for_cmd(DEFAULT_CONFIG_FILE, with_external_mods=False)
with app.app_context():
data = DB.session.query(TModules).filter(
TModules.active_frontend == True).all()
enabled_modules = [d.as_dict()['module_name'] for d in data]
for f in mod_path.iterdir():
if f.is_dir():
conf_manifest = load_and_validate_toml(str(f / 'manifest.toml'),
ManifestSchemaProdConf)
class GnModuleSchemaProdConf(GnModuleProdConf):
pass
conf_module = load_and_validate_toml(
str(f / 'config/conf_gn_module.toml'), GnModuleSchemaProdConf)
if conf_manifest['module_name'] in enabled_modules:
yield conf_module, conf_manifest
def install_gn_module(module_path, url, conf_file, build, enable_backend):
"""
Installation d'un module gn
"""
try:
# 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 = get_app_for_cmd(conf_file, with_external_mods=False)
with app.app_context():
from geonature.core.gn_commons.models import TModules
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é
mod = (DB.session.query(TModules).filter(
TModules.module_code == module_code).one())
except NoResultFound:
# 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
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# Installation du module
run_install_gn_module(app, module_path)
# 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
add_application_db(app, module_code, url, enable_frontend,
enable_backend)
# Enregistrement de la config du module
gn_module_register_config(module_code.lower())
if enable_frontend:
# generation du du routing du frontend
frontend_routes_templating(app)
# generation du fichier de configuration du frontend
create_module_config(app,
module_code.lower(),
module_path,
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"])
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(module_code, ex))
sys.exit(1)
def install_gn_module(module_path, url, conf_file, build):
"""
Installation d'un module gn
"""
try:
# 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 = get_app_for_cmd(conf_file, with_external_mods=False)
with app.app_context():
from geonature.core.gn_commons.models import TModules
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é
mod = (
DB.session.query(TModules)
.filter(TModules.module_code == module_code)
.one()
)
except NoResultFound:
# 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
# Vérification de la conformité du code :
# installation
# front end
# backend
check_codefile_validity(module_path, module_code)
# Installation du module
run_install_gn_module(app, module_path)
# 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
add_application_db(app, module_code, url, enable_frontend)
# Enregistrement de la config du module
gn_module_register_config(module_code.lower())
if enable_frontend:
# generation du du routing du frontend
frontend_routes_templating(app)
# generation du fichier de configuration du frontend
create_module_config(
app, module_code.lower(), module_path, 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"])
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(module_code, ex)
)
sys.exit(1)
